Agent Mechanics

Engineering promise

Make agents runnable. Then make them trustworthy.

Agent Mechanics does not rank frameworks. It uses real source code, fault injection, and reproducible labs to turn stopping, recovery, verification, permissions, memory, and multi-agent coordination into mechanisms you can inspect.

Four mechanism questions

1. How does it stop?Who decides completion, and what happens when the budget ends?
2. How does it resume?Which state can be replayed safely after the process dies?
3. How is it verified?What external fact counts after the model says done?
4. How does it split?Which work belongs to agents, code, tools, and humans?

See the mechanism map in 10 minutes →

Enter by current problem

You do not need to read in order.

Choose the failure happening now. Each route gives the boundary and decision first, then leaves source code, diagrams, and implementation detail for deeper verification.

01First visit? Build the architecture map.The roles, boundaries, and central trade-off axis of four systemsOverview →02The agent keeps retrying. Who stops it?Stopping rules, budgets, error compaction, and event logsAgent Loop →03Context keeps growing. How can it compact without losing state?Context assembly, compaction triggers, and recovery boundariesContext →04What may tools do, and when must a human approve?Permissions, approvals, policy, and side-effect boundariesPermissions →05After a process exits, where does the session resume?Persistence, replay, idempotency, and recovery invariantsRecovery →06Multi-agent coordination runs away. Who owns the state?Nodes, edges, state ownership, and human gatesGraph →

Hands-on labs

Every reading path should leave a runnable artifact.

Three standard-library Python labs turn recovery protocols, tool gates, and context budgets into objects you can fault-test, rerun, and submit with an acceptance report.

LAB 01Kill the process after the effect commits but before the result is durableArtifact: append-only events, operation IDs, recovery and deduplication report45 min →LAB 02Turn allow / ask / deny into an execution boundaryArtifact: schema validation, action-bound approval token, and audit log40 min →LAB 03Pressure-test context at 40% / 75% / 92% occupancyArtifact: context budget, protected segments, compaction policy, and injection scan35 min →

Open the full lab route and submission format →

Core trade-off

Decide whether you need control or autonomy.

This isn’t a leaderboard. The systems sit on one trade-off axis: toward the left, every step is auditable; toward the right, cross-session memory buys long-term autonomy.

One axis, four product judgments. There is no overall winner — only a match for your cost of failure.

System evidence

Don’t copy their shape. Copy their judgment.

CodexDistrust model self-evaluation; make the loop replayableFor coding work that tests and patches can verifyClaude CodeLabel every continuation reason; turn the black box into a state machineFor IDE agents needing careful compaction and observabilityOpenClawTreat the agent as a session control plane; make routing and hooks first-classFor multi-channel, multi-user, plugin-driven runtimesHermesSpread verification across time; trade memory and reflection for convergenceFor long-running assistants that learn across sessions

Apply the findings

Turn mechanism judgments into constraints for the next build.

build-your-own-agent compresses the conclusions into 10 hard rules, an 8-dimension selection matrix, a Python scaffold, diagnostics, and a security checklist.

Open the companion Skill →