The agent cowork loop is a simple collaboration pattern: brief, delegate, verify, learn.

It avoids two common extremes. In one, a person micromanages every click and gets little leverage. In the other, an agent receives a vague goal, makes hidden assumptions, and returns something polished but unreliable.

The loop keeps human judgment at the boundaries and gives the agent enough room to do meaningful work inside them.

1. Brief the outcome

A good brief tells the agent what must become true, not just which activity to perform.

Include:

  • the user or business outcome;
  • the files, systems, or people in scope;
  • constraints and protected surfaces;
  • the strongest available sources;
  • the evidence required before completion;
  • actions that need explicit approval.

Compare these two requests:

Research Astro integrations.

Identify the smallest maintained Astro integration set for this static SEO site. Check official compatibility and current package health. Do not add dependencies. Return a recommendation with removal paths and evidence links.

The second brief gives the agent a decision to make and a standard for making it.

2. Delegate a coherent slice

Delegation works best when the job has one owner and a visible boundary.

Good slices include:

  • map the current architecture;
  • implement one route family;
  • create contract tests for one API;
  • audit one user journey;
  • challenge a proposed dependency set.

Avoid splitting work so narrowly that every agent needs to rediscover the same context. Also avoid one giant job that mixes research, implementation, deployment, and irreversible business actions.

If multiple jobs can proceed independently, run them in parallel. If one changes the contract that another consumes, sequence them and make the handoff explicit.

3. Verify against evidence

Do not review the agent’s confidence. Review the result.

Match the proof to the claim:

Claim Useful proof
The code compiles Typecheck or build output
The page works Browser journey and response checks
The design is responsive Screenshots at agreed viewports
A deploy is live DNS, TLS, health, and release identity
A user converted Downstream system evidence, not a CTA click
Existing behavior is preserved Targeted regression tests and scoped diff

When evidence is missing, say “unverified.” That is not failure. It is an accurate state that tells the next person what remains.

The NIST AI Risk Management Framework emphasizes governance, measurement, and management around AI risks. In everyday agent work, that translates into clear ownership, observable checks, and a response when the system is uncertain.

4. Store the learning

If a result will matter again, move it out of the conversation.

Store different truths in the right places:

  • architecture in an architecture owner;
  • product decisions in a decision log;
  • repeatable commands in a runbook;
  • current tasks in a task ledger;
  • raw test or runtime proof in an evidence folder;
  • reusable cross-project lessons in shared memory.

Keep the record compact. The point is to reduce rediscovery, not to archive every thought.

A reusable cowork brief

Use this skeleton for a real task:

Outcome:
Scope:
Read first:
Protected surfaces:
Decisions the agent may make:
Actions requiring approval:
Acceptance checks:
Evidence location:

After the task, ask three questions:

  1. Which assumption changed?
  2. Which check caught a real problem?
  3. What should be automatic or documented next time?

The human role does not disappear

Agents can search, compare, implement, and test at useful speed. The person still owns intent, tradeoffs, risk tolerance, and the meaning of success.

The best cowork loop is not the one with the least human involvement. It is the one that spends human attention where judgment changes the outcome, while the rest of the work becomes clear, repeatable, and verifiable.

Further reading