Skip to main content
Transform any agent into a production-ready server that speaks universal protocols.

​
Why These Concepts Matter

Most agent demos stop at a prompt and a response. Real agent systems need a lot more than that. They need discovery, identity, payment rails, task state, observability, storage, and a way to keep conversations alive across turns.
A Basic Agent WrapperBindu
Exposes a model or workflow behind a custom endpointTurns an agent into a protocol-native server
Usually treats interactions as one-off requestsTreats every interaction as a trackable task
Context is often held in app code or lost between callsContext and history persist across states
Payments and auth are bolted on laterX402, DID, and auth fit into the request path
Observability is added separatelyPhoenix, Langfuse, and Jaeger tracing are built in
That is the real shift: Bindu is not just a wrapper around an agent framework. It gives the agent the infrastructure it needs to operate on the Internet of Agents.
Bindu is built around the idea that agent infrastructure should not be stitched together by hand every time. Discovery, task state, routing, identity, and execution all need to work as one system.

​
How Bindu Works

Bindu turns your agent into a server that can be discovered, called, authenticated, paid, traced, and resumed. The request path is protocol-native from the first message to the final artifact.

​
The System Flow

Protocol-Native

Bindu speaks A2A, AP2, and X402 without making you invent your own transport layer first.

Task-First

Every interaction becomes a trackable task with clear state, history, and lifecycle transitions.

Production-Ready

Identity, payments, storage, scheduling, and tracing fit into the execution path from the start.

​
The Lifecycle: Discovery, Execution, Completion

1

Discovery

Client finds agents via /agent/skills endpoint.
2

Execution

Send message via message/send -> Task enters “submitted” state. X402 verifies payment if required. Auth0 + DID verify identity. Task moves to “working” state, and the agent executes.
3

Completion

If the agent needs input, task enters “input-required” state. When processing finishes, task reaches “completed” state with artifacts. Full trace is captured via Phoenix, Langfuse, and Jaeger.

​
Task Lifecycle And States

Bindu uses a task-first pattern where every interaction is a trackable, resumable task with persistent state:
StateDescriptionCan Cancel?Next Actions
submittedTask received, queued for processingYesWait or poll with tasks/get
workingAgent actively processingYesWait for completion or input request
input-requiredAgent needs user input to continueYesSend follow-up message with same taskId
completedTask finished successfullyNoRetrieve artifacts, submit feedback
failedTask encountered an errorNoCheck error details, retry if needed
canceledTask was canceled by userNoCreate new task if needed
Each part of that lifecycle solves a real problem:
  • Resumable Conversations: Tasks can pause for user input and resume seamlessly
  • Context Preservation: Full conversation history maintained across all states
  • Reference Previous Tasks: Use referenceTaskIds to build on prior results
  • Async by Default: Submit task, get immediate response, poll for completion
  • Artifact Storage: Final results stored with DID signatures for verification
# 1. Submit task
response = await agent.send_message("create sunset caption")
# State: "submitted" -> "input-required"
# Agent asks: "Which platform? Instagram, Pinterest, or General?"

# 2. Check status
task = await agent.get_task(task_id)
# State: "input-required"
# History shows agent's question

# 3. Respond to agent (same taskId, new messageId)
response = await agent.send_message("Instagram", task_id=task_id)
# State: "submitted" -> "working" -> "completed"

# 4. Get final result
task = await agent.get_task(task_id)
# State: "completed"
# Artifacts: ["Chasing sunsets and dreams. 🌅 #SunsetLovers"]

# 5. Build on previous result (new task, reference old one)
response = await agent.send_message(
    "make it shorter",
    reference_task_ids=[task_id]
)
# Agent accesses previous caption and shortens it
# Result: "Sunset vibes. 🌅 #GoldenHour"
Unlike stateless APIs, Bindu preserves the whole conversation context. Agents can ask clarifying questions, users can respond on the same task, and later tasks can build on earlier results.

​
Protocol-Native Architecture

The architecture is built around open agent protocols and real execution infrastructure, not just a model call behind an endpoint.

Universal Protocol Support

Native A2A, AP2, and X402 compliance out of the box.

Framework Agnostic

Works with Agno, LangChain, CrewAI, LlamaIndex, FastAgent, and any Python-based framework.

DID Authentication

Built-in Decentralized Identity for secure agent-to-agent communication. Influenced by AT Protocol DID structure.

Type Safe

Enforce structured I/O through schema validation for predictable behavior.

​
Infrastructure And Deployment

Infrastructure is part of the core model here, not an afterthought.
Turn your AI agent into a web server using Starlette (a Python web framework). The BinduApplication class handles all the complex setup. You just provide your agent and it creates a fully functional server ready to receive requests.
Comes with automatic error handling, task retry mechanisms, health checks, and backup systems. If something fails, Bindu knows how to recover gracefully without crashing your agent.
Start on your local machine (localhost) and deploy to any cloud platform when ready. Works with Docker and Podman containers, making it easy to package and ship your agent to production environments.
Native integration with Phoenix, Langfuse, and Jaeger for complete visibility. Track agent health, performance metrics, execution flows, and distributed-system errors in one place.
Choose between in-memory, PostgreSQL, or Redis for context and history. Redis-based scheduler coordinates tasks across agent instances. Analyze tasks and route to agents based on capabilities and availability, with sequential, parallel, or collaborative execution patterns.
Native support for agent-to-agent payments and micropayments through X402. AP2 support lets agents participate in agentic commerce ecosystems.
Support for AuthKit, GitHub, AWS Cognito, Google, and Azure. Runs in your infrastructure with a private-by-default model and no external data sharing or vendor lock-in.

​
Developer Experience

Good infrastructure only helps if developers can actually use it without spending a week wiring the basics together.

2-Minute Setup

Production-ready agent with create-bindu-agent cookiecutter template.

Best Practices Built-In

Pre-configured with ruff, ty, pytest, and pre-commit hooks.

113+ Built-In Toolkits

Access thousands of tools across data, code, web, and enterprise APIs.

MCP Integration

First-class Model Context Protocol support to connect agents with external systems.
  • /bindu/introduction/what-is-bindu
  • /bindu/concepts/architecture
  • /bindu/concepts/task-first-pattern
  • /bindu/how-to/install
Sunflower LogoBindu gives your agents the infrastructure they need todiscover, act, remember, and coordinate, without making you rebuild the plumbing every time.