DEV Community

10XScale profile image Shudipto Trafder
Shudipto Trafder for 10XScale

Posted on

AgentFlow — From Agent Code to Production API in Minutes

#ai #agents #langgraph #opensource

AgentFlow — The Python Framework for Production AI Agents

Stop rebuilding the same agent infrastructure. AgentFlow gives you auth, streaming, persistence, and a React frontend — out of the box.

AgentFlow (10xscale-agentflow on PyPI) is an open-source Python framework for building and deploying multi-agent AI systems. Write your agent graph once. Run it locally. Ship it to production without rewriting your backend.

Built by 10xScale. MIT licensed. No vendor lock-in.

Why AgentFlow?

Most agent frameworks stop at the prototype. You get a cute demo, then spend weeks bolting on auth, rate limiting, persistence, and a frontend. AgentFlow is built for what comes after the demo.

One framework. From first pip install to production Docker deploy.

🔗 Links

Resource URL
Core Python Library github.com/10xHub/Agentflow
API & CLI github.com/10xHub/agentflow-cli
Documentation 10xhub.github.io/agentflow-docs
PyPI — Core pypi.org/project/10xscale-agentflow
PyPI — CLI pypi.org/project/10xscale-agentflow-cli

The Full Stack 

agentflow            →  Core Python orchestration engine
agentflow-cli        →  FastAPI server + CLI tooling
agentflow-client     →  TypeScript/React SDK (@10xscale/agentflow-client)
agentflow-playground →  Hosted UI for testing agents
Enter fullscreen mode Exit fullscreen mode

Use any layer alone. Use them together for a complete AI product stack — from LLM call to browser UI — without stitching four different libraries together.

Get Running in 60 Seconds 

pip install 10xscale-agentflow-cli

agentflow init   # scaffold a new project
agentflow api    # start the dev server
agentflow play   # open the playground UI
Enter fullscreen mode Exit fullscreen mode

That's it. Your agent is running, streamed, and explorable in under a minute.

What You Get

Graph-Based Agent Orchestration

AgentFlow uses a StateGraph — directed nodes, conditional edges, and full control over execution flow. No black boxes. No magic routing you can't debug.

from agentflow.graph import Agent, StateGraph, ToolNode
from agentflow.state import AgentState, Message
from agentflow.utils.constants import END

def get_weather(location: str) -> str:
    """Get weather for a location."""
    return f"The weather in {location} is sunny, 72°F"

graph = StateGraph()
graph.add_node("MAIN", Agent(
    model="gemini/gemini-2.5-flash",
    system_prompt=[{"role": "system", "content": "You are a helpful assistant."}],
    tool_node_name="TOOL"
))
graph.add_node("TOOL", ToolNode([get_weather]))

def route(state: AgentState) -> str:
    if state.context and state.context[-1].tools_calls:
        return "TOOL"
    return END

graph.add_conditional_edges("MAIN", route, {"TOOL": "TOOL", END: END})
graph.add_edge("TOOL", "MAIN")
graph.set_entry_point("MAIN")

app = graph.compile()
result = app.invoke(
    {"messages": [Message.text_message("Weather in NYC?")]},
    config={"thread_id": "1"}
)
Enter fullscreen mode Exit fullscreen mode

Stateful. Tool-calling. Under 30 lines.

LLM-Agnostic

Pass the model string. AgentFlow routes it.

Provider Package
OpenAI (GPT-4o, o3, etc.) pip install openai
Google Gemini + Vertex AI pip install google-genai
Anthropic Claude pip install anthropic (coming soon)

No provider-specific abstractions to learn. Swap models without touching your agent logic.

Parallel Tool Execution — Automatic

When an LLM calls multiple tools at once, AgentFlow runs them concurrently. No config required.

Other frameworks:  1.0s + 1.5s + 0.8s = 3.3s
AgentFlow:         max(1.0s, 1.5s, 0.8s) = 1.5s  ⚡ 2.2x faster
Enter fullscreen mode Exit fullscreen mode

Production Memory — Three Layers 

Working Memory    →  Current execution state (AgentState)
Session Memory    →  Redis (hot) + PostgreSQL (durable) checkpointer
Knowledge Memory  →  Qdrant vector store + Mem0 semantic recall
Enter fullscreen mode Exit fullscreen mode

Redis keeps hot conversation state fast. PostgreSQL keeps it durable and horizontally scalable. Both run together — you don't pick one.

Streaming 

stream_gen = app.astream(
    inp,
    config=config,
    response_granularity=ResponseGranularity.LOW,
)
async for chunk in stream_gen:
    print(chunk.model_dump())
Enter fullscreen mode Exit fullscreen mode

Three granularity levels: token-by-token (ChatGPT-style), message-by-message, or node-by-node graph traces. Your frontend decides what to show.

Auth and Security — Built In, Not Bolted On

Most frameworks leave auth as an exercise for the reader. AgentFlow ships it.

{ "auth": "jwt" }
{ "auth": null }
{ "auth": { "method": "custom", "path": "auth.my_backend:MyAuth" } }
Enter fullscreen mode Exit fullscreen mode

One line in agentflow.json. Switch from dev to production auth without touching your graph code.

Security features included:

  • JWT authentication with configurable secrets
  • Custom auth backends for OAuth2, API keys, and sessions
  • Role-Based Access Control (RBAC)
  • Sliding-window rate limiting (memory or Redis backends)
  • Configurable request size limits (DoS protection, default 10 MB)
  • Auto-redaction of tokens and secrets from logs
  • Startup validation — warns about insecure CORS and debug mode before you accidentally deploy them

Lifecycle Callbacks

Hook into every layer of execution — before and after each LLM call, tool call, or MCP invocation. Hook into the graph itself for start, end, checkpoint, interrupt, resume, and error events.

Use them for audit logs, billing meters, policy enforcement, prompt-injection checks, or any business logic that shouldn't live inside the prompt.

The CLI 

agentflow init              # scaffold project + config
agentflow api               # dev server with auto-reload
agentflow play              # open playground against local backend
agentflow build --docker-compose  # generate Dockerfile + compose
Enter fullscreen mode Exit fullscreen mode

Auto-generated FastAPI endpoints:

Endpoint Method
/invoke POST — synchronous agent call
/stream POST — streaming agent call
/threads GET — list conversation threads
/threads/{id} GET — fetch thread history
/threads/{id} DELETE — delete thread

Your agent graph becomes a production API. No FastAPI boilerplate to write.

Dependency Injection with InjectQ 

from agentflow.utils import tool

@tool(tags=["weather"])
async def get_weather(location: str, user_id: str = Inject(UserService)) -> str:
    """Get weather for a location."""
    return f"Weather for user {user_id} in {location}: sunny"
Enter fullscreen mode Exit fullscreen mode

Clean tools. Testable tools. Per-request context without global state.

Human-in-the-Loop

Pause execution mid-graph. Inject a human decision. Resume with full state intact. No re-running prior steps.

Approval workflows, moderation gates, interactive debugging — all supported without custom state management.

Event Publishing

Publisher Use Case
Redis Pub/Sub Lightweight in-process distribution
Kafka High-volume event streaming
RabbitMQ Reliable queuing, distributed systems
Console Local debugging
Custom Any backend you want

React/TypeScript Client SDK

@10xscale/agentflow-client gives you React hooks (useAgent, useStream, useThreads), token-level streaming for ChatGPT-style UIs, and client-side tool execution. The frontend talks to your AgentFlow API without custom integration code.

Feature Comparison

Feature AgentFlow LangGraph CrewAI AutoGen
Architecture Graph Graph Role-Based Conversational
Full Stack (Backend + Frontend SDK) ✅ ❌ ❌ ❌
Parallel Tool Execution ✅ Auto ⚠️ Config ❌ ❌
Persistence ✅ Redis + Postgres ⚠️ Postgres/SQLite ⚠️ Local ⚠️ Local
Dependency Injection ✅ Native ❌ ❌ ❌
CLI + Docker Deployment ✅ One command ❌ ❌ ❌
Auth Built-In ✅ JWT + Custom ❌ ❌ ❌
Rate Limiting ✅ Memory + Redis ❌ ❌ ❌
Lifecycle Callbacks ✅ Full ⚠️ Manual ❌ ⚠️ Manual
MCP Support ✅ Native ⚠️ Partial ❌ ❌
Event Publishing ✅ Kafka/Redis/AMQP ❌ ❌ ❌
Open Source (MIT) ✅ ✅ ✅ ✅

Installation 

# Core library
pip install 10xscale-agentflow

# Full CLI + API server
pip install 10xscale-agentflow-cli
Enter fullscreen mode Exit fullscreen mode

Optional extras:

pip install 10xscale-agentflow[pg_checkpoint]   # PostgreSQL + Redis persistence
pip install 10xscale-agentflow[mcp]             # Model Context Protocol
pip install 10xscale-agentflow[google-genai]    # Google GenAI adapter
pip install 10xscale-agentflow[kafka]           # Kafka event publishing
pip install 10xscale-agentflow[redis]           # Redis publisher + rate limiting
Enter fullscreen mode Exit fullscreen mode

Current Version

Package Version
10xscale-agentflow (core) v0.7.4
10xscale-agentflow-cli v0.3.2

Added in v0.7.x: multimodal support (images, audio, video), extended reasoning / chain-of-thought, 3-layer memory, callback and lifecycle hooks, agent skills, Vertex AI support, structured Pydantic outputs.

Roadmap

  • ✅ Graph engine with nodes, edges, and conditional routing
  • ✅ Redis + PostgreSQL state checkpointing
  • ✅ Tool integration — local Python, MCP, optional adapters
  • ✅ Parallel tool execution
  • ✅ Lifecycle callbacks and graph hooks
  • ✅ Streaming + event publishing
  • ✅ Human-in-the-loop
  • ✅ Multimodal agents
  • 🚧 Remote node execution for distributed processing
  • 🚧 OpenTelemetry tracing
  • 🚧 More persistence backends (DynamoDB, etc.)
  • 🚧 Visual graph editor

Privacy and Licensing

  • MIT License — use freely in commercial products
  • No data collection — your conversations and agent data stay on your infrastructure
  • No per-call billing — you pay for your LLM API and infra, not our licensing
  • Deploy anywhere — Docker, Kubernetes, AWS ECS, Cloud Run, Azure, Heroku

Links

Core Library https://github.com/10xHub/Agentflow
API & CLI https://github.com/10xHub/agentflow-cli
Documentation https://10xhub.github.io/agentflow-docs
PyPI Core https://pypi.org/project/10xscale-agentflow/
PyPI CLI https://pypi.org/project/10xscale-agentflow-cli/
Issues & Requests https://github.com/10xHub/Agentflow/issues
Discussions https://github.com/10xHub/Agentflow/discussions

Built by 10xScale and the community. MIT licensed.

Top comments (0)