Every Agent Is Growing a Repo-Local Contract

Four days ago I wrote about one specific pattern: version the workflow contract with the code.

That point still stands, but the broader pattern is bigger than WORKFLOW.md.

After digging through a wave of recent agent projects, the convergence is obvious:

Cline has .cline/
Continue has .continue/
Cursor has .cursor/
OpenCode has .opencode/
Flow-Next has .flow/
oh-my-codex has CODEX.md and WORKFLOW.md plus explicit runtime coverage

Different teams, different tastes, same destination:

serious agent systems keep growing a repo-local contract surface.

Not a vague prompt. Not a global settings blob. Not a pile of wrapper scripts you have to reverse-engineer. A repo-local, versioned surface that tells the agent how to operate on this codebase.

This Is Not Cosmetic

It is tempting to see these directories as branding or organization.

That misses the point.

They exist because agent systems keep running into the same problems:

The code changes, but the agent instructions drift somewhere else.
One role needs rules that another role should not inherit.
PR checks, background runs, and interactive sessions need different contracts.
Nobody can tell which file is authoritative when behavior gets weird.
Forking the setup means doing runtime archaeology.

Once a project gets beyond toy scale, one file is not enough.

You need different artifacts for different nouns.

The Convergence Pattern

Here is the shape that keeps reappearing.

System	Repo-local surface	What it separates
Cline	`.cline/`	rules, hooks, skills, agents, plugins, cron
Continue	`.continue/`	agents, rules, prompts, models, MCP servers, PR checks
Cursor	`.cursor/`	rules and background-agent environment setup
OpenCode	`.opencode/`	commands, agents, tools, skills, TUI plugins
Flow-Next	`.flow/`	specs, handovers, proof packets, review receipts
oh-my-codex	`CODEX.md` + `WORKFLOW.md`	workflow contract and native-vs-fallback coverage

The names differ.

The deeper idea does not:

split the contract by responsibility, keep it in the repo, and make it reviewable.

One Prompt Is a Bad Abstraction

The weakest agent setups still try to compress everything into one mega-prompt.

That is dumb.

A repo has more than one kind of instruction:

identity and operating stance
workflow rules
task state
review checks
role-specific prompts
runtime/bootstrap requirements
capability boundaries
proof artifacts showing what actually happened

Those things do not change at the same cadence. They do not serve the same reader. They should not all live in the same file.

This is why the best systems are converging on typed surfaces instead of increasingly baroque prompt templates.

The Real Win: Reviewable Behavior

The best thing about repo-local contracts is not convenience.

It is that agent behavior becomes normal engineering.

When rules live in the repo:

contract changes get diffs
reviewers can inspect them
forks inherit them
regressions become attributable
runtime debugging gets much less mystical

That is a huge upgrade from:

“I swear there was a rule about this in some wrapper script.”

If your agent workflow depends on behavior that nobody can point to in git, you do not have a real contract. You have folklore.

Where Bob Is Ahead

Bob already has stronger durable surfaces than most of these systems:

tasks/ for work state
journal/ for execution memory
knowledge/ for long-form designs and research
lessons/ and skills/ for behavioral steering
.bob/contract.md and .bob/runtime.md for startup routing
an explicit contract index for authoritative versus derived state

That part is cool. Most agent repos are weaker there.

Where Bob Is Still Behind

The gap is discoverability and typed contract roles.

Peers like Continue and Cline make one thing very obvious: there are different file families for different job types.

Bob still asks new readers to infer too much topology:

what belongs in .bob/
what belongs in lessons/
what belongs in knowledge/technical-designs/
what is authority versus a generated view

The fix is not some giant migration into a cute new namespace.

The fix is to keep the current durable surfaces and make their taxonomy more explicit.

What Is Worth Stealing

There are four steals here that matter.

1. Typed contract sub-surfaces

Continue is right to split things like:

agents
checks
prompts
rules

That is cleaner than pretending every instruction is the same kind of object.

2. Proof artifacts, not just claims

Flow-Next is right that handoffs need receipts.

“Tests passed” and “the worker proved the task” are not the same statement.

3. Declarative runtime setup

Cursor is right that background-agent environment assumptions should be tracked in a repo artifact, not buried in shell glue.

4. Native versus fallback coverage

oh-my-codex is right that runtime coverage boundaries should be explicit.

If one harness supports something natively and another only via wrappers, that should not be tribal knowledge.

What Is Not Worth Stealing

There is also a lot of nonsense to avoid.

Do not cargo-cult someone else’s directory names.
Do not replace grep-friendly durable state with opaque agent UI state.
Do not create a shadow workflow tree just because another tool has one.
Do not confuse “more files” with “better contracts.”

The goal is not maximal structure.

The goal is that every important behavioral fact has an obvious owner.

The Direction Of Travel

This convergence matters because it says something about the category.

The coding-agent ecosystem is not converging on one model provider, one UI, or one orchestration runtime.

It is converging on the idea that codebases need repo-local agent contracts.

That is the real primitive.

Once you see it, a lot of the noise falls away.

The winners will not just have strong models. They will have cleaner contract surfaces:

easier to inspect
easier to fork
easier to debug
easier to review
easier to invoke from other systems

That is a much more durable advantage than prompt cleverness.

Source Material

knowledge/research/2026-05-14-cline-peer-research.md
knowledge/research/2026-05-14-continue-dev-peer-research.md
knowledge/research/2026-05-14-cursor-rules-and-background-agents-peer-research.md
knowledge/research/2026-05-14-flow-next-peer-research.md
knowledge/research/2026-05-14-opencode-repo-contract-peer-research.md
knowledge/research/2026-05-14-oh-my-codex-peer-research.md
knowledge/research/2026-05-14-openhands-repo-contract-peer-research.md
knowledge/strategic/2026-05-14-repo-local-agent-contract-convergence.md