Skip to main content

​
AgentFlow

Everyone building with AI is focused on the model — which one, which version, which provider. But the model is increasingly table stakes. What determines whether an agent actually works in production is the system around it: the harness. The harness is everything the model can’t be on its own — tools, memory, orchestration, state, approvals, and guardrails. AgentFlow is that harness, purpose-built for multi-agent systems and ready to deploy the day you install it. Most AI deployments give you one model and a list of tools. AgentFlow gives you a coordinated team of specialized agents — each with its own domain, tools, and knowledge — orchestrated by a central dispatcher that routes every request to the right expert automatically.

​
Built like a team, not a chatbot

The orchestrator has one rule: delegate, never guess. Every request goes to the agent that owns that domain and has the tools to execute it.
Request typeDelegated to
Email: read, draft, send, manage inboxEmailsAgent
Tasks: create, assign, track, follow-upsTasksAgent
Meetings: schedule, availability, transcriptsMeetingsAgent
Research: web search, SEC filings, newsResearchAgent
CRM records: accounts, contacts, pipelinesRecordsAgent
Multi-part requests are decomposed automatically. “Draft an email and create a follow-up task” triggers sequential delegation to EmailsAgent then TasksAgent. The orchestrator delegates rather than guesses — if it doesn’t have a sub-agent with the right tools, it says so instead of fabricating an answer.

​
Everything is composable

Agents, tools, knowledge bases, and capabilities are independent building blocks. Wire them together in a few lines: 
from agentflow import AsyncAgentFlow, RunOptions

async with AsyncAgentFlow.from_profile("prod") as client:
    agent_id = (await client.agents.by_name("MainAgent")).id

    # Inspect composable building blocks
    tools = await client.agents.tools.list(agent_id)
    knowledge_bases = await client.agents.knowledge_bases.list(agent_id)

    # Chat - the agent uses assigned tools and knowledge automatically
    response = await client.agents.run(
        agent_id=agent_id,
        message="What's the status of order #4821?",
        options=RunOptions(knowledge_bases=[kb.id for kb in knowledge_bases]),
    )

​
Production is the problem. AgentFlow solves it.

Prototypes are easy. Production is the problem. AgentFlow includes the operational layer most teams spend 6-12 months building themselves: Security and isolation
  • JWT authentication with Auth0 bearer tokens, M2M support, and tenant isolation
  • Database-per-tenant architecture on Aurora/PostgreSQL
  • Human-in-the-loop approvals — gate sensitive tool executions with user confirmation
Reliability
  • Cooperative cancellation — cancel any running execution without corrupting state
  • Chat-history compaction — intelligent pruning with LLM summarization
  • Background workers — async batch processing, scheduled jobs, stale call cleanup
  • Health probes — /health (liveness) and /ready (readiness with DB check)
Observability
  • Structured SSE streaming with call hierarchies and sequence-ordered events
  • Full execution traces — every agent delegation, tool call, and result is tracked
  • Context window metrics — token usage, model, and cost data on every request

​
Deploy anywhere. Own everything.

AgentFlow ships as a self-contained system — not a SaaS dependency, not a vendor lock-in. Install it on AWS, GCP, Azure, or your own hardware. Fork it, extend it, white-label it. Your agents, your data, your infrastructure. Every layer is replaceable: swap the model provider, plug in a different vector store, add your own tools without touching the core. The orchestration layer, the RAG pipeline, the streaming engine — you own the source, you control the roadmap. Most agent platforms charge you to use their harness. You’re renting infrastructure you can’t inspect, can’t modify, and can’t take with you. AgentFlow is the alternative: a production-grade harness you install once and own outright.

​
Platform capabilities

Python SDK

Async-first SDK with Agent, Tool, KnowledgeBase, Skill, and Conversation classes

REST API

Full REST + SSE API with OpenAPI spec and interactive documentation

Knowledge Bases

Document processing, vector storage, hybrid search with configurable retrieval

Artifacts

Structured, interactive outputs — email drafts, meeting invites, CRM tables, tasks

Tool Registry

Composable tool system with approval gates, result caching, and shared instances

Streaming

Real-time SSE with call hierarchies, sequencing, and cooperative cancellation

Approvals

Human-in-the-loop approval workflows with audit trail and bulk operations

Authentication

Auth0 bearer tokens, machine clients, local dev bypass, and tenant binding

Usage & Budgets

Admin dashboard, spend tracking, monthly caps, and shared LLM rate controls

Batch Processing

Bulk classification, extraction, summarization, and enrichment at scale

Multi-Model

100+ providers via LiteLLM — with vision, reasoning controls, and BYO API keys

Personalization

Per-user model selection, tone, custom instructions, and adaptive memory

Prompt System

Modular prompt blocks with per-user config, preview, and validation

Context Blocks

Live CRM, tasks, memory, and org context injected into agent prompts automatically

Skills

Curated operational playbooks that teach agents domain-specific workflows

Activity Timeline

Unified email + meeting timeline for CRM accounts and contacts

Voice

Voice channel integration with real-time transcripts and post-call reports

​
Next steps

Quickstart

Send your first message to an agent in under 5 minutes

Architecture

Understand the multi-agent orchestration model