Questions
Straight answers
The questions I get asked most about building with agents — and the ones the field is currently arguing about. Each answer is short on purpose and points at the piece that covers it properly.
The vocabulary
The words moving fastest right now, and the two places they get used inconsistently.
What is graph engineering?
Designing agent work as a graph rather than a straight line: nodes do the jobs, edges carry what crosses between them, independent nodes run at once, and a barrier is where parallel work merges. The underlying idea is old — data pipelines have been drawn as directed acyclic graphs for decades. What's new is that the jobs are now agents, and most people are still writing lists.
The shape of the work is a graphWhat's the difference between harness, loop and graph engineering?
Be careful here, because those three words are currently used in two incompatible ways. Some writing puts them side by side as three sibling layers. C² nests them instead: prompt sits inside context sits inside harness, where a harness is the gather → act → verify machine around the model — so C² is a harness methodology, and the loop and the graph are things inside it, not beside it. Concretely: the brief is a node, execution inside that node is a loop, and the plan draws the graph between nodes.
What is an agent harness?What is loop engineering?
Designing the repeated work-and-feedback cycle an agent runs — the trigger, the action, the check, and above all the stop rule. The failure it addresses is an agent that almost works: close-but-weak output, inconsistent success, no proof it finished. In C² that loop is the per-item read → implement → review → verify → commit cycle, and its stop condition is the anchor.
Don't loop on confidence. Loop on evidence.What is context engineering?
The discipline of curating what an agent knows before it acts — what to load, what to leave out, and what to keep across sessions. It overtook prompt engineering because the model stopped being the bottleneck and the context around it started being one. Prompt engineering tunes one message. Context engineering decides what the agent has read.
Context engineering, explainedWhat is a node contract?
The specification that makes one agent's job safe to run alongside others: bounded input, exactly one job, and an output something other than the agent can confirm. Without it a fan-out returns twelve confident, mutually incompatible answers. C² has shipped this for two years under a different name — the prompt brief.
The prompt brief is a node contractWhat is a fan-out, and what is a barrier?
A fan-out is several independent jobs running at the same time. A barrier is the point where their results come back together — the merge, the integration brief, the pull request. A barrier makes every branch wait for the slowest one, so it needs a real cross-branch dependency to justify it rather than tidiness.
Fan out, isolate, merge through a barrierRunning agents in parallel
The question underneath most multi-agent advice, and the two checks that settle it.
Can you run multiple AI coding agents at the same time?
Yes, when two things are true: no edge connects the work, and no surface is shared. An edge means one agent's output is another's input. A surface is everything an agent mutates or contends for — files, data, a rate-limited API, one deploy target. Two agents on one surface is the anti-pattern regardless of how many you run.
The decision procedure, in fullHow many AI agents should I run at once?
The number was never the variable, which is why advice phrased as a number keeps missing. I once ran 5 agents on one feature and got a mess — but the problem was that all 5 shared one branch and one settings object, not that there were 5. Two would have failed identically, and twelve on twelve disjoint surfaces would have been fine.
The field noteWhy do parallel AI agents conflict with each other?
Almost always because they share something nobody declared. The obvious version is two agents editing the same files. The version that actually bites is false independence — two agents whose instructions never mention each other, both writing to one staging database or burning the same API quota. Nothing in either brief says the resource is shared, so nobody sees it coming.
Edges, surfaces and false independenceDo git worktrees make parallel agents safe?
They make the filesystem safe, and nothing else. A worktree gives each agent its own checkout so they can't overwrite each other's files. Two agents in two spotless worktrees still collide if they both write to the same database or deploy to the same target.
Worktrees, and what they don't fixMaking agents reliable
How you know work is actually done, when the thing reporting it is fluent.
How do you know when an AI agent has actually finished?
When something the agent can't produce by asserting it says so. A test that ran and passed. A query that returned rows. A deploy that resolved. That signal is the anchor, and "the agent says it's done" is a report about the work rather than the work.
Anchors and frozen rulesWhy do AI agents report success on work that's broken?
Because completing a task and reporting completion are two different actions, and only the second one is always available. A model producing a plausible final message will produce one whether or not the work holds. It isn't lying — nothing in the loop ever required it to check.
Why consistency isn't verificationDoes adding more review agents fix hallucinated results?
Not on its own. If every reviewer is reading another agent's report rather than a real signal, you get a system that's internally consistent and entirely unverified — it fails the same way one agent fails, later and with more green lights on the way down. At least one node has to touch something outside the conversation.
Independent review that means somethingMy agent is stuck. What should I check first?
Whether it could physically do the job, before you assume it couldn't think. Missing tool access, expired credentials, an environment that differs from the one you assumed — these produce confident nonsense that reads exactly like a reasoning failure. Name the layer that owns the failure — the environment, the loop, or the topology — then escalate into that layer.
The triage ruleGetting started
Where to begin, and the thing most people reach for too early.
When should I start building agent workflows or graphs?
Later than the current enthusiasm suggests. Diagramming a large workflow before you've watched the work behave produces brittle structure encoding assumptions you never checked — and structure is much harder to change than instructions. If you aren't already running concurrent agents behind a verification loop you trust, the loop is your next move, not the graph.
Topology is earned, not adoptedHow do I measure how far along my team is with AI agents?
On two axes, not one. The first is the risk of the work you trust agents with — small fixes, then features behind review, then autonomous well-fenced runs. The second is how many agents you run and what that makes you. They move independently, so a team can be advanced on one and a beginner on the other, and a single maturity score hides exactly that.
The two laddersWhat's the first thing to do if I'm new to building with agents?
Write down what the agent needs to know, in a file, in git. One agent, one brief, one loop — and a short note at the end of every session saying what changed and what's next. That habit is what everything else compounds on, and it's the whole investment for the first few weeks.
Run your first sessionAbout C²
What the method is, and what it costs you.
What is the C² Method?
An open build method for working with AI coding agents, built on one idea: every project runs two systems, a codebase (what runs) and a contextbase (what guides). Most methods optimise only the first. C² treats context as a version-controlled asset the agent reads before it acts, so it compounds across sessions instead of being reloaded every time.
Read the methodWhat is a contextbase?
The folder of markdown your agent reads before it acts — briefs, decisions, gotchas, session notes — living in the same repository as the code. Chat history evaporates when the session ends. A contextbase is in git, so the next session and the next agent both start from it.
What is a contextbase?Is C² tied to a particular AI agent or vendor?
No, and that's deliberate. The whole contextbase is plain markdown, so anything that reads files can use it — the router file is just named for whichever agent you run. When a better model ships, you adopt it and the context transfers intact.
C² vs native rule filesWhat does C² actually ask of me?
Discipline at the two moments you least want it. Writing the brief before you start, when you'd rather be building. Writing down what you learned at the end, when you feel finished. That's the honest cost, and it's the real one — the method moves work earlier and asks you to record things at the moment the temptation to skip is strongest.
The method in fullNothing here is for sale. The method is free and open, and the fastest way to judge it is to run one session with it.