The Elk Method
Read nothing.
Watch everything.
Decide once.
Every team now has more agents than people, and more output than anyone can read. The Elk Method is how a small team stays in charge of that without a single person becoming the reader. It is four steps in a loop. Elk is the tool built around it, but the loop comes first.
Walk the loopWhy a method
The tools changed.
The habits did not.
Agents took over the writing, the building, and the first draft of most decisions. The habits around that work stayed the same: standups to find out what happened, boards to say what is next, review queues to catch what went wrong. Those habits assume a person did the work and can be asked about it. When an agent did the work, nobody can be asked. The work has to be watched instead.
The Elk Method replaces reading with watching, assigning with handing off, checking with judging, and configuring with keeping. Each step is small on its own. Together they close a loop that gets tighter every time it runs.
Four steps. One loop.
The next time
gets clearer.
Every piece of agent work goes around once. What it earns on the way around decides how the next piece is treated.
Step one
See
Make the path visible.
Nothing is read. Everything is watched.
Agent work is invisible by default. The result lands and the path to it is gone. The first step is to make the path visible, for every agent on the team, at the level a colleague can use: what it was asked, what it decided, what it skipped, what it was unsure about. Not tokens. Not tool calls. Judgments.
Three rules make watching work.
The subject is the work, never the person.
Elk watches what an agent did. It does not watch what you did.
Every piece of work carries a name.
Whose agent, serving what goal, with what permission. “An agent changed this” is the failure. “Isaac’s agent changed this, to cut checkout latency, allowed to suggest but not to deploy” is the standard.
Watching is silent until it matters.
A good day produces nothing to look at. The team hears from Elk when two agents touch the same thing, when an agent was unsure, or when something it was watching for happens.
Step two
Hand off
Give the next move a home.
Every signal ends in one next move.
Watching that produces nothing to do is a dashboard. The second step turns what was seen into exactly one next move, with the evidence attached, and hands it to whoever should take it.
Hands go to an agent.
If the move is to write it, fix it, draft it, or run it, an agent takes it, with the context it needs already on the task.
Taste goes to a person.
If the move needs a call only a human can make, it goes to the right human, at the right density, and no one else is interrupted.
Nobody updates a board.
The hand-off is the task. The task closes when the work lands. A merged pull request closes it. A sent reply closes it. Friday is not involved.
Step three
Judge
One human call. Shared context.
The only job left is the call.
Work comes back. The third step is the one that stays human, and the method protects it by making it small. The person does not re-read the work. They see what the agent decided, why, and what it was unsure about, and they make one of three calls: accept it, tweak it, or send it back.
The evidence comes with the result.
The commits, the alert, the call where it was discussed, the session where it was built. Nothing to hunt for.
The call is fast because the watching was good.
An agent that narrated its decisions in step one is easy to judge in step three. This is why the loop is one loop and not four features.
Judging is where two agents get reconciled.
When Isaac’s agent and Casey’s agent disagreed on the timeout, the person who holds the goal makes the call once, and both agents hear it.
Step four
Keep
Carry the lesson forward.
A review is a lesson.
Most teams review the same mistake every week. The fourth step is what stops that. Every call in step three becomes part of the agent’s record and part of the context it works from next time. What held up is kept. What did not is corrected once.
Trust is earned, not toggled.
Every agent starts by observing. It earns the right to suggest when its suggestions have held up. It earns the right to act when its actions have been reviewed and held. Nobody flips a switch. The record is the switch.
Your co-agent learns from your calls.
The company’s agents learn from everyone’s. A correction made once on one camp reaches the agent that works there, and the agent that works there next.
Keeping is how the loop tightens.
The first time around, everything goes to a person. The hundredth time, most of it flows through, and the person sees only what is new.
What the method is not
Clear about
what belongs.
It is not surveillance.
The subject of every step is the work an agent did. No step watches a person.
It is not a trace viewer.
Tokens, spans, and latency belong to the person who built the agent. The method runs on decisions and results.
It is not a framework.
Nothing gets migrated. Agents keep working where they already work, and the loop runs above them.
It is not a board.
Nothing is updated by hand. Every step closes on the work itself.
Running it without Elk
The loop
comes first.
You can. A shared channel where agents post what they decided, a task list where someone hands things off, a weekly hour where results get judged, and a doc where the lessons go. Teams have done it. It works for about a month, then the channel becomes the reading problem it was meant to solve.
Elk is the tight version. Each step is one tap instead of one ritual, and the loop runs on every piece of work instead of the ones someone remembered to post.
Look up.
An elk on a ridge sees the whole valley and moves only when it matters. That is the posture the method gives a team: aware of everything, alarmed by nothing, and clear about which moves deserve a person.
Aware of everything. Alarmed by nothing.