Agent Builder¶

The Agent Builder is the primary interface for creating and configuring agents in Manifest Platform. It provides a visual workspace where you assemble an agent from components -- model, prompt, tools, schemas -- and configure execution parameters.

Creating an Agent¶

Navigate to Solution Builder > Agents and click New Agent. You will be prompted for:

Field	Description	Example
Name	Human-readable agent name	`Customer Support Agent`
Slug	URL-safe identifier (auto-generated from name)	`customer-support-agent`
Description	What this agent does	`Handles tier-1 support tickets using Jira and knowledge base`
Framework	Agent runtime framework	`pydantic_ai` (default)
Version	Semantic version	`1.0.0`
enable_conversations	Persist message history across turns (bool, default `false`)	`false`
persona_constraints	Behavioral guardrails applied at runtime (list of strings)	`["never share PII", "escalate legal questions"]`
tags	Labels for search and filtering	`["support", "tier-1"]`
certification_status	Lifecycle stage: `draft`, `certified`, or `deprecated`	`draft` (default)
visibility	Who can see and use the agent	`workspace` (default), `private`, `organization`, `marketplace`
marketplace_publisher	Publisher name when `visibility` is `marketplace` (optional)	`Acme Corp`

Frameworks

Manifest Platform supports multiple agent frameworks: pydantic_ai, langchain, google_adk, and strands. Pydantic AI is the default and recommended framework for most use cases.

Configuring the Model¶

Every agent requires a model component that defines which language model to use. Select an existing model from your workspace or create a new one.

A model component specifies:

Provider and model string -- e.g., anthropic/claude-sonnet-4-20250514, openai/gpt-4o
Temperature -- Controls response randomness (0.0 = deterministic, 2.0 = highly creative)
Max tokens -- Upper limit on response length
Top-p -- Nucleus sampling parameter
Timeout -- Maximum seconds to wait for a model response
Fallback chain -- Backup models if the primary is unavailable

{
  "name": "Claude Sonnet",
  "slug": "claude-sonnet",
  "model": "anthropic/claude-sonnet-4-20250514",
  "provider": "anthropic",
  "temperature": 0.3,
  "max_tokens": 4096,
  "use_proxy": true,
  "fallback_to_direct": true
}

AI Gateway routing

When use_proxy is enabled, all model calls route through the platform's AI Gateway (powered by LiteLLM). The gateway handles API key management, rate limiting, cost tracking, and automatic fallback -- your agent configuration never contains raw provider API keys.

Writing the System Prompt¶

The system prompt defines your agent's behavior, personality, and constraints. You can configure it in two ways:

Inline Prompt¶

Write the system message directly in the agent configuration. Good for simple agents.

Prompt Component¶

Reference a versioned prompt component for reuse across agents. Prompt components support:

Static templates with variable interpolation ({customer_name}, {company})
Dynamic function refs that generate prompt content at runtime
Role assignment (system, user, assistant)

Simple inline promptPrompt component (YAML)

You are a customer support agent for Acme Corp. You help customers
with billing questions, account issues, and product inquiries.

Rules:
- Always be polite and professional
- Never share internal pricing or discount structures
- Escalate refund requests over $500 to a human agent
- Use the knowledge base tool before saying "I don't know"

name: Support Agent Prompt
slug: support-agent-prompt
system_message: |
  You are a customer support agent for {company_name}.
  You help customers with billing, account, and product questions.

  Rules:
  - Always be polite and professional
  - Escalate refund requests over ${refund_threshold} to a human
  - Use the knowledge base tool before saying "I don't know"
static_templates:
  - content: "Customer context: {customer_context}"
    role: system
    variables: ["customer_context"]

Attaching Tools¶

Tools give your agent the ability to take actions beyond text generation. In the Agent Builder, you add tools by selecting from available tool components in your workspace.

Tool Types¶

Implementation Type	Description	Example
`codeblock`	Runs a Python code block	Data transformation, calculations
`function`	Calls a Python function path	Internal service calls
`api_endpoint`	Calls an external HTTP endpoint	Third-party API integrations
`agent`	Delegates to another agent	Specialized sub-tasks
`dataset`	Queries a dataset catalog entry	Knowledge retrieval, lookup tables
`mcp_server`	Routes calls through an MCP server	Platform-managed connector tools

Connector-Based Tools¶

Connectors with MCP enabled automatically generate tools that agents can use. When you attach a connector instance to an agent, its operations become callable tools. See MCP Configuration for details.

Tool Configuration¶

Each tool component defines:

{
  "name": "Search Knowledge Base",
  "slug": "search-knowledge-base",
  "implementation_type": "codeblock",
  "implementation_ref": "a1b2c3d4-...",
  "parameters": [
    {
      "name": "query",
      "type": "string",
      "description": "Search query text",
      "required": true
    },
    {
      "name": "max_results",
      "type": "integer",
      "description": "Maximum results to return",
      "required": false,
      "default": 10
    }
  ],
  "timeout_seconds": 30,
  "retry_max_attempts": 2
}

Tool count considerations

While there is no hard limit on tools per agent, each tool adds to the model's context window. Most agents work best with 5-15 focused tools. If you need more, consider splitting into specialized sub-agents.

Structured Output¶

Attach a schema component to constrain the agent's response to a specific structure. This is useful when agent output feeds into downstream systems.

{
  "schema_type": "json_schema",
  "fields": [
    {"name": "sentiment", "type": "string", "description": "positive, negative, or neutral"},
    {"name": "confidence", "type": "number", "description": "0.0 to 1.0"},
    {"name": "topics", "type": "array", "description": "List of detected topics"},
    {"name": "summary", "type": "string", "description": "One-sentence summary"}
  ],
  "strict_validation": true
}

When structured output is configured, the platform validates the agent's response against the schema before returning it to the caller. Invalid responses are retried automatically.

Conversation Persistence¶

Enable enable_conversations to give the agent memory across turns. With conversations enabled:

Message history is stored and loaded automatically per conversation ID
The agent sees all prior turns when processing a new message
Conversations can be listed, retrieved, and deleted via the API

This is essential for chatbot-style agents but adds token cost for long conversations.

Visibility and Access¶

Control who can see and use the agent:

Visibility	Who Can Access
`private`	Only the creator
`workspace`	Anyone in the workspace
`organization`	Anyone in the organization
`marketplace`	Published to the component marketplace

Validation¶

Before saving, the Agent Builder validates your configuration:

Model reference exists and is accessible in your workspace
All tool references resolve to valid tool components
Prompt reference (if used) exists
Schema references are valid
No circular dependencies (agent tools referencing the same agent)

Validation issues are categorized as errors (must fix), warnings (should fix), and info (suggestions).

SDK Example¶

You can also create agents programmatically using the SDK:

Coming Soon

The Python SDK for local development is not yet publicly available.

from flow_sdk.cli_client import CLIClient

client = CLIClient(config)

agent = client.agents.create({
    "name": "Data Analyst",
    "slug": "data-analyst",
    "description": "Analyzes datasets and generates insights",
    "model_ref": "uuid-of-model-component",
    "tool_refs": [
        "uuid-of-query-tool",
        "uuid-of-chart-tool",
    ],
    "prompt_ref": "uuid-of-analyst-prompt",
    # schema_refs is a dict[str, UUID] — multiple named schemas can be attached
    "schema_refs": {
        "output": "uuid-of-output-schema",
        "context": "uuid-of-context-schema",
    },
    "tags": ["analytics", "reporting"],
    "certification_status": "draft",
    "visibility": "workspace",
})

print(f"Created agent: {agent['id']}")

Or use the Agent Builder UI: navigate to Components > Agents > New, fill in the configuration, and click Create.

Next Steps¶

Once your agent is configured, head to the Playground to test it interactively before deploying.