What's under the hood

Every agent interaction runs inside a durable execution harness that tracks each step independently. The agent assembles context, reasons about the request, takes action — calling tools, delegating to other agents, or dispatching longer-running tasks — observes the results, and responds. That cycle is not a single function call. It is a structured loop with discrete, inspectable stages.

Each step has its own lifecycle. If the agent service restarts mid-execution, it picks up from the last completed step, not from the beginning. If a tool call fails, the agent retries that specific step without re-running everything before it. If a budget limit is hit, the agent stops cleanly and tells the user why. Partial progress is preserved; nothing is silently discarded.

This is not a wrapper around an LLM API call. It is a state machine that treats every operation as a recoverable, auditable unit of work. The execution record persists after the interaction completes, giving you a full trace of exactly what happened, in what order, and at what cost.

The practical consequence is that agents behave predictably under conditions that break naive implementations: network partitions, deployment rollouts, long-running tasks that span multiple sessions. Production reliability is not retrofitted — it is the starting assumption.

An agent can call another agent as a tool. The calling agent passes a task to the sub-agent, waits for the result, and incorporates it into its own reasoning. From the platform's perspective, the sub-agent call is an auditable step with its own trace, its own cost attribution, and its own policy evaluation — not a black box handed off to another process.

Delegation always narrows permissions, never widens them. A sub-agent inherits the intersection of the calling agent's permissions and its own configured permissions. There is no mechanism for a calling agent to grant a sub-agent capabilities it does not already hold independently. This prevents privilege escalation through composition and means you can reason about a composed workflow without needing to trace every possible delegation path. Cycle detection is built in — agents cannot form delegation loops. Cost from sub-agent calls rolls up to the calling agent's budget, so a composed workflow is always bounded by the top-level budget constraint.

Agent Studio is the visual workspace for building and inspecting composed workflows. You can see which agents a given agent delegates to, inspect the permission boundaries at each delegation point, and run composed workflows step by step during development to verify behaviour before deploying to a live channel.