Skip to main content
Version: 11.5.0

Subagent Attribution

A coding agent does not always work alone. It can spawn subagents: separate threads it delegates work to. A subagent inherits its parent's session identifier, so every one of its requests lands in the same session. Without attribution, a session that delegated heavily is one undifferentiated pile of activity, such as hundreds of shell commands with nothing to say which specialist ran them.

Subagent attribution splits that pile into threads. Each thread is either the developer's own conversation, or one subagent it spawned. HYPR AgentPass™ can tell you how much work each did, and what each cost.

The Threads Bar​

When a session has more than one thread, a Threads bar appears above the representations. Its heading says what the session contains, such as Root conversation and 2 subagents. The bar is split into one segment per thread.

  • Width. A segment's width is that thread's share of the session's requests, so the thread that did the most work is the widest.
  • Label. Where a segment is wide enough, it shows the thread's name and its share. The name is the subagent's type, where the spawn declared one, such as recon-specialist. Otherwise, it is the description the spawn gave it. The developer's own conversation is labeled Root. A very narrow segment shows only its share, or nothing.
  • Details on hover. Hovering over a segment shows its name, how much is known about its parentage, and its request count, tool-call count, token total and any failed requests. The token total is the per-subagent cost figure. It answers which specialist consumed the budget.
The Threads bar for a session with a root conversation and two subagents: three segments sized by share of requests, each labeled with its thread and percentage

Focus One Thread​

Select a segment to narrow every representation at once. The table, timeline, entity graph, flow diagram and turn tree all show that one thread, and the other segments are dimmed. Select the segment again to return to the whole session. While one thread is focused, the bar says so: "Showing one thread. Select it again to return to the whole session."

Focus is shared across views, not set per view, on purpose. Five representations each applying their own grouping rules would be five places to disagree about which subagent did what. On a forensic timeline, that disagreement is the finding you would act on.

A thread whose activity has all been filtered out shows nothing, instead of falling back to the whole session. Showing the session's entire activity under a heading naming one subagent would attribute the whole session to it.

The Bar Appears Only Where There Is Structure​

The Threads bar, the table's Thread column, the flow diagram's Branch column and the entity graph's thread nodes all appear only when a session has more than one thread.

One thread is not a structure. A session whose requests carry no thread information cannot be told apart from one that used no subagents. AgentPass therefore never shows a bar with a single segment, which would assert a check it never made.

How Attribution Is Derived​

Attribution is observed, not inferred. When a thread spawns a subagent, the opening instruction the parent passed and the one the subagent received are the same text. AgentPass matches the two ends of that spawn, and connects them.

Only a one-way hash of that opening text is stored, never the text itself. A thread is identified by that hash.

The connection depends on seeing both ends. A thread therefore reports how well its parentage is known, instead of being attached to a plausible-looking parent.

Parentage, on hoverWhat it means
Spawn observedA spawn call creating this thread was seen in this session
Root conversationNothing spawned this thread, and it is the session's earliest, so it is the developer's own conversation
Parentage unknownNo spawn call for this thread was found in the rows scanned, so its parent is unknown, not absent
No subagent attributionThese requests carry no thread information at all

A thread with unknown parentage sits at the top level of the turn tree, instead of being nested under a guess.

A thread always reports its true volume, even when its parent is unknown. Counts cover every request in the session, while parentage is resolved from the spawn calls in the scanned rows. An unplaceable subagent still tells you accurately how much work it did.

Limits​

Attribution is derived evidence. In three cases, it says less than it might seem to, and the console states each one.

"No Subagent Attribution" Means Cannot Attribute, Not "No Subagents"​

Requests that carry no thread information are grouped into a thread labeled No subagent attribution. Either the requests were recorded without thread information, or their request body was a shape AgentPass does not recognize.

Read the label literally

No subagent attribution means "these requests cannot be attributed to a thread," never "this session used no subagents." Attribution comes from request bodies at the time they are recorded, and cannot be backfilled for requests recorded without it.

Two Subagents Can Merge Into One Thread​

Two subagents given near-identical opening instructions produce the same thread identity, and are shown as one thread. AgentPass does not merge them silently. The session raises a warning naming the affected threads, Two subagents are being shown as one. It explains that more than one spawn produced the thread, and that a call attributed to it may belong to either. The warning appears beneath the Threads bar.

Do not split a merged thread

When a session flags a merged thread, treat its activity as belonging to either of the subagents shown as one. Do not attribute any individual call in it to a specific subagent. Do not draw a per-subagent conclusion from it either, including a cost conclusion.

Very Large Sessions Are Bounded​

A very large session is read over a recent slice, not in full. Counts may cover a bounded portion of the session. The parentage of a thread whose spawn falls outside that slice is reported as unknown. When this happens, the session says so: "This is the most recent part of the session; earlier activity is not included in the totals." A bounded count is never presented as a complete one.

Requests Without Thread or Session Information​

When a session carries no thread information at all, the Threads bar is missing because there is nothing to split. Read that as a session whose requests did not declare a thread, not as one that delegated nothing.

A request that declares no session ID is not grouped into a session at all. It still appears in the Request Log on its own.