AI Orchestration

Factory.ai
Missions &
Mindframes

Orchestrating complex AI workflows, end-to-end

Factory.ai

Workflow Engine

v2.0

Presenter AI Product Team

Focus Missions + Mindframes

Audience PMs & Engineers

Factory.ai / Core Product

Introduction to
Factory.ai Missions

An advanced AI workflow orchestration system that structures complex tasks into reliable, multi-step end-to-end executions.

Workflow Orchestration

Structures complex tasks into multi-step, ordered executions with full state management

Beyond Simple Prompts

Moves past single-turn LLM calls to execute full workflows from goal to completion

Built for Technical Reliability

Designed for AI product managers and engineers managing complex AI operations at scale

End-to-End Execution

Assigns AI agents and tools per step, maintaining shared context across the entire pipeline

Mission Architecture

GOAL

STEP GRAPH

AGENTS

TOOLS

MEMORY

EXECUTION

mission.run(goal="automate_workflow")

Architecture Comparison

Traditional Prompting vs. Missions

Legacy

Traditional Prompting

Single-Shot Interactions

Each prompt is isolated — no memory of prior responses. Every interaction starts from zero context.

No Persistent Memory

State is lost between calls. Re-explaining context becomes the user's burden on every subsequent prompt.

Weak Multi-Stage Reasoning

Complex tasks requiring chained logic, branching, or specialized sub-tasks degrade quickly in quality.

Pattern: User → Single LLM Call → Output

prompt

LLM

output

↩ repeat

Factory.ai

Missions

Structured Step Graph

Goals are decomposed into an explicit directed graph of steps — each node is a discrete, verifiable sub-task.

Specialized Agent Assignment

Each step is handled by the most capable agent or tool — research, code generation, summarization, and more.

Shared Context Across Steps

Persistent memory layer propagates outputs and metadata between steps for coherent end-to-end execution.

Pattern: Goal → Step Graph → Parallel Agents → Output

goal

step 1

step 2

step N

result

shared context layer — persists across all steps

Missions unlock reliable, repeatable AI workflows by treating complex goals as orchestrated programs — not one-off conversations.

Architecture Factory.ai

The Missions Architecture

Six core components that structure complex tasks into end-to-end AI workflow executions.

Components

6

01

Goal

The overarching objective of the workflow. Defines the high-level intent that drives all downstream step decomposition and agent assignment.

entry_point

02

Step Graph

Logical mapping of dependencies and sequential actions. A DAG structure that ensures correct ordering and parallel execution where applicable.

dag :: steps[]

03

Agents

Specialized AI models assigned to specific tasks within the step graph. Each agent operates within defined scope and communicates via shared context.

type: LLM | specialized

04

Tools

External capabilities and APIs utilized by agents to interact with the environment — web search, code execution, file I/O, and third-party integrations.

external_apis[]

05

Memory / Context

Shared state maintained across the entire execution. Enables agents to access prior outputs, accumulated data, and cross-step information seamlessly.

shared_state: persistent

06

Execution Engine

The system that drives step-by-step execution. Handles scheduling, error recovery, retries, and orchestrates the entire mission lifecycle end-to-end.

runtime: orchestrator

Structural

Relational

Operational

Execution flow:

Goal Steps Agents Tools Output

Mission Architecture

Defining the Goal and Step Graph

A Mission begins with a clear overarching goal, which the system decomposes into actionable steps — organized as a dependency-aware execution graph.

Step 01

Define the Goal

A Mission begins by establishing a clear, overarching objective — the north star for the entire workflow execution.

mission.goal string | structured

Step 02

Decompose into Steps

The system automatically breaks the goal into discrete, actionable steps — each with a clear responsibility and defined inputs/outputs.

decompose() Step[]

Step 03

Build the Step Graph

Steps are organized into a DAG — mapping dependencies, parallel branches, and sequential logic required to achieve the goal.

StepGraph DAG

step_graph.visualize()

GOAL

Single Source of Truth

Research

Analyze

Draft

Agent A

parallel

Agent B

parallel

Synthesize

sequential

OUTPUT

Mission Complete

Dependencies

Steps can depend on prior step outputs before execution

Parallel Execution

Independent branches run concurrently to reduce latency

Sequential Logic

Ordered steps enforce correct data flow and causality

Mission Architecture

Assigning Agents & Tools

Each step in the graph receives a designated agent or tool — creating a structured, composable execution pipeline.

Step Graph

Step-Level Assignment

Within the step graph, every node (step) is explicitly mapped to either an AI agent or a tool. This declarative assignment model ensures each sub-task has a dedicated executor with the right capabilities.

step: "research_topic"

assigned_to: agent.researcher

tools: [web_search]

Agents

Reasoning Engines

Agents function as autonomous reasoning engines for specific sub-tasks. Each agent operates on the step's input context, applies LLM-driven logic, and produces structured outputs consumed by downstream steps.

Receives step context from memory

Executes reasoning chain (CoT / ReAct)

Delegates to tools when needed

Returns typed output to execution engine

Tools

External Capabilities

Tools extend agent capabilities beyond LLM reasoning, providing access to real-world systems and data. Agents invoke tools via structured function calls during step execution.

Web Scraper

Code Exec

API Calls

Execution Flow

Mission Goal

Step Graph

Agent Assignment

Tool Invocation

Output → Memory

Next Step

CORE MECHANISM

Memory & Shared Context

How Factory.ai Missions prevent context-loss across multi-step executions

1

STEP 01

Data Gathering

Agent collects raw data, sources, and initial analysis. Outputs stored to shared memory layer.

raw_data[] sources[]

2

STEP 02

Analysis & Reasoning

Agent reads Step 1 outputs from memory. Applies reasoning, generates insights, writes conclusions back.

insights[] reasoning

3

STEP 03

Output Generation

Full access to Steps 1+2: data, reasoning, and context. Generates final output without hallucination.

final_output verified

SHARED MEMORY LAYER — persists outputs, reasoning & data across all steps

step_1_output

step_2_output

step_3_output

Critical Differentiator

Unlike single-prompt AI, Missions maintain a persistent shared context — the defining architectural advantage over traditional LLM calls.

Full Context Access

Any agent on Step N has complete read access to all prior outputs, reasoning chains, and intermediate data — nothing is lost between steps.

Prevents Hallucination

Grounding each step in verified prior outputs eliminates context-loss drift — the primary source of hallucination in deep multi-step workflows.

Architecture Component

The Execution Engine

The runtime core that drives Missions end-to-end — traversing the step graph, orchestrating agents and tools, and maintaining resilient state throughout.

Step Graph Traversal — Live Execution Flow

INIT

Goal

S-1

Step 1

S-2

Step 2

S-3

Step 3

DONE

Output

Graph Traversal

.traverse(stepGraph)

Walks the directed step graph in dependency order, resolving which agents and tools to invoke at each node. Ensures upstream outputs are available before downstream steps begin.

topological sort dependency graph

Agent & Tool Dispatch

.dispatch(agent | tool)

Triggers the correct AI agent or tool assigned to each step, passing relevant context and inputs. Coordinates parallel or sequential execution based on the graph topology.

async dispatch context injection

State & Recovery

.recover(error, state)

Manages shared workflow state across all steps and handles failures gracefully — retrying, rerouting, or escalating errors — to guarantee end-to-end execution success.

retry logic state persistence

Mission Example Research Automation

Real-World Example: Research Automation

Agent A

Data Gatherer

Tools

web_search() fetch_url() scrape()

Deploys search tools to scan the web, academic sources, and industry databases — collecting raw market data at scale.

Output: raw_data[]

step 1→2

Agent B

Data Filter

Tools

relevance_score() dedup() rank()

Applies relevance scoring and deduplication to Agent A's output — surfacing only high-signal, actionable data points.

Output: filtered_data[]

step 2→3

Agent C

Synthesizer

Tools

summarize() generate_report()

Reads both raw and filtered data from shared context, then synthesizes a coherent, structured market research report.

Output: final_report.md

Shared Mission Context

Persists across all steps

raw_data[] filtered_data[] mission_goal step_outputs{}

Synthesis accurately reflects initial raw data

Factory.ai › Missions › Real-World Example

Real-World Example: Coding Workflows

Mission Goal

Develop and test a new software feature — end-to-end, autonomously.

Step 01

Coding Agent

Writes the core business logic for the new feature based on the mission specification.

def process_feature(input):

return transform(input)

AI Agent

Step 02

Test Runner Tool

Executes the full unit test suite against the code generated in the previous step.

RUNNING test_suite.py

✓ 14 passed ✗ 2 failed

Automated Tool

Step 03

Reviewer Agent

Analyzes test outputs, diagnoses failures, and determines whether code is ready for deployment.

REVIEW complete

coverage: 98.2% ✓

AI Agent

Execution Engine Guarantee

The step-by-step execution model ensures code is never deployed until all tests pass. Each step's output becomes the next step's input — maintaining shared context throughout.

vs. Traditional AI Usage

Unlike single prompt-response interactions, Missions orchestrate multi-agent collaboration with conditional logic, memory, and verified outputs at each stage.

OUTPUT LAYER

Presenting Workflows with Mindframes

Once a Mission completes, its structured outputs are transformed into professional stakeholder presentations via Mindframes.

STEP 01

Mission Execution

Complex multi-step workflow runs to completion — agents, tools, and memory coordinated by the execution engine.

goal_achieved: true

steps_completed: all

context: persisted

STEP 02

Collect Structured Outputs

The execution engine consolidates all step results, agent findings, and tool outputs into structured data objects.

findings: [ ... ]

metrics: { ... }

artifacts: attached

STEP 03

Feed into Mindframes

Structured data and outputs are passed to Mindframes, which transforms them into slide-ready presentation content.

slide_count: auto

format: stakeholder

output: presentation

OUTPUT

Professional Presentation

Stakeholder-ready slides with charts, summaries, and insights generated automatically from Mission results.

Auto-structured slides

Data-driven visuals

Stakeholder narrative

Research Automation

Mission findings → summary deck

Report Generation

Structured reports → slide narratives

Coding Workflows

Dev outputs → technical briefings

workflow.integration

The Integration Workflow

A seamless pipeline connecting Mission execution to polished visual presentations — end-to-end, automated, precise.

01

Run Mission

Execute the end-to-end step graph. Agents and tools run in sequence, maintaining shared context across every node.

execution_engine.run()

02

Collect Outputs

Gather final data, execution logs, and synthesized context produced by the mission into a structured output bundle.

outputs.collect(results)

03

Feed into Mindframes

Transfer the structured data payload to the Mindframes presentation engine. Context, insights, and data all pass through.

mindframes.ingest(data)

04

Generate Presentation

Mindframes automatically creates a polished visual deck — structured slides, charts, and insights rendered instantly.

mindframes.generate(deck)

End-to-end automated

Structured context transfer

Zero manual reformatting

Visual deck auto-generated

Practical Example

Report Generation Pipeline

Mission orchestrates data analysis → Mindframes transforms outputs into slides

Step 01

Mission Execution

mission = Mission(
  "Q4 Performance Report",
  steps=[aggregate, calc_kpis,
        write_summary]
)
# → structured JSON output

Aggregates quarterly data from multiple sources

Calculates KPIs: revenue, growth, churn metrics

Writes structured executive summary

Step 02

Mission Outputs

"metrics": { revenue: 4.2M, growth: "summary": "Q4 exceeded targets...",
"charts_data": [ quarterly_arr ]

Step 03

Mindframes Generation

Maps JSON metrics → slide structure automatically

Auto-generates charts from data arrays

Renders bullet points from summary text

Zero Manual Formatting

Mission outputs feed directly — no copy-pasting or reformatting needed

Repeatable Workflow

Run the same Mission every quarter; Mindframes regenerates slides automatically

Data-Accurate Visuals

Charts rendered directly from computed metrics, eliminating transcription errors

Mindframes Output

Q4 Performance Dashboard

Total Revenue $4.2M ▲ 18%

Active Users 84,200 ▲ 12%

Customer Retention 94.3%

Auto-generated insight: Q4 exceeded all quarterly targets. Revenue growth driven by enterprise tier expansion (+31% YoY).

Conclusion

End-to-End AI Operations

Two purpose-built systems. One seamless pipeline from complex execution to polished communication.

Orchestration Layer