Modern agents rarely do the whole job themselves. They break it up and hand pieces to sub-workers, each with its own context and its own tools. Then they hand you back a tidy summary. That summary is not a record of what happened.
This is for security and engineering leaders who need to reconstruct what an agent did, and are finding that the agent's own answer is not enough.
What delegation looks like
A subagent is a delegated worker. The main agent spins one up to handle a slice of the task, gives it a goal, and lets it run with its own tools and its own context. The sub-worker does the work and returns a short result to its parent. Real agents do this many times over in a single run, sometimes several layers deep.
It is efficient. It is also where visibility quietly disappears.
A summary is not a record
The problem is what comes back. A sub-worker returns a summary, not a transcript. The parent folds those summaries into its own answer. By the time you read "Done: refactored the module, tests pass," several sub-workers have each made their own decisions and their own tool calls, and almost none of that is in the sentence you are reading.
"Done. Refactored the payment module, updated the tests, everything passes." One clean paragraph.
Four sub-workers, dozens of tool calls, a file deleted, a database queried, an external API contacted, one command that needed approval and did not get it.
For a person, the summary is a successful result. For a security team, it is the cover page of a report whose contents are missing.
The questions delegation makes hard
Delegation multiplies the questions you already care about, and the summary answers none of them:
Who did what. Which sub-worker took which action, under whose identity.
What it touched. The tools each sub-worker reached, the data it read, the systems it changed.
What was decided. Which actions were allowed, which were blocked, and which slipped through because no one was watching that layer.
What good visibility looks like
The record has to be the execution, not the summary. That means capturing every sub-worker, its identity, and each tool call it made, with the decision attached to each one, and keeping it in one place instead of scattered across the machines the work ran on.
This is what KonaSense captures for delegated work. When an agent hands a task to sub-workers, we record what each one does, the tools it calls, and the decision on each action, so the evidence you keep is the real chain of work rather than the paragraph the agent chose to show you. It is the same idea from When AI Starts Executing: the run may be temporary, and the summary is convenient, but the record has to survive both.
See the full chain of what your agents delegate
