graph latch

    1

    A deterministic protocol for orchestrating complex multi-step engineering tasks via dependency-derived task graphs.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    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 IDGoalDependenciesWrite Scope
    BK-01Update /login to set HttpOnly cookieNoneserver/auth/
    BK-02Update middleware to read from cookiesBK-01server/middleware/
    FE-01Configure Axios to use withCredentialsBK-02client/src/api/
    FE-02Remove local storage logic and cleanupFE-01client/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:

    1. Execute BK-01 to implement the cookie-setting logic in the backend.
    2. Verify the presence of the secure; httpOnly flags in the response headers.
    3. 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

    1. Establish the Contract by reading project context and defining "done when" predicates using TASK_CONTRACT.md.
    2. Build the Graph by mapping dependencies into task-graph.json and validating structure with scripts/validate_graph.py.
    3. Dispatch Tasks to workers with strict write-scope isolation and interface constraints.
    4. 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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 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

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed9 days ago

    What's inside

    Frequently Asked Questions

    GraphLatch is designed for any coding agent capable of file manipulation and shell execution, such as Claude Dev, Aider, or custom GPT-based engineering agents. It operates through a framework-agnostic protocol rather than a specific API integration.

    You receive the core orchestration protocol, Markdown templates for task contracts, the `task-graph.json` schema, and a Python-based utility script for validating graph integrity and detecting circular dependencies.

    While simple prompts often lead to "context drift" or infinite loops during large tasks, GraphLatch enforces a Directed Acyclic Graph (DAG) that isolates failures and requires objective evidence for task completion. This ensures complex migrations stay on track even when the agent's internal memory becomes crowded.

    GraphLatch is specifically optimized for high-complexity, multi-file engineering tasks like framework migrations and architectural refactors. For simple one-file edits or basic Q&A, the overhead of defining a task contract and DAG may be unnecessary.

    To prevent infinite loops and resource exhaustion, GraphLatch implements a "Bounded Correction" rule that limits an agent to three repair attempts per node. If a task cannot be verified within these cycles, the protocol triggers a hard stop for human intervention rather than continuing to burn tokens.

    New in Agents & Orchestration