Agent Contracts: The Job File

Estimated reading time: 6 minutes

If it is not written down, there is no guarantee it happens.

An agent that did the work once in a chat has not taken the job. It has performed. The next session does not inherit the performance. Whoever is still holding the context is still doing the job, whether they notice or not.

Four Hats, No Interface

By mid-March the newsletter pipeline had four named jobs: plan the week, draft the essay, distribute it, and handle what came back. That felt like specialization. It was a longer prompt with job titles.

The planner would re-sharpen the thesis the brief had already locked. The essay would re-derive the Key Sentence. Distribution would invent Wednesday from vibes. Engagement would start drafting replies in the same breath as strategy. One chat. Four hats. No written interface between them.

We had files. We had named skills. We did not have a job. Each role could still do everyone else’s work, because nothing said it couldn’t. The session looked specialized. The metabolism was still one organism wearing four badges.

If you run agents for a living, you already know this room. A research agent, a drafting agent, a review agent, all in one window, all allowed to reach for the same levers. The names are a costume. The work keeps collapsing back onto whoever is still in the chat. The meeting version is familiar too: three workstreams on the slide, one person still holding every exception in their head after the call.

Write Down the Job

On 23 April we stopped treating that as a prompting problem and made it a role problem. We added an orchestration layer whose only job is to classify the mode, emit a brief, and route. It is not allowed to write the essay, pack the cascade, or pull Search Console. The routing file still says it in a table: what each skill owns, and what the orchestrator may only seed.

That was the first time the toolset admitted a generalist session would keep doing everyone else’s job unless we wrote down who decides, what may go in, and what must come back.

Prompting is not a contract.

Call the written interface Agent Contracts. Three fields. Who decides what the agent may know. What it may take in. What it must return. Anthropic already asked builders to invest as much in the agent-computer interface as in the human one: written tool docs, tested, constrained. That is the machine-facing file. Knowledge as Code already argued that durable knowledge is a file a human can judge and a machine can read. This is the job file. Not the corpus. The interface.

The COBOL Problem named the missing curator between the contributor and the record. Storage without transfer. Agent Contracts names the missing object between a human role and an agent. A fluent session without a written job. Different failure. Same family: work that exists only while someone is in the room.

Who Decides, What Goes In, What Comes Back

Write the three fields before you add another skill.

Who decides. Name the role that is allowed to set what the agent needs to know. If everyone can, no one has. Ask a well-read library this question and it will hand you a primer and a system prompt. Those belong in the next field. They are inputs someone still had to choose. The missing object is the role allowed to make that choice, written down so the next session can find it. In our pipeline the orchestrator decides the mode and the brief. The essay role does not get to reopen the thesis unless a human overrides it. Watch for the tell: a downstream agent that “helpfully” re-sharpens what was already locked. That is an unwritten job stealing a written one. What changes when the field exists: the next session can refuse work that is not its own.

What it may take in. A brief. A handoff. A named evidence packet. Not the whole vault, not a second thesis, not last week’s chat because it is still in the window. Watch for fat context dressed up as onboarding. Knowledge Priming already named the attention budget; the contract is how you enforce it at the job boundary. What changes: the agent can be wrong about missing inputs instead of silently inventing them.

What it must return. A named artifact. A weekly plan. An essay. A cascade pack. A score. Not “helpfulness.” Not a summary of how hard it tried. Watch for a return that is another prompt. If the output cannot be handed to the next role without a meeting, it is not a return. It is a conversation that ended. What changes: you can tell whether the job happened after the window closes.

Those three fields are the same shape as any written interface: who may act, what comes in, what must come out. Compliance teams already live there. Agent work pretends it is exempt because the interface is a chat box. It is not exempt. If you cannot point at the file, you do not have a job. You have a session.

Pick one agent job this week and fill the three lines in a document the next session can find. Not a slide. Not a thread. A file. If you cannot finish the three lines without an argument, you have found the role-design fight. Have that fight before you buy another seat or add another model. The argument is the work. The file is how the next session inherits it.

This Job Cannot Share a Brain

The second cut was sharper.

By late June, distribution had language gates. Mechanical blockers. They did not stop the drafting agent from blessing its own Wednesday post. A checklist in the same window as the draft is a costume too. The agent that wrote the post still wanted the post to ship.

On 28 June we added an evaluator with a hard line: invoke it as a separate agent, never the one that drafted the work. You are not the cascade agent. Score. Do not redraft. The same pattern landed on engagement and measurement within a day. Generator and evaluator had to be different roles, or the quality loop was theater.

After that, specialization was no longer “add another skill.” It was this job cannot share a brain with that job.

The hangover showed up in July. Stuffing the orchestrator into every session drowned the attention budget, so the orchestrator became a stub that points at the canonical file instead of dumping hundreds of lines into the window. The contract had to be a file the next session could find. A system prompt that restates the org chart is still a prompt.

You need Agent Contracts when one session is planning, drafting, distributing, and grading itself. You do not need another prompt pack. You need a file that says who decides, what may go in, and what must come back. If those three lines do not exist, the work is optional, no matter how good the last chat felt.

We did not start from a theory of agent roles. We started from one chat that would plan, draft, distribute, and grade itself, and from the mess that created until the contracts were files.

What work in your stack exists only as a prompt that worked once?

Madam I’m Adam

This continues the thread from Knowledge as Code, where the durable unit was a file a human can judge and a machine can read, and from The COBOL Problem, where a store without a curator does not pass anything on. Agent Contracts is the job file: who decides, what goes in, what comes back.