Agent System

Manifest Platform agents are AI-powered components that combine a language model, a set of tools, and a system prompt to perform tasks on behalf of users. Agents can answer questions, invoke APIs, transform data, and orchestrate multi-step workflows -- all governed by the platform's security and observability controls.

---

How Agents Work

An agent receives a user prompt, reasons about it using the configured model, and decides whether to respond directly or call one or more tools. Tool results feed back into the model, which continues reasoning until it produces a final answer.

graph LR
    User["User Prompt"] --> Agent["Agent"]
    Agent --> Model["AI Model<br/>(via AI Gateway)"]
    Model --> Decision{Needs a tool?}
    Decision -- Yes --> Tool["Tool Execution"]
    Tool --> Model
    Decision -- No --> Response["Response"]

Each iteration of this loop is called a turn. An agent may take multiple turns to answer a single request -- for example, querying a database, then summarizing the results, then formatting them as a table.

---

Agent Components

Every agent is assembled from reusable platform components:

Component	Role	Required
Model	The language model that powers reasoning (e.g., anthropic/claude-sonnet-4-20250514)	Yes
Prompt	System instructions that define the agent's behavior and constraints	Yes
Tools	Callable capabilities the agent can invoke (API calls, code blocks, connectors)	No
Schema	Structured output contract that constrains the response format	No
State	Persistent memory across conversation turns (session or long-term)	No
Observability Spec	Tracing, metrics, and logging configuration	No

Component reuse

Models, prompts, tools, and schemas are standalone components. The same tool can be attached to multiple agents. The same model component can power dozens of agents across different solutions.

---

Agent Architecture

Under the hood, the platform compiles your agent configuration into a runtime execution graph:

graph TD
    AgentSpec["Agent Spec<br/>(configuration)"] --> Runtime["Agent Runtime"]
    Runtime --> Gateway["AI Gateway<br/>(model routing, rate limiting)"]
    Gateway --> Provider["Model Provider<br/>(Anthropic, OpenAI, etc.)"]

    Runtime --> ToolRouter["Tool Router"]
    ToolRouter --> CB["Code Block Tools"]
    ToolRouter --> CT["Connector Tools<br/>(via MCP)"]
    ToolRouter --> AT["API Endpoint Tools"]
    ToolRouter --> SubAgent["Sub-Agent Tools"]

    Runtime --> Guard["Guardrails"]
    Guard --> InputCheck["Input Validation"]
    Guard --> OutputCheck["Output Validation"]
    Guard --> Approval["Human Approval<br/>(if configured)"]

    Runtime --> Trace["Observability"]
    Trace --> Logs["Execution Logs"]
    Trace --> Metrics["Token & Latency Metrics"]
    Trace --> Cost["Cost Attribution"]

The AI Gateway handles model routing, API key management, fallback chains, and cost tracking. Your agent configuration references a model component -- the gateway resolves the actual provider call at runtime.

---

Types of Agent Interactions

Single-Turn

The agent receives one prompt and returns one response. This is the default mode.

User:  "Summarize the Q3 revenue data"
Agent: "Q3 revenue was $4.2M, up 18% from Q2..."

Multi-Turn Conversations

When enable_conversations is turned on, the agent retains message history across requests. Each follow-up message includes the full conversation context.

User:  "Pull the latest tickets from Jira"
Agent: [calls jira_list_tickets tool] "Found 12 open tickets..."
User:  "Which ones are critical?"
Agent: "3 tickets are marked critical: PROJ-101, PROJ-204, PROJ-317"

Tool-Augmented

Agents with tools can take actions beyond text generation. Tools let agents query databases, call external APIs, run code, and modify platform resources.

Structured Output

When a schema component is attached, the agent's response is constrained to match a defined structure. This is useful for downstream processing, form filling, or piping agent output into other components.

{
  "sentiment": "positive",
  "confidence": 0.92,
  "topics": ["pricing", "feature request"],
  "summary": "Customer is happy with the product but wants bulk pricing."
}

---

Agent Lifecycle

stateDiagram-v2
    [*] --> Draft: Create agent
    Draft --> Testing: Open in Playground
    Testing --> Draft: Iterate
    Testing --> Certified: Passes eval suite
    Certified --> Deployed: Promote to ring
    Deployed --> Certified: Roll back
    Certified --> Deprecated: Archive

1. Draft -- Configure the agent in the Agent Builder: select a model, write a prompt, attach tools.
2. Testing -- Use the Playground to run the agent against sample prompts. Compare model and prompt variants with A/B testing.
3. Certified -- Run an evaluation suite against a dataset to verify quality, then certify.
4. Deployed -- Promote the agent (as part of a solution) through deployment rings.
5. Deprecated -- Archive agents that are no longer needed.

---

Next Steps

• Agent Builder

  ---

  Configure agents with models, prompts, tools, and guardrails.

  Build an agent

• Playground

  ---

  Test agents interactively, compare variants, and run dataset evaluations.

  Open Playground

• Experiments

  ---

  A/B test agent configurations and promote winners.

  Run experiments