- Home
- Skills
- Agents & Orchestration
- graph latch
graph latch
A deterministic protocol for orchestrating complex multi-step engineering tasks via dependency-derived task graphs.
$5
Works with the AI Agents you already use
graph latch
Example session with this skill installed
Use GraphLatch to plan the migration of the user authentication logic from JWT-based local storage to HttpOnly cookies across the frontend and backend.
- Read your context and instructions
- Compiled the graph latch
I have established the task contract and generated the dependency graph for the authentication migration. The plan ensures the backend set-cookie implementation precedes the frontend storage removal to prevent service interruption.
Engineering Report: Authentication Migration Plan
Goal: Migrate session management from JWT in local storage to HttpOnly cookies.
Contract Summary:
Done when: Set-Cookie header is present in /login response, frontend uses credentials for API calls, and local storage keys are purged.
- Constraints: No changes to the underlying passport.js strategy; must maintain IE11 compatibility.
Task Graph (Validated):
| Node ID | Goal | Dependencies | Write Scope |
|---|---|---|---|
BK-01 | Update /login to set HttpOnly cookie | None | server/auth/ |
BK-02 | Update middleware to read from cookies | BK-01 | server/middleware/ |
FE-01 | Configure Axios to use withCredentials | BK-02 | client/src/api/ |
FE-02 | Remove local storage logic and cleanup | FE-01 | client/src/store/ |
Validation Commands:
python3 scripts/validate_graph.py task-graph.json(Result: Valid, 0 cycles)./check.sh auth-integration-suite(Pending execution)
Next steps:
- Execute
BK-01to implement the cookie-setting logic in the backend. - Verify the presence of the
secure; httpOnlyflags in the response headers. - Proceed to update the middleware once headers are verified.
Connects securely to your tools. The creator never sees your data.
About this skill
Large-scale engineering tasks often collapse under their own weight when agents lack clear boundaries, dependency management, or failure isolation. GraphLatch provides a deterministic protocol for orchestrating multi-step, multi-file engineering work through explicit task contracts and dependency-derived Directed Acyclic Graphs (DAGs). It replaces vague prompting with a rigorous operating method that treats complex refactors and migrations as structured execution graphs.
What it does
- Task Contract Definition creates observable goals, constraints, and objective acceptance predicates before work begins.
- DAG Construction decomposes work into small, independently verifiable nodes with defined inputs, outputs, and dependency paths.
- Dependency Validation uses a bundled Python script to check for cycles and logical breaks in the task graph.
- Isolated Execution enforces write-scope boundaries and manages parallel dispatch to prevent resource or file-system conflicts.
- Bounded Correction Loops limits implementation attempts to three cycles, preventing infinite loops and repetitive failure patterns.
- Risk Gating categorizes actions into allow, ask, and deny buckets to manage side effects and unauthorized changes.
How it works
- Establish the Contract by reading project context and defining "done when" predicates using
TASK_CONTRACT.md. - Build the Graph by mapping dependencies into
task-graph.jsonand validating structure withscripts/validate_graph.py. - Dispatch Tasks to workers with strict write-scope isolation and interface constraints.
- Execute and Verify using build-check-correct loops and evidence-backed completion reports.
Frameworks & tools
This skill is framework-agnostic and works with any coding agent capable of file inspection and shell command execution. It includes a Python-based graph validator and Markdown-based templates for state tracking and contract management.
Why this beats prompting it yourself
Relying on an agent's internal reasoning for complex refactors often leads to scope creep and circular dependencies. GraphLatch forces an external, deterministic structure that persists state, isolates failures, and ensures every change is backed by an actual check rather than a hallucinated pass.
Use cases
- Multi-file Refactoring where changing one interface impacts dozens of downstream consumers.
- Legacy Migrations requiring step-by-step verification of state and data integrity.
- Bug Investigations involving multiple workstreams and concurrent diagnostic paths.
- Distributed Agent Orchestration where work must be safely delegated across multiple workers or worktrees.
Known limitations
Overhead is unsuitable for trivial one-file edits or simple questions. Parallel execution requires support for Git worktrees or isolated workspaces to prevent file conflicts.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.
Planning overhead makes it unsuitable for trivial edits. Parallel execution requires isolated workspaces or serial execution. Python is required for graph validation.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 9 days ago
- Software
Git