Field Notes/2026
Give the Agent What It Wants
Working with agents keeps bringing me back to the same tools: terminals, plain text, and diffs I can review.
June 7, 2026 · 5 min read
The most capable software ever made starts its day like a programmer from 1978: a terminal, some plain text files, a list of what changed. That’s where I do most of my work now, not in the dashboards I used to live in, but at a blinking cursor. Plain text is cheap to process, easy to inspect, and easy to verify. That has turned out to matter more than most of the elaborate interfaces built around AI. My working rule is simple: give the agent what it wants.
01/Agents
A useful definition
For this piece, I mean something specific by agent: a model that chooses its next step, uses tools to act, and adjusts to what comes back. A workflow follows a path someone defined in advance. An agent decides its path as it goes. I care about the distinction because it changes what I build.
What the agent wants from you is modesty. Anthropic’s Building Effective Agents is still the clearest writing on this: start with a single model call and add complexity only when the simpler version stops working. A fixed workflow is easier to trace and debug. I use an agent when the work is open-ended enough that I cannot predict the steps in advance. Teams of agents can be useful, but every extra process adds cost and another place for the work to go sideways.
The autonomy that makes an agent useful is the same autonomy that compounds its errors and its bill.
After Anthropic Engineering, Building Effective Agents
02/MCP
The common plug
Every technology eventually needs a shared standard so tools from different makers can connect without custom wiring. For AI, that standard is becoming MCP, the Model Context Protocol. It does not make every integration automatic, but it replaces a lot of one-off plumbing between models, tools, and data. Anthropic open-sourced it in November 2024. Over the following year, major model and software vendors added support, and Anthropic contributed the protocol to the Linux Foundation’s Agentic AI Foundation.
The handoff to a neutral foundation matters. Companies can compete on products without competing over the connection standard itself. The agent, though, does not care about your tool count. Many available tools are thin wrappers that flood the model with raw structured data it has to dig through. Nearly half of the companies represented in Stacklok’s 2026 survey were using MCP in production. The mistake I keep seeing is collecting tools instead of curating them. In my own setups, a small, deliberate toolset has been more reliable than a crowded catalog.
03/Markdown
Keep the input lean
Format is one of the cheapest ways to make an agent’s job easier. For model-facing context, I default to Markdown. It is compact, familiar to the models, and easy for a person to inspect without a rendering step. HTML carries tags, attributes, and structure that may be useful later but often add little when the model only needs the text.
I do not force everything through Markdown. If structure or interaction matters, I use the richer format. I only strip out what the task does not need.
04/HTML
When the person needs an interface
Markdown is often the working format for the agent. HTML can be the review format for the person.
In January 2026 the MCP ecosystem shipped MCP Apps, which let tools return interactive HTML surfaces inside a conversation. The host renders each one in a sandboxed frame. They are already useful for data exploration, document review, and live monitoring. That does not mean every answer needs an interface. A one-off question can get a one-off screen, scoped to the work at hand and discarded afterward.
The catch is trust. You are still rendering code supplied through a tool, so its origin and permissions matter. Simon Willison calls the dangerous combination the lethal trifecta: private data, untrusted outside content, and a way to send information out. Do not put all three within reach of the same agent.
05/Cowork
Delegation, not conversation
Claude Cowork launched as a research preview in January 2026 and brought this way of working outside the engineering department. Point it at a folder, describe an outcome, and it runs the multi-step job. Last week I needed to pull key threads from a few months of project notes and draft an agenda. I described the outcome and scoped the folder. Eight minutes later I checked the output, made two edits, and it was done.
The change, for me, is in the verbs. I spend less time trying to write a perfect prompt and more time defining the outcome and the boundaries. I describe the work, choose the files it can touch, and check what it produced. The model does the first pass; I still own the result.
06
The practical version
If you skipped to the end, here’s the whole argument as things you can do this week.
- Start with one model call. Add a workflow when the steps need to be repeatable; add an agent when the steps cannot be known in advance.
- Use MCP where it removes custom integration work, then curate the toolset. Every tool has to earn its place.
- Give the model compact, readable context. I default to Markdown for text and reach for HTML when a person needs an interactive surface.
- Define the outcome, boundaries, and stopping point. Keep the agent in a controlled environment and review the work before anything ships.
- Do not put private data, untrusted content, and external communication within reach of the same agent.
- Keep what you can inspect. A terminal, a text file, and a clean diff are often enough.
In 1991 Mark Weiser wrote that the most profound technologies disappear into everyday life. I used to imagine AI arriving as a new layer of software with its own interface. Instead, the useful part has slipped into tools I already know: a folder, a terminal, a text file, a diff. That is less dramatic than the demos and much easier to trust. I can see what the agent read, what it changed, and what I still need to decide. For now, that is enough.