Part 4 of Better Software
Nobody Cares That Your Agent Did It
· 10 minute read
More from Safi and Bruce together
Better Software · 4 of 4
When agents write most of the code and something breaks, who's responsible? That question, more than any tool choice, decides how a team should work with agents. The operative word is "team," and if humans are ultimately responsible, it's the ability to harness the knowledge of your teams across your company that will determine the effectiveness of your agentic workflows.
Who answers when it breaksLink to Who answers when it breaks
Picture the postmortem. A change went out on Tuesday, and by Wednesday a customer's checkout was failing. Someone walks through the timeline and says, a little defensively, "the agent wrote that part." The room nods and moves on, because it doesn't matter. The customer doesn't know which model produced the diff and wouldn't care if they did. What they know is that your product broke. Air Canada once argued that its chatbot was responsible for its own answers; in Moffatt v. Air Canada the tribunal replied that "it should be obvious to Air Canada that it is responsible for all the information on its website."
Now scale that up. At Anthropic, agent work hours passed human work hours in March, and by August "interactive AI agent hours outnumbered employees' six to one," according to the company's own study. Nobody reads six times their own output. Yet the same study finds that "human trust and accountability remains critical." The agents do more of the work every month, and the people still answer for all of it.
That isn't one company's view. LLVM's policy is blunt: "The contributor is always the author and is fully accountable for their contributions." The Linux kernel and Fedora say the same, and even the Personal Agent Protocol, built for agents that act in a customer's accounts, records whether the user or the agent approved each action. Whoever asks, a customer, a teammate or a regulator, the answer comes down to a person, a team or a company. Agents change who types, not who answers.
In Fundamentals Matter we argued that the engineer still has to understand what ships, and warned about cognitive surrender: taking an AI's answer as your own without noticing you handed anything over. Put those together and you're in a strange place: expected to understand more work than anyone could read, with tools that make it easy to stop checking, and still the one who answers when it breaks.
So the question isn't whether you're accountable. It's how you stay accountable when there's too much to read. We think it comes down to two things a team does together: share the context behind the work, and share the responsibility for it.
Context is a team sportLink to Context is a team sport
Everyone building with agents has hit the same wall: the agent doesn't know what the team knows. Most of the answers so far are about memory and context. They range from the company "brain" products of 2023 and 2024 to Andrej Karpathy's LLM knowledge bases in April 2026. In the past year alone about twenty-five startups building memory or shared context for agents raised nearly $600 million. But memory is only part of it. Agents have gone from answering one prompt, to working through a conversation, to running for hours and handing pieces to sub-agents of their own. They don't touch one file or one team's work; they touch everyone's. So the context an agent needs may span the whole company.
Go back to the checkout postmortem. The change didn't start in the code. A customer asked for it in the support tool, sales promised it in the CRM, finance set the price in billing, the team argued it out in a Slack thread, and an agent wrote the code. Every team works in its own system of record, and the why behind one change runs through all of them, well beyond the codebase. The obvious answer is to wire agents into every one of those systems, and the biggest platforms are trying: Atlassian is "stitching together people, goals, code, and content," and Microsoft and Google connect their agents to email, documents, chat and tickets. As a16z put it, "The living context layer is being built inside companies right now, whether they're paying attention or not."
But the systems of record get a say, and they don't agree on the answer. Slack said it was "reinforcing safeguards around how data accessed via Slack APIs can be stored, used, and shared," and in April SAP rewrote its API terms to rule out use with "(semi-) autonomous or generative artificial intelligence systems" outside the channels it approves. Newer systems are going the other way, rebuilding around agents and each reaching for more of the company's context. Attio, a CRM, says it "now speaks SQL, the data language of agents"; Linear has its own agent that "understands your roadmap, issues, and code"; Pylon relaunched in July as "the agentic support platform"; and Granola, the AI-native meeting notetaker that in 2025 dubbed itself "a second brain for your team," now sells team workspaces and APIs that feed its notes into other AI tools. Each is trying to become part of the context chain, and each only adds to the fragmentation your agents have to work across.
So build with fragmentation in mind: assume the context behind any change is split, and plan for it. That comes down to three things.
Every change points back to its why. It shouldn't matter which system, person or agent wrote it. The code should lead to the support request, the promise in the CRM and the thread where it was decided, through links anyone on the team can follow, not a memory someone has to be asked for. Nothing needs copying into one place; the why only has to be findable from the change. It's the purpose we argued for in Why Are You Shipping So Much?, carried down to a single change, and it's what lets a teammate trust a change they didn't write: they can check why it's there.
Every kind of data has an owner. Customer commitments, pricing, the checkout flow: each has a person or team accountable for it, who keeps it current. Systems disagree all the time, and when the CRM says one thing and the code another, someone settles it instead of an agent guessing. The owner also retires what's no longer true, so the next agent doesn't build on it.
The team knows how it will put the pieces back together. Not every system or change needs the same attention. The team decides which to watch closely based on risk, pricing and payments more than a copy change, and knows ahead of time where it will look and who it will ask when one of them breaks, so a fix can go in fast instead of after a week of archaeology.
Staying accountable without reading everythingLink to Staying accountable without reading everything
Context will stay fragmented. Accountability can't be. Links, owners and a plan by risk set a team up, but something will still break, and when it does the customer wants an answer, not a map of who held which piece. So accountability has to stop meaning "someone read every line" and start meaning "the team can say what was meant, who decided and what happened, and fix it when it breaks." That's a different job from reviewing code, and operations teams have been doing it for years: they run systems far too busy for anyone to watch line by line, and they still answer for every outage. Three of their habits carry over.
Learn from what breaks, as a team. Google made blameless postmortems "a tenet of SRE culture": a review that looks for "the contributing causes of the incident" "without indicting any individual or team." That's the right stance when an agent wrote the change. Asking who typed it doesn't help; asking what the team missed, and fixing that, does. It keeps trust intact, too: when nobody is blamed for what an agent wrote, people raise problems early instead of hiding them. This is where the links pay off. A postmortem is only as good as what the team can reconstruct, and with the why one step from the change, it starts from facts instead of memory.
Watch it like traffic. Teams that run services don't read every request; they keep logs and traces, and look when something seems off. Agent work can be watched the same way: keep a record of every change, its why and who approved it, so there's a trail to follow when anything breaks. But full agent sessions pile up fast, and at scale keeping and checking all of them gets expensive. Operations teams hit the same wall more than a decade ago: Google's Dapper paper, from 2010, credited "the use of sampling" for making tracing work at all. The lesson carries over. Keep enough to trace any change back; a link to its why and who approved it is small, so every change gets one. Sample the rest, the full sessions and the checking, as cost and scale demand. The areas the team marked as risky, such as payments, permissions or data migrations, get a person every time, and the rest gets a sample checked afterwards, the way Anthropic logs every approval its review agents make and has people check "a risk-weighted sample."
Let anyone stop the line. On Toyota's production line, an operator "can stop the line by pulling the stop cord themselves" when something is wrong, so the problem gets fixed where it started instead of being built into everything after it. Agents need the same cord, and today they mostly don't pull it. When a project's instructions contradicted its code, Claude Code noticed the conflict in 79 of 80 runs and followed the stale instructions anyway; one added sentence telling it to trust the code took it from following the code 4% of the time to 91%. Treating the code as the source of truth works most of the time. But the code can't say what a customer was promised or why a price changed, and when the disagreement is about the why, the agent shouldn't settle it alone. It should stop and send the question to the area's owner, and so should anyone who sees a change that doesn't add up.
Playing as a teamLink to Playing as a team
Run that postmortem again. Someone says the agent wrote that part, and this time it starts the conversation instead of ending it. The team follows the change back to the support request and the decision behind it, sees who owns pricing and who approved the change, and finds what it missed: a check that wasn't there, or a rule nobody had kept current. Before the meeting ends, it knows what happened, why, and what changes so it doesn't happen again, and it can tell the customer exactly that.
That's what playing as a team looks like. Not that every line was read, or that the agents never get it wrong, but that when something breaks, the team can put the why back together and stand behind the fix. And it's what lets people trust work none of them read in full. The customer will never care that an agent did it, and they shouldn't. Agents will keep doing more of the work, and the context behind it will stay in pieces. Answering for it was always the team's job. Better software is software someone can answer for.
Series · 4 of 4
Better Software
- Agents Took Over Your SDLC. Now What?
- Fundamentals Matter
- Why Are You Shipping So Much?
- Nobody Cares That Your Agent Did It