graph-engineering

Compose installed agent skills into orchestrated multi-agent graphs with adversarial verification.

Updated May 18, 2024
One-click install
npx skills add https://github.com/joshhornby/dotfiles --skill graph-engineering-joshhornby
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: graph-engineering
Source: https://github.com/joshhornby/dotfiles/tree/main/.claude/skills/graph-engineering
Command: npx skills add https://github.com/joshhornby/dotfiles --skill graph-engineering-joshhornby

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Complex tasks like multi-lens code reviews, audits, and migrations often need several skills applied in parallel, but running them in one context blurs each lens and produces unverified, prose-only results. This Skill turns a library of installed skills into a coordinated agent graph where each sub-agent node loads exactly one skill, works a bounded scope, and returns schema-shaped findings that are independently verified before synthesis. ## Core Features & Use Cases - Skills-as-nodes orchestration: Design a graph where each node is a sub-agent loading one skill, with typed edges (needs, informs, excludes) and stage patterns like fan-out, pipeline, adversarial verify, and judge panel. - Structured contracts and verification: Every stage returns schema-shaped data with file:line evidence and fixed severity levels; independent verifier nodes attempt to refute each finding, and unverifiable claims are labelled rather than dropped. - Three runtimes: Run via the Workflow tool (dynamic workflows with schema enforcement and resume), Agent-tool fan-out, or a sequential degraded mode when no sub-agent mechanism exists. - Use Case: Reviewing a large pull request through five architectural lenses — scout the diff inline, fan out one node per lens, dedup findings, verify each adversarially, and deliver one ranked, evidence-linked report. ## Quick Start Ask the agent to use graph engineering to fan out one sub-agent per relevant skill over your target scope, verify the findings adversarially, and synthesize a single ranked deliverable.

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 agent skills in one workflow?

Design an agent graph: scout the scope inline, map each responsibility to one installed skill per node, fan the nodes out in parallel, then verify findings adversarially and synthesize one deliverable. Each node gets a bounded brief with an output schema, never your session history.

What is the orchestrator-workers pattern for AI agents?

Orchestrator-workers is a pattern where one orchestrator decomposes a task, dispatches sub-agents (workers) with isolated contexts, and synthesizes their structured results. This Skill implements it as an agent graph with stages for fan-out, dedup, adversarial verification, and synthesis.

When should I not use a multi-agent graph?

Skip the graph when one skill in one context handles the task, when steps form a single chain needing full prior context, or when the user has not opted into multi-agent scale. A graph of one node is ceremony, and fan-outs cost real tokens.

How does adversarial verification work in an agent graph?

Each surviving finding goes to an independent verifier node instructed to refute it against the actual code. Verdicts are confirmed, refuted, or unverifiable; unverifiable claims are reported rather than silently dropped, and high-stakes runs use multiple verifiers with majority rule.

Can sub-agents run in parallel when they write files?

Writes are serial by default; reads parallel freely. Two writers run concurrently only when they have disjoint owned paths, no shared open decision, independently verifiable outputs, and workspace isolation such as git worktrees, with edges typed as needs, informs, or excludes.

What happens if there is no Workflow or Agent tool available?

The Skill falls back to sequential degraded mode: load each skill in turn in your own context, record per-lens findings, then self-verify and synthesize. The output is labelled as a single-context run since isolation and independent verification are weakened.