When an agent gets it wrong, look at what you gave it.

How I work keeps changing as agents improve and as I learn. Here's what holds so far.

I see this agentic era in three acts:

  1. Capability. Getting an agent to do anything you can do on a computer. That's been solved for a while.
  2. Orientation. Keeping an agent clear on who it is, who it's working with, and what the work is, from one session to the next. Most of what I've built is about this, starting with Desk.
  3. Work design. Designing and measuring how agents get their work done. The industry is just starting to move into this one, and it's what the factory is for.

Five principles keep an agent oriented on jobs that take days. The long version is in Desk's design doc.

Failure modes I watch for

  • You're doing it by hand. Anything the agent could have done.
  • You're teaching it twice. The same correction, session after session.
  • Control keeps coming back to you. You've become an approval button on a loop.

What's been working

1. Talk through intent and judgment

I'd rather talk something through with an agent once, for as long as it takes, than answer it twenty times along the way. So every job starts with one real conversation about what we're doing and why, and then I say go.

2. Delegate whole outcomes

I say what done looks like and why it matters, and the how is the agent's. When I handed over a tool built for agents, all I asked was that it work as well as it possibly could, and that's the only thing I judged.

3. Make context durable

Decisions live in files the next session reads. Desk keeps them in a Git repository. I once asked my agents to stop pinning dependencies to exact commits. They did it about a dozen more times anyway, because each one trusted an older agent's handoff note over what I'd said, and one of those notes was written twelve minutes after I said it. Now my words outrank any handoff note, and every agent's instructions say so.

4. Give agents meaningful authority, with clear boundaries

Only I spend my money, speak in my name, use my private accounts, or make calls that can't be undone. The rest is the agent's, and its work stays visible. One night a cleanup command stopped to ask me for a click, and the run sat there until morning. Now my agents work under a rule never to run a command that asks for one.

5. Verify the actual result

I look where the result lives: the live page, the installed app, the merged change. I ask for proof that it works end to end, with screenshots I can check.

Fix it for the next agent

When I fix something, I fix it for the whole system: in the agent's instructions, in a skill, or in the tool itself, so the next agent starts out ahead.

For teams

  1. Pick one real job this week that will take more than a day.
  2. Talk it through once with the agent, then say go.
  3. Keep plans in a repository the agent reads. Desk sets that up.
  4. Judge the merged result.

One number to watch: per job, how long the agent sat waiting on a human. The factory measures it in public.

Hand this to your agent → Read the blog →