Working "Agent First"

Your job used to be doing the work. It isn't anymore. Your job is supervising a fleet of agents who do the work.

That shift has a consequence most workplaces haven't metabolized yet: every piece of information, every system capability, every artifact in your orbit has to be accessible to agents first. Not "also." First. The agent is the one doing the work now — if your agent can't reach something, it might as well not exist.

I've started calling this working agent first, and once you see it, you can't stop seeing the violations.

The SharePoint incident

Earlier this week, someone at work helpfully shared a SharePoint folder with me, full of Word docs containing Q3 requirements. Oof.

So I:

• clicked the link in the email to open the folder in my browser
• clicked "Add shortcut to OneDrive"
• opened Finder on my Mac
• navigated to my OneDrive folder and selected the newly synced folder
• right-clicked the folder name in the path bar and selected Copy "Q3 Notes" as Pathname — a great trick for getting a path you can drop straight into Claude Code; hat tip to Todd for this one
• pasted the pathname into Claude Code and said "convert this mess to .md so we can get started"

Six manual steps of human middleware before any actual work could begin.

But here's the detail that makes the story: the Word docs were full of green checkmarks and red X's — the typographic tells agents love to sprinkle around. An agent wrote these requirements. Then a human exported them to Word, uploaded them to SharePoint, and mailed me a link, so that I could spend six steps converting them back into the format they were born in.

The context started agent-native. It got printed onto a human-ritual artifact for transport. And I had to scan it back in on the other end.

We've seen this movie before.

It's a check

Say you owe me $100. You have the money in your checking account. So you:

• get out your checkbook
• write a $100 check
• put the check in an envelope
• write my address and your return address on the envelope
• put a stamp on the envelope
• drop it in the outgoing mail

A few days later (skipping the steps performed by the good people at USPS):

• I fetch the envelope from the mailbox
• I open it and remove the check
• I sign my name on the back
• I write "for deposit only" under my signature
• I open my bank's iPhone app and navigate to the deposit section
• I choose an account
• I thumb in the $100 amount
• I photograph the front of the check
• I photograph the back of the check
• the app confirms the deposit was received

Then I throw the check away.

Whew. I'm tired and cranky just thinking about it.

But the check was never the point. The goal was to move funds from one account to another — a database transaction. The check is a paper serialization of that transaction, designed for a world where the only way to move information between banks was to physically mail it. The mobile deposit flow gives the game away: the system's final step is to OCR the paper back into the transaction it always was. The artifact exists only to be destroyed after parsing.

That's what a Word doc full of agent-generated checkmarks is. The goal was never to write a doc. The goal is to move context from your agent to mine. The doc is a serialization of agent-native context into a human-ritual artifact, delivered by human carrier pigeon, scanned back in at the destination.

We've run this mandate before

In 2002, Bezos issued the now-famous API mandate at Amazon: all teams expose their data and functionality through service interfaces. No other form of interprocess communication allowed — no direct links, no shared memory, no back doors. All interfaces designed to be externalizable. The mandate is a big part of why AWS exists.

The point wasn't APIs for their own sake. The point was that human-mediated data sharing doesn't scale, and the only way to prove it is to ban it.

Agent first is the same mandate, one level up. If a capability only exists behind a GUI, it doesn't exist for your fleet. If knowledge only exists in a Word doc behind SSO, your agents are working blind and you've appointed yourself lead carrier pigeon. Nice. You look good in gray. Brings out your eyes.

Every artifact that requires a human to transport, transform, or transcribe it is a tax on the only resource that matters now: how much work your agents can do without you in the loop.

Build the agent interface first

This isn't just about how we share. It's also about how we build.

When you build something new, don't build the human interface. Yet. Build the agent interface — the MCP server, the CLI, the API — and then use the thing exclusively through your agent. See what friction emerges. Where do you get frustrated? Where do you lose the plot? What's genuinely hard to reason about when your only interface is natural language?

Cool. Now go build that human interface. Not the one you would have designed up front — the one the friction demanded. Let it emerge, because the primary user is the agent. You're just a client.

I built Agent GTD exactly this way — MCP and API surface first, web UI later, and only for the things narration handled badly. To a fault, honestly: there's API and MCP surface that still hasn't made it into the UI, and every so often an agent casually mentions a feature of my own tool that I didn't know it had. I learn about my product from my users. That's agent first working as intended — the UI is a partial view of the system, not the system a partial automation of the UI.

This is the design method that follows from the asymmetry I keep writing about: the agent can hold and manipulate far more than you can, but some things — scanning fifty tasks at a glance, watching a wave of parallel dispatches move — are genuinely better rendered for human perception than narrated in prose. You can't know which things those are in advance. You find out by working agent first and noticing where conversation fails you. Human-readable turns out to be a rendering concern, not a storage or transport concern. Markdown is both, which is why it's the native file format of this era and Word is not.

Monday

• Default to plain text. Markdown for documents, structured formats for data. If your artifact needs a specific app to open, it's a check.
• Share sources, not exports. A repo path, an API endpoint, an MCP server — not an attachment. Moving context should be a transaction, not a mailing.
• Build the agent interface first. Human UI second, and only where natural language demonstrably fails.
• Audit your week for carrier-pigeon work. Every time you manually move information between a system and your agent, that's a check you're mailing. Each one is a candidate for elimination.

The software factory runs on context the way a physical factory runs on parts. You can have the best line in the world, but if every incoming shipment arrives as paper that someone has to re-key at the loading dock, throughput is capped by the dock — not the line. When the output is bad, you improve the factory. When the input is slow, you fix the supply chain.

Agent first is the supply chain fix. The doc was never the point.

Stop mailing checks.