Solution Builder¶

The Solution Builder is Manifest Platform's visual workspace for designing, assembling, and managing AI-powered solutions. It provides a structured approach to building complex systems from reusable, composable components -- agents, workflows, code blocks, tools, and more -- all within a governed, version-controlled environment.

What is the Solution Builder?¶

The Solution Builder turns high-level system designs into executable solutions. You start by describing your system architecture as a Mermaid diagram, and the platform analyzes the diagram to generate a component skeleton -- a structured plan of every piece that needs to be built. From there, you configure each component, test it individually, wire components together, and deploy the entire solution through managed deployment rings.

Design-first, build incrementally

The Solution Builder encourages a design-first approach. Sketch your architecture, let the platform break it into components, then implement each piece. You can always add, remove, or rearrange components as your understanding evolves.

Solutions vs Components¶

Manifest Platform draws a clear line between solutions and components:

Solutions are containers that group related components into a cohesive, deployable unit. A solution represents a complete business capability -- a customer support system, a data pipeline, a compliance automation workflow. Solutions are versioned with semantic versioning, and you promote an entire solution through deployment rings (development, staging, production).

Components are the individual building blocks inside a solution. Each component has a single responsibility and a well-defined interface. Components can be shared across solutions, versioned independently, and tested in isolation.

Concept	Scope	Example
Solution	A complete system that solves a business problem	"Customer Support Automation"
Component	A single building block with one responsibility	An agent, a workflow, a code block

Component-Driven Architecture¶

Every capability in Manifest Platform is expressed as a discoverable, composable component. The platform defines eleven component types, each serving a distinct role in the architecture:

graph TD
    S["Solution"]

    S --> A["Agent"]
    S --> W["Workflow"]
    S --> CB["Code Block"]
    S --> T["Tool"]
    S --> M["Model"]
    S --> P["Prompt"]
    S --> SC["Schema"]
    S --> TR["Transform"]
    S --> V["Validation"]
    S --> ST["State"]
    S --> OB["Observability"]

    A --> M
    A --> T
    A --> P
    A --> SC
    A --> ST
    A --> OB

    W --> A
    W --> CB
    W --> TR
    W --> V

    T --> CB

    TR --> SC

Components reference each other through typed refs. An agent references a model component (for LLM configuration), tool components (for capabilities), a prompt component (for instructions), and optionally schema, state, and observability components. Workflows reference agents and code blocks as execution nodes. This explicit wiring makes the architecture auditable and reproducible.

How It Works¶

1. Design with Mermaid¶

Start by describing your solution architecture as a Mermaid flowchart. The diagram captures the components and their relationships:

graph TD
    Classifier["Ticket Classifier Agent"]
    Router["Routing Workflow"]
    Responder["Response Agent"]
    Escalator["Escalation Code Block"]
    KB["Knowledge Base Tool"]

    Classifier --> Router
    Router --> Responder
    Router --> Escalator
    Responder --> KB

2. Generate Component Skeleton¶

The platform parses your Mermaid diagram and generates a skeleton -- a list of components with inferred types, descriptions, dependencies, and a recommended creation order. Each skeleton component starts in pending status.

3. Build Components¶

Work through the skeleton, configuring each component. The platform tracks your progress and respects dependency ordering -- it suggests building leaf components (tools, schemas, models) before the components that depend on them (agents, workflows).

4. Test and Iterate¶

Test components individually using the built-in execution system. Agents can be tested in the playground. Code blocks validate syntax automatically. Workflows can be dry-run before deployment.

5. Deploy¶

Promote your solution through deployment rings. The platform packages all components, manages versioning, and tracks execution metrics for each deployment.

Next Steps¶

Solutions

Create, version, and manage solutions.

Solutions
Components Overview

All component types at a glance.

Components
Agents

Build AI agents with tools and guardrails.

Agents
Workflows

Automate multi-step processes.

Workflows