> ## Documentation Index
> Fetch the complete documentation index at: https://docs.labelbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Managed Agents

> Run agents in managed sandboxes with tools and credentials, follow every step, and grade the result against your own rubric.

Recursion Managed Agents runs agents that need a sandbox, tools, and more than one model turn. Each session keeps a durable record that you can inspect, continue, or grade.

<Warning>
  Recursion Managed Agents is designed around persistent, stateful sessions. Agent sessions may remain active over extended periods, resume after interruptions, and retain conversation history, sandbox state, and generated outputs on the server.

  Because Managed Agents relies on this server-side state, it is currently not supported for customers requiring Zero Data Retention (ZDR) or HIPAA Business Associate Agreement (BAA) coverage. Customers with an active BAA or ZDR arrangement, or with a use case that requires either, cannot use Recursion Managed Agents at this time.
</Warning>

## What do you want to do?

<CardGroup cols={2}>
  <Card title="Run your first graded task" icon="play" href="/managed-agents/quickstart">
    Create an API key, an environment, and an agent, then read a grader's verdict. About 10 minutes.
  </Card>

  <Card title="Understand the model" icon="diagram-project" href="/managed-agents/how-it-works">
    See how agents, environments, sessions, vaults, and outcomes fit together.
  </Card>

  <Card title="Build in the console" icon="display" href="/managed-agents/console">
    Find the screen for each setup, launch, and inspection task.
  </Card>

  <Card title="Call the API" icon="code" href="/managed-agents/api">
    Install an SDK, authenticate, and learn the retry and paging rules.
  </Card>

  <Card title="Connect your apps" icon="plug" href="/managed-agents/integrations">
    Let agents work in 164+ apps, choose their tools, or add any MCP server.
  </Card>

  <Card title="Split work across agents" icon="users" href="/managed-agents/multi-agent">
    Delegate to subagents or let a team share a task board.
  </Card>

  <Card title="Automate sessions" icon="clock" href="/managed-agents/automations">
    Run agents on a schedule or when Slack, GitHub, or a webhook sends an event.
  </Card>

  <Card title="Give agents memory" icon="brain" href="/managed-agents/memory">
    Let agents learn from past sessions and read your curated knowledge.
  </Card>

  <Card title="Connect a coding agent" icon="terminal" href="/managed-agents/ai-coding-agents">
    Let your AI coding agent read these docs and call the API for you.
  </Card>

  <Card title="Fix a problem" icon="wrench" href="/managed-agents/troubleshooting">
    Match an error code or symptom to its cause and fix.
  </Card>
</CardGroup>

## What you can do

| Capability                          | What it gives you                                                                                                                                                                                                                                                              |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Versioned agents                    | A model, system prompt, tools, skills, MCP servers, and credential grants, saved as immutable versions. See [Agent setup](/managed-agents/agents).                                                                                                                             |
| Managed sandboxes                   | A workspace per session tree, with a setup script you verify once, sized compute, and an egress policy. See [Environments](/managed-agents/environments).                                                                                                                      |
| Durable sessions                    | Every message, tool call, and result is recorded. Stream it live, resume after it ends, or send a follow-up. See [Sessions](/managed-agents/sessions).                                                                                                                         |
| Graded outcomes                     | A separate grader checks each rubric criterion and sends the work back until it passes. See [Outcomes](/managed-agents/outcomes).                                                                                                                                              |
| Work in your apps                   | Connect GitHub, Slack, Jira, Confluence, and 164+ catalog apps such as Salesforce, Zendesk, HubSpot, and Snowflake, choose which tools agents may use, and grant them to agents. See [Integrations](/managed-agents/integrations) and [GitHub access](/managed-agents/github). |
| Memory that learns                  | Agents learn from their finished sessions automatically, and you can add curated memory stores, review every change, and roll back. See [Memory](/managed-agents/memory).                                                                                                      |
| Files in and out                    | Upload inputs once and attach them to any session, show images and documents in a message, and download every deliverable. See [Files](/managed-agents/files).                                                                                                                 |
| Automations                         | Start sessions on a schedule, from Slack, GitHub, or webhook events, or by hand, with the same agent version and credentials every run. See [Automations](/managed-agents/automations).                                                                                        |
| Credentials without pasting secrets | Vaults hold tokens and keys. MCP tokens are attached outside the sandbox. See [Vaults](/managed-agents/vaults).                                                                                                                                                                |
| Multi-agent work                    | Delegate to subagents, consult an advisor, or run a team with a shared board, all in one sandbox. See [Teams](/managed-agents/teams).                                                                                                                                          |
| Deliverables                        | Agents save named files that are kept at the end of each turn and checked by the grader. See [Artifacts](/managed-agents/artifacts).                                                                                                                                           |
| Cost and analytics                  | Model cost for one session or a whole tree, and organization-wide charts of usage, completions, and environment startup. See [Usage and cost](/managed-agents/usage-and-cost) and [Analytics](/managed-agents/analytics).                                                      |
| Evaluations                         | Score finished sessions against a keyed rubric and compare quality by agent version. See [Evaluations](/managed-agents/evaluations).                                                                                                                                           |
| API keys and roles                  | Personal API keys scoped to your tenant or one organization, with role-based access checked on every request. See [API keys](/managed-agents/api-keys).                                                                                                                        |

## How it fits together

```mermaid theme={"theme":"css-variables"}
flowchart LR
  you["You: console or API"] -->|"start with a task"| session["Session"]
  agent["Agent version"] --> session
  environment["Environment"] --> session
  vaults["Vaults"] -->|"granted credentials"| session
  integrations["Integrations"] -->|"granted apps"| session
  session --> sandbox["Sandbox: files, shell, tools"]
  session --> events["Event log"]
  session --> outcome["Outcome: grader verdict"]
  events --> you
  outcome --> you
```

You start a session with an agent and an environment. The session freezes both, so later edits never change work in progress. The agent works in its sandbox, every step lands in the event log, and a grader decides when the work meets your rubric. [How it works](/managed-agents/how-it-works) explains each piece.

## When to use Managed Agents

Use Managed Agents when the work needs one or more of these:

* Several model turns and tool calls.
* A shell, files, package installation, or a browser in a sandbox.
* Work in other systems, such as Salesforce, Jira, or Snowflake, an API with a token, or an MCP server.
* A rubric that sends incomplete work back for revision.
* A durable record you can review, audit, or continue later.

For a single model response with no tools or sandbox, call the model directly instead.

## Next steps

<CardGroup cols={2}>
  <Card title="Quickstart" href="/managed-agents/quickstart">
    Run a graded task in the console or with code.
  </Card>

  <Card title="How it works" href="/managed-agents/how-it-works">
    Learn the concepts and see the session, credential, and grading flows.
  </Card>

  <Card title="API conventions" href="/managed-agents/api">
    Set up an SDK and learn the shared request rules.
  </Card>

  <Card title="Glossary" href="/managed-agents/glossary">
    Look up any term used in these docs.
  </Card>
</CardGroup>