×

Labelbox•November 18, 2026

Inside Recursion Managed Agents: the architecture of reliable enterprise work

Inside Recursion Managed Agents: the architecture of reliable enterprise work

An enterprise agent needs to do useful work and leave enough evidence for a team to trust the result.

That means connecting to the right systems, keeping track of a task across many steps, recognizing when progress stalls, and checking the finished work. Teams also need to understand what the agent could access and what the job cost.

Recursion Managed Agents (RMA) connects these responsibilities in one architecture. The main agent executes. Oversight combines the rule-based Interventionist with optional Supervisor review and requested advice. Outcome grading checks the result against explicit criteria. Sessions and events connect those roles, giving people a way to follow, guide, and assess the work.

For example, a team configures a GitHub-triggered automation to prepare a draft fix for a reported bug. The job must deliver a patch, a regression test, and evidence that the test catches the bug and passes with the fix. Following that job shows how the parts of RMA work together.

01 / Request

Objective + outcome criteria, when configured

Console · Slack · API · automations from schedules, GitHub events, or webhooks

Start or continue the job

Session & events

Actions, outputs, delegated work, oversight, and reviews stay linked.

02 / Execute

Main agent

Plan → act → inspect → adapt

The main agent uses:

Context

Instructions, skills, memory, and files inform the agent’s decisions.

Tools & integrations

Granted tools connect business systems, web research, and MCP. Results return to the agent.

Sandbox

A workspace for commands, files, and browser use. Remote tools operate outside it.

Delegation

Subagents, roster agents, and teams handle assigned work. The main agent combines their results.

Alongside execution

Oversight

Interventionist
Rules detect concerns and can provide guidance.
Supervisor · when enabled
Reviews detected concerns and decides whether to intervene.
Advisor · when requested
Offers another perspective to the main agent.

Guidance returns to the main agent.

Supervisor guidance is rechecked. Shadow mode records without guiding.

Work produced
03 / Review · when configured

Outcome grading

Captured work and activity → rubric checks → verdicts with reasons. Workspace checks use a copy, not the main agent’s live workspace.

↶ Failed criteria can return to the main agent

The agent revises within the review limit. A Not evaluable verdict stops the loop for clarification or evidence.

Or, if grading is not configured

Without outcome grading

Work goes directly to the result, without an outcome verdict.

Review ends, or grading is skipped
04 / Result

Answer + deliverables

With grading configured: outcome status and supporting reasons, including unmet criteria, clarification needs, or grading errors.

Across the whole job

Security

Organization, roles, tool grants, credentials, and network controls define access. Remote tools have their own access boundaries.

Cost

Model calls + billable tools + running compute, including delegated work and reviews. The total settles after work, compute, and charges end.

Main agent

The main agent turns an objective into a sequence of actions. It gathers context, selects tools, examines their results, and decides the next step. Its reusable definition combines a model, instructions, skills, and access to the tools and credentials the task needs. For the bug-fix job, it inspects the report and code, prepares a patch, and delegates a focused test check.

Those tools connect reasoning to action. An agent can research the web, run code, analyze files, and create deliverables. Enabled browser and computer tools let it interact with applications visually. Integrations bring in business systems such as GitHub, Slack, Jira, and Confluence. Custom tools can connect internal systems through MCP, a standard interface for exposing tools to an agent. Each connection must be available and granted before the agent can use it.

Subagents handle delegated tasks. The main agent can also delegate to roster agents: other configured agents with their own instructions, models, skills, and granted tools. Teams coordinate copies of the lead agent through a shared task board. An advisor supplies another perspective without carrying out the task itself. The main agent brings those contributions back into the job.

Delegating focused tasks can improve performance when work can be split into independent parts. The main agent stays focused on the overall goal and combines the results while subagents investigate separate areas in parallel. Anthropic’s multi-agent study identifies highly parallel work with opportunities for specialization as a strong fit for this pattern, while showing that effective coordination between agents remains important.

Agent definitions are versioned. Changing an agent creates a new version; work already running keeps its version until someone explicitly moves it. Teams can refine instructions and tools while retaining a clear record of the definition used for each session.

Sandbox

The sandbox gives the agent a place to execute commands, work with files, and use a browser when enabled. A saved environment defines the resources, setup, and network access for that workspace. Setup can prepare the dependencies the work requires before the workspace is used.

Independent execution sessions that use a sandbox have separate workspaces. In this example, a subagent shares the main agent’s sandbox to inspect the patch and run the regression test. Delegation can also give a subagent its own sandbox or no sandbox. Advisor and Supervisor reviews have no sandbox or credentials; they read only the permitted evidence for the thread they review.

RMA also distinguishes working files from finished outputs. Uploaded inputs can be attached read-only, while files explicitly saved as deliverables remain available for preview and download. This makes the result a concrete artifact a person can inspect and use.

A workspace can be restored after idle compute is released. Running processes have a shorter lifetime and may need to restart. This lets a team continue work from its saved state without assuming that the underlying computer stayed active throughout the pause.

Sessions and events

The main session holds the continuing record of a job. It connects the objective and agent version with messages, actions, files, and results. Delegated work and linked reviews have their own threads, connected to the job. Events capture the steps along the way: tool calls and responses, status changes, interventions, and grading activity. The timeline connects the final answer to the work behind it.

Work can begin in the console, through the API, in Slack, or from an automation. A Slack conversation can carry follow-up messages into the same session and bring progress back to the thread. Automations can start sessions from schedules, GitHub or Slack events, and configured webhooks. Their saved agent version, environment, and instructions make recurring work explicit; teams can pause automations, manage overlapping scheduled runs, and inspect run history. In the bug-fix job, the GitHub trigger, delegated test check, and saved patch stay connected to the same job.

People remain part of the session. They can add context, queue guidance, interrupt a run, cancel it, or resume it. A browser handoff can bring a person in for a step that needs their participation. These controls make it practical to adjust work as requirements change.

For investigation, the session analyst can examine the recorded activity and explain errors or coordination issues without taking over the workspace. Analytics shows organization usage and operational performance. An agent’s Observability tab shows its sessions, tool errors, and activity by version. A completed session establishes that execution ended; outcome grading supplies a separate judgment about the result.

Interventionist

Suppose the bug-fix agent repeatedly calls a tool that returns errors. The Interventionist detects the pattern in the session record. Its rules also detect repeated calls and revisions that leave grading failures unresolved. Rules and their template guidance require no separate model call.

With Supervisor review enabled, the detected concern goes to a model for review while the agent continues working. The Supervisor decides whether guidance is useful. If it declines, no guidance is delivered; if the review fails, active rules can provide template guidance. Separate rules for announcing work without acting or waiting on silent subagents respond directly, without Supervisor review.

When a Supervisor review is ready, RMA rechecks that the concern is still relevant and recent before delivering guidance at a turn boundary. Resolved or stale findings are dropped. If the same problem persists despite repeated guidance, the Supervisor can pause the session for human input. A person’s reply resumes the work with its record intact.

Oversight
Triggered review

Interventionist rules

Detect a recurring problem

Supervisor decision

When enabled: decide whether to intervene

Recheck

Drop resolved or stale findings

Deliver guidance or pause

A pause waits for a human response

A decision to continue adds no notice. A human pause requires repeated prior guidance about the same problem.

Requested advice

Agent question

Advisor review

Answer returns when ready

Active rules can provide standard guidance directly when no Supervisor is active or its review fails. Decisions and supporting evidence remain connected to the session.

Teams can assess oversight in Shadow mode before allowing it to guide work in Active mode. The Interventionist, Advisor, and Supervisor are configured separately, with an Off setting for each.

Outcome grading

An outcome pairs the objective with a rubric: the criteria that define an acceptable result. Teams can set criteria for one session or save them with an agent version for recurring use. Clear criteria turn expectations into checks the agent can work toward and a grader can assess.

When a graded turn finishes, a separate grader reviews captured work and a frozen view of the writer’s activity. When a workspace is available, it can inspect files and run checks in its own copy. Teams can use the standard grader or a custom evaluator with its own model and instructions. Both use the same restricted review boundary and cannot edit the main agent’s live workspace.

Each criterion receives Pass, Fail, Not applicable, or Not evaluable, with a reason. In the first review round of our example, the grader might find that the test passes with the patch but does not reproduce the original bug. That failed criterion returns to the main agent as feedback. The agent revises the test, and a later review checks the updated work within the configured limit.

The review loop
01

Capture work

Files and activity

02

Grade criteria

Verdicts with reasons

03

Revise if needed

Review updated work

Each review assesses a specific version of the result. Failed criteria can guide a revision; Not evaluable stops the loop for clarification or evidence.

If no criterion fails but one is Not evaluable, automatic revision stops for clarification or missing evidence. A satisfied outcome requires at least one Pass and no Fail or Not evaluable verdicts. Reaching the review limit, finding every criterion inapplicable, needing clarification, and a grading error are recorded separately. Teams can see what was checked and why the review ended. The quality of that judgment depends on the criteria and available evidence.

Evaluations improve overall quality by validating the agent’s result against clear criteria, showing where it failed, and directing the next correction. OpenAI’s trace-grading guide reinforces this approach: structured grading turns each run into evidence, showing where the agent succeeded, where it failed, and whether a revision improved quality or introduced a regression.

Memory and context

Repeated tasks benefit from continuity. RMA supplies several kinds of context, each with a different role in how an agent works.

Skills

Authored procedures, references, and scripts give the agent a reusable way to perform a task. They are versioned and loaded when needed.

Memory

With memory enabled, completed sessions can contribute useful observations. Background curation refines, combines, or retires those memories for later work.

Files and history

With file history enabled, agents can search earlier deliverables. Explicitly referenced sessions provide a read-only view of the permitted history.

Learned memory can change independently of the agent’s saved version. Updates become available the next time the agent reads memory, including during an ongoing session.

Teams can inspect memories and their history, adjust memory settings, and remove memories that should no longer be used. A useful lesson can carry forward while people retain a way to review what the agent remembers. This is persistent context for future work; it does not require retraining the underlying model.

For recurring bug-fix jobs, a skill supplies the test procedure, a saved memory can capture a recurring setup issue, and a previous test report provides supporting evidence.

Improvement happens on different timelines: oversight guides execution, grading drives revisions within a job, and memory carries lessons into later sessions. People control changes to the agent’s versioned definition.

Background curation helps keep old advice from becoming a recurring mistake. The AWS recommendation is to consolidate related memories and prune outdated ones, following observations of agents treating resolved issues as active and repeating advice from superseded runbooks.

In an internal production analysis of 2,569 sessions, a migration agent’s final grading pass rate rose from roughly 6% to over 70% between two memory revisions, with the agent version and grader unchanged. The later group used about half as many grading rounds, with 22% lower median worker cost and 58% lower median grading cost.

Security

Enterprise agents need access to do useful work. RMA makes that access an explicit part of the configuration, from the people who operate the system to the accounts and tools an agent can use. The GitHub trigger in our example starts the job; repository access is a separate grant.

Agents, sessions, environments, and connections belong to an organization. Roles govern who can view or change them. Enterprise identity controls include SAML single sign-on, verified domains, and multifactor authentication requirements. Tenant administrators can review administrative changes in an audit log and filter them by organization.

Connections and tool grants determine the systems an agent can reach. For supported integrations, administrators can select allowed tools and narrow what a particular agent receives. The connected account’s own permissions remain a ceiling. Custom MCP connections expose the tools their server makes available to the supplied credentials, so teams should scope access at that server as well.

Credentials also have distinct exposure boundaries. Vault-backed MCP credentials can be attached to tool requests outside the model and sandbox. Credentials delivered directly as environment variables can be read by commands within the shared sandbox. Delegated workers sharing that workspace can therefore access those credentials, even when they have separate tool grants. Choosing the right connection method matters as much as choosing the right tools.

Sandbox network policies control destinations reachable from that workspace. Built-in integration tools run outside the sandbox but still honor the environment’s No access setting. Remote MCP connections, model calls, and web tools have separate controls. Together, these layers let teams define where work can happen, what it can access, and who can change those permissions.

Cost

A job may involve the main agent, subagents, teammates, supervisory model calls, and several grading rounds. RMA brings their usage together with billable tools and running sandbox compute so the session total reflects the work required to produce the result.

That makes architectural choices visible in the economics. More helpers or grading rounds can add model and compute usage. Interventionist rules and template guidance require no separate model call. Advisor and Supervisor reviews add model usage to the job’s total and budget, without starting another sandbox. Releasing idle compute reduces the time a workspace keeps incurring compute charges.

A displayed total can remain “so far” while work continues, compute stays active, or charges settle. The final total becomes available after the work and compute end and charges have settled. Session budgets, where enabled, can pause work before another model call; requests already in flight can still take the total beyond the threshold.

For the bug-fix job, the final total includes the delegated test check, Supervisor review, grading rounds, and compute used to produce the patch. Teams can review that settled cost alongside the test evidence and outcome verdicts before deciding whether to change the model, supervision, or rubric for the next run.

Across agent platforms, lightweight execution environments can also reduce infrastructure costs. MicroVMs use a minimal virtual-machine design to reduce startup time and memory overhead for isolated workloads. V8 isolates provide lightweight, separate execution contexts within a shared runtime, avoiding a separate virtual machine for each task. For suitable workloads, these designs let more work share the same hardware and spend fewer resources on starting and maintaining execution environments.

Getting started

Start with a bounded task and a result your team can judge. Choose or configure an agent, grant the tools it needs, and define the outcome criteria. The organization assistant can help prepare an agent configuration for a person to approve. Run the task, inspect the session and grading evidence, and review the settled cost before expanding its scope.

With execution, delegation, oversight, grading, and memory already connected, your team can spend less time building the agent system and more time getting useful work done. RMA provides that foundation, so you can focus on the task, the tools it needs, and what a good result looks like—a faster path from an idea to an agent doing useful work.

Explore Recursion Managed Agents