# Platform

Introspection runs versioned agent behavior in governed environments built for long-horizon work, records what happened, and gives you the evidence to improve it deliberately.

## How Introspection works

```text
Recipe → Runtime → Task → Conversation
  ↑                         │
  └────── Improvement ← Evidence
```

A **recipe** is a portable package of agent behavior kept in Git. It contains
instructions, agent definitions, skills, extensions, and capability policy.
**Pi** runs the agent loop from that definition. A **runtime** pins an immutable
recipe version and supplies the identity, bindings, sandbox, and infrastructure
needed to run it.

When an application asks a runtime to do something, Introspection creates a
**task** in an isolated sandbox. Its model calls, tool calls, messages, and
outcome are captured as a **conversation**. Tasks can continue across multiple
conversations while retaining their sandbox. Saved artifacts and evidence remain
after execution ends.

## What happens when a task runs

1. **Create.** An SDK call, CLI command, or dashboard action creates a [task](/platform/tasks-and-runs).
2. **Prepare.** The runtime creates an isolated [sandbox](/platform/tasks-and-runs#sandboxes), checks out the pinned recipe, and supplies its configured identity and [bindings](/platform/bindings).
3. **Run.** Pi executes the selected agent and its permitted tools inside that sandbox.
4. **Record.** Introspection preserves the [conversation](/platform/conversations) and emits [events](/platform/observations-and-patterns#events) as the agent works.
5. **Finish.** The sandbox is eventually destroyed, while saved state, artifacts, observations, and judgements remain available for investigation and improvement.

The sandbox is temporary. The evidence it produced is not.

## Control Plane and Data Plane

Introspection separates configuration from agent-run data. This boundary
explains where identity and credentials live, why every task is isolated, and
how different deployment models place customer data in different infrastructure.

| Plane | What it holds |
| --- | --- |
| **Control Plane** | Organizations, projects, deployments, API keys, integrations, recipes, runtimes, judges, experiments, endpoints, variables, and credentials |
| **Data Plane** | Tasks, conversations, events, judgements, observations, patterns, state, and artifacts |

The Data Plane can run in Introspection's Managed Cloud, your cloud account
through BYOC, or an on-premises environment. See [Deployment models](/platform/deployment),
[Security](/platform/security), and [Data handling](/platform/data-handling) for
the operational boundaries.

## Learning loop

Start with the strongest evidence you have. Open the exact conversation when a
user reports a problem, or look across observations and patterns to understand
recurring behavior. Make a focused recipe change and check it locally. Use an
offline evaluation for durable multi-step behavior, a calibrated judge for a
standard you need to track continuously, or an experiment when trustworthy
offline evidence cannot choose between versions.

To learn more, look at [Learn from production](/guides/learn-from-production).

## Explore the platform

| Area | Start with |
| --- | --- |
| Account and access | [Organizations and projects](/platform/projects), [Authentication and identity](/platform/authentication), [Tags](/platform/tags) |
| Run agents | [Runtimes and environments](/platform/runtimes), [Bindings](/platform/bindings), [Tasks and runs](/platform/tasks-and-runs), [Conversations](/platform/conversations), [State and artifacts](/platform/state-and-artifacts) |
| Observe and improve | [Observations and patterns](/platform/observations-and-patterns), [Judges and judgements](/platform/judges), [Experiments](/platform/experiments) |
| Integrations | [GitHub](/platform/github), [Connectors](/platform/connectors), [MCP and federation](/platform/mcp), [Model access and routing](/platform/llm-providers) |
| Deploy and secure | [Deployment models](/platform/deployment), [Infrastructure](/platform/infrastructure), [Security](/platform/security), [Data handling](/platform/data-handling) |

Platform

Introspection runs versioned agent behavior in governed environments built for long-horizon work, records what happened, and gives you the evidence to improve it deliberately.

How Introspection works

Recipe flows to Runtime, Task, Conversation, and Evidence; Evidence informs Improvement, which loops back to Recipe — Text representation of the diagram:
`Recipe → Runtime → Task → Conversation ↑ │ └────── Improvement ← Evidence`

A recipe is a portable package of agent behavior kept in Git. It contains instructions, agent definitions, skills, extensions, and capability policy. Pi runs the agent loop from that definition. A runtime pins an immutable recipe version and supplies the identity, bindings, sandbox, and infrastructure needed to run it.

When an application asks a runtime to do something, Introspection creates a task in an isolated sandbox. Its model calls, tool calls, messages, and outcome are captured as a conversation. Tasks can continue across multiple conversations while retaining their sandbox. Saved artifacts and evidence remain after execution ends.

What happens when a task runs

Create. An SDK call, CLI command, or dashboard action creates a task.
Prepare. The runtime creates an isolated sandbox, checks out the pinned recipe, and supplies its configured identity and bindings.
Run. Pi executes the selected agent and its permitted tools inside that sandbox.
Record. Introspection preserves the conversation and emits events as the agent works.
Finish. The sandbox is eventually destroyed, while saved state, artifacts, observations, and judgements remain available for investigation and improvement.

The sandbox is temporary. The evidence it produced is not.

Control Plane and Data Plane

Introspection separates configuration from agent-run data. This boundary explains where identity and credentials live, why every task is isolated, and how different deployment models place customer data in different infrastructure.

Plane	What it holds
Control Plane	Organizations, projects, deployments, API keys, integrations, recipes, runtimes, judges, experiments, endpoints, variables, and credentials
Data Plane	Tasks, conversations, events, judgements, observations, patterns, state, and artifacts

The Data Plane can run in Introspection’s Managed Cloud, your cloud account through BYOC, or an on-premises environment. See Deployment models, Security, and Data handling for the operational boundaries.

Learning loop

Start with the strongest evidence you have. Open the exact conversation when a user reports a problem, or look across observations and patterns to understand recurring behavior. Make a focused recipe change and check it locally. Use an offline evaluation for durable multi-step behavior, a calibrated judge for a standard you need to track continuously, or an experiment when trustworthy offline evidence cannot choose between versions.

To learn more, look at Learn from production.

Explore the platform

Area	Start with
Account and access	Organizations and projects, Authentication and identity, Tags
Run agents	Runtimes and environments, Bindings, Tasks and runs, Conversations, State and artifacts
Observe and improve	Observations and patterns, Judges and judgements, Experiments
Integrations	GitHub, Connectors, MCP and federation, Model access and routing
Deploy and secure	Deployment models, Infrastructure, Security, Data handling