graph-engineering

Orchestrates interdependent multi-agent work as a contract-first execution graph with independent per-node verification.

3|Updated Nov 8, 2014
One-click install
npx skills add https://github.com/mintuz/.dotfiles --skill graph-engineering-mintuz
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: graph-engineering
Source: https://github.com/mintuz/.dotfiles/tree/main/agents/.agents/skills/graph-engineering
Command: npx skills add https://github.com/mintuz/.dotfiles --skill graph-engineering-mintuz

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Coordinating multiple AI agents on interdependent specs, stories, or work items often collapses into unverified parallel fan-out: agents conflict on shared files, judge their own work, and drift from the original goal. This Skill turns that chaos into a scheduled execution graph where correctness is defined before implementation and every node is verified independently. ## Core Features & Use Cases - Contract-first planning: Derives a verification contract from governing specs before any node runs, splitting assertions into static and behavioral lanes with recorded sources and revisions. - Graph cutting and scheduling: Cuts nodes at judging seams with bounded write scopes, draws typed edges (needs, informs, excludes), defaults writers to serial execution, and renders the graph as an approval-gated Mermaid diagram. - Independent verification and checkpoints: Assigns each node a fresh-context verifier, runs reference-judged assertions through budgeted gauntlet loops, integrates at checkpoints, and reports a full ledger of verdicts and evidence. - Use Case: Given three interdependent feature specs, produce an approved execution graph, dispatch workers into isolated worktrees on Claude Code workflows or Codex managed threads, verify each node independently, and integrate only what passes. ## Quick Start Use the graph-engineering skill to turn these specs into an execution graph with a verification contract, scheduled nodes, and an independent verifier per node.

Frequently Asked Questions about graph-engineering

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I orchestrate multiple AI agents on interdependent tasks?

Build an execution graph: fix a verification contract from the governing specs, cut nodes at judging seams with bounded write scopes, draw typed edges (needs, informs, excludes), and schedule writers serially by default. Render the graph as Mermaid and get user approval before dispatching any node.

When should I use an execution graph instead of parallel agent fan-out?

Use a graph only when units depend on, inform, or exclude each other, such as shared write scopes or single-writer resources. When no unit writes and none depends on another, run plain concurrent reads with no contract, ledger, or verifier.

Does graph-engineering work with Claude Code and Codex?

Yes. On Claude Code it maps nodes to agent() calls in a Workflow script with schema-enforced outputs and worktree isolation. On Codex it maps nodes to durable managed threads, with the coordinator maintaining a written ledger as the authoritative schedule.

How does independent verification of agent work prevent false passes?

Each node gets a fresh-context verifier that receives only the assertions and the real artifact, never the worker's narration or rationale. Verifiers run static checks and exercise the running system, returning pass, fail, or unjudgeable per assertion with recorded commands and exit codes.

What happens when a provider usage limit is hit mid-run?

A heartbeat monitor tracks headroom and triggers a pause protocol at 90% of any limit: the frontier freezes, in-flight nodes write partial handoffs, the ledger is saved, and a resume is scheduled for the limit window reset. On resume, the frontier is recomputed from actual repository state.

When can two agent nodes safely run concurrently?

Concurrent writers are allowed only when all four conditions hold: disjoint owned paths including lockfiles, no shared open decision, independent verifiability, and workspace-level isolation such as separate worktrees. Otherwise writes stay serial because reconciliation costs more than the time saved.