Components Overview¶

Components are the building blocks of every solution in Manifest Platform. Each component has a single responsibility, a well-defined interface, and can be versioned, shared, tested, and reused independently.

Component Types¶

Manifest Platform defines eleven component types. Together, they cover AI orchestration, data processing, validation, state management, and observability.

Type	Description	Typical Use
Agent	AI agent with model access, tools, and guardrails	Conversational AI, decision-making, autonomous tasks
Workflow	Multi-step automation with nodes, edges, and triggers	Data pipelines, approval flows, orchestration
Code Block	Executable code in Python, TypeScript, JavaScript, SQL, or Bash	Custom logic, data processing, integrations
Tool	Callable capability exposed to agents	API calls, data lookups, side effects
Model	Configured LLM with provider, parameters, and routing	GPT-4, Claude, Gemini, self-hosted models
Prompt	Versioned prompt template with variable interpolation	System instructions, few-shot examples
Schema	Structured data type definition	Input/output contracts, validation shapes
Transform	Data transformation between components	Reshaping payloads, format conversion
Validation	Data quality and business logic rules	Not-null checks, range validation, custom rules
State	State management definition	Session state, conversation memory, context
Observability	Monitoring and tracing configuration	Metrics, logs, traces, alerts

Component Lifecycle¶

Every component follows the same lifecycle from creation through deployment:

graph LR
    C["Create"] --> CF["Configure"]
    CF --> T["Test"]
    T --> V["Version"]
    V --> D["Deploy"]
    D --> M["Monitor"]

    T -->|"Issues found"| CF
    M -->|"Iterate"| V

Create -- Define the component with a name, slug, and type-specific configuration.
Configure -- Set up references to other components (model refs, tool refs, schema refs), write code, configure parameters.
Test -- Validate the component in isolation. Agents can be tested in the playground, code blocks validate syntax automatically, workflows can be dry-run.
Version -- Create new versions when you make changes. The platform tracks version history and changelogs.
Deploy -- Deploy through a solution to a deployment ring. The platform manages container lifecycle and endpoint routing.
Monitor -- Track execution metrics, errors, and performance through observability specs and the platform dashboard.

Shared Properties¶

All component types share a common set of properties regardless of their specific type:

Property	Type	Description
`id`	UUID	Unique identifier
`name`	string	Human-readable display name (max 200 chars)
`slug`	string	URL-safe identifier (`^[a-z0-9-]+$`)
`version`	string	Semantic version (`major.minor.patch`)
`description`	string	Optional description (max 2000 chars)
`tags`	string[]	Freeform tags for filtering and organization
`certification_status`	enum	`draft`, `submitted`, `certified`, `deprecated`
`visibility`	enum	`private`, `workspace`, `organization`, `marketplace`
`owner_id`	UUID	User who owns this component
`org_id`	UUID	Organization this component belongs to
`workspace_id`	UUID	Workspace this component belongs to
`source_solution_id`	UUID	Solution that generated this component (if any)
`created_at`	datetime	Creation timestamp
`updated_at`	datetime	Last update timestamp
`created_by`	UUID	User who created this component
`updated_by`	UUID	User who last updated this component
`archived_at`	datetime	Soft-delete timestamp (null if active)

Creating Components¶

Components are created through the SDK or the platform UI:

PythonUI

Coming Soon

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

from flow_sdk.cli_client import CLIClient

client = CLIClient(config)

# Create a model component
model = client.models.create({
    "name": "GPT-4o",
    "slug": "gpt-4o",
    "model": "openai/gpt-4o",
    "provider": "openai",
    "temperature": 0.7,
    "max_tokens": 4096,
})

Navigate to Components, select a type tab, click New Component. Fill in the configuration and click Create.

Versioning Components¶

When you update a component, you can create a new version rather than modifying the existing one. This preserves the full history of changes and allows rollback.

Coming Soon

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

from flow_sdk.cli_client import CLIClient

client = CLIClient(config)

new_version = client.agents.create_version(agent_id, {
    "version_increment": "minor",  # "major", "minor", or "patch"
    "updates": {"tool_refs": updated_tool_list},
    "change_summary": "Added knowledge base search tool",
})

print(f"New version: {new_version.version}")

Viewing Version History¶

Coming Soon

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

versions = client.agents.list_versions(agent_id)

for v in versions.items:
    print(f"v{v.version} — {v.updated_at}")

Viewing Changelogs¶

Coming Soon

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

changelog = client.agents.get_changelog(agent_id)

for entry in changelog.items:
    print(f"v{entry.version}: {entry.change_summary}")

Listing and Filtering¶

The list endpoint supports filtering by tags, search text, association status, and deployment state:

Coming Soon

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

from flow_sdk.cli_client import CLIClient

client = CLIClient(config)

# List all agents in the workspace
agents = client.agents.list(
    search="customer",
    tags=["production", "support"],
    deployed=True,
    limit=50,
)

for agent in agents.items:
    print(f"{agent.name} v{agent.version} [{agent.certification_status}]")

Association Filters¶

Filter	Description
`association="linked"`	Components that belong to at least one solution
`association="orphaned"`	Components not linked to any solution
`deployed=True`	Components with an active deployment
`deployed=False`	Components without any active deployment
`solution_id=<uuid>`	Components linked to a specific solution

Component References¶

Components reference each other through UUID refs. These references create a dependency graph that the platform uses for validation, deployment ordering, and impact analysis.

graph TD
    Agent["Agent<br/><i>customer-support</i>"]
    Model["Model<br/><i>gpt-4o</i>"]
    Tool1["Tool<br/><i>search-kb</i>"]
    Tool2["Tool<br/><i>create-ticket</i>"]
    Prompt["Prompt<br/><i>support-instructions</i>"]
    Schema["Schema<br/><i>ticket-output</i>"]
    CB["Code Block<br/><i>kb-search-impl</i>"]

    Agent -->|"model_ref"| Model
    Agent -->|"tool_refs"| Tool1
    Agent -->|"tool_refs"| Tool2
    Agent -->|"prompt_ref"| Prompt
    Agent -->|"schema_refs.output"| Schema
    Tool1 -->|"code_block_id"| CB

Build leaves first

When building a solution, start with leaf components (models, schemas, prompts, code blocks) that have no dependencies. Then build the components that reference them (tools, agents, workflows). The solution skeleton's creation_order field reflects this ordering.

Archiving Components¶

Deleting a component performs a soft-delete (archive). Archived components are hidden from default list queries but can be restored.

Coming Soon

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

from flow_sdk.cli_client import CLIClient

client = CLIClient(config)

client.tools.delete(tool_id)

To include archived components in queries:

Coming Soon

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

all_tools = client.tools.list(include_archived=True)

Blocked deletions

A component cannot be archived if it has active deployments or is referenced by other active components. The API returns a 403 with details about what is blocking the deletion.