Skip to main content
Most developers do not get stuck on the agent logic. They get stuck on everything around it. Server setup, protocol handling, auth, identity, observability, deployment, CI, and the long trail of things that somehow become your job before the agent can go live.

​
Why This Matters

The hard part is usually not writing the agent. The hard part is getting from “it works on my laptop” to “this thing can actually talk to other agents in production.”
Starting From ScratchStarting With Bindu
You assemble the server, config, auth, and deployment stack yourselfThe template gives you a production-ready starting point
Protocol support is another projectA2A, AP2, and X402 are already part of the setup
Identity, tracing, and testing come laterDID, observability, and pytest are included from the start
Existing agents need custom infrastructure gluebindufy() wraps what you already built
First usable version can take weeksFirst usable version takes minutes
That is the point of this page: getting onto the Internet of Agents should not mean spending three weeks rebuilding plumbing.
In the next 2 minutes, you can have a production-ready agent. Not a demo. Not a prototype. A real agent with DID identity, A2A protocol compliance, observability, and payment support.

​
How To Get Started Fast

There are two practical paths. Use the cookiecutter template if you want the fastest clean start. Use bindufy() if you already have an agent and want to put it on Bindu without rewriting it.

​
The Fast Way: Cookiecutter Style

Time to first agent: ~2 minutes This is the fastest way to get started. Navigate to the directory where you want to create your agent project and run: 
uvx cookiecutter https://github.com/getbindu/create-bindu-agent.git

Fast Setup

Start from a working project scaffold instead of wiring the basics by hand.

Protocol-Ready

The generated project is ready for A2A, AP2, and X402-aware agent workflows.

Production Baseline

Testing, CI/CD, docs, and deployment scaffolding are already in place.

​
The Lifecycle: Generate, Run, Join

1

Generate The Project

Run the cookiecutter command and answer the setup prompts for project details, agent framework, features, and license type.
uvx cookiecutter https://github.com/getbindu/create-bindu-agent.git
2

Install And Start

Move into the generated project, install dependencies with uv, and start the agent.
cd your-agent
uv sync
uv run python -m your_agent.main
3

Join The Network

Your agent is now live at http://localhost:3773. It is speaking A2A, AP2, and X402, and other agents can discover it, talk to it, and pay it for services.

​
Already Built Something?

You’ve got an agent running. Maybe it’s in LangChain. Maybe CrewAI. Maybe custom code. It does not matter. You can Bindu-fy it in 5 minutes. Two things you need: a config file and the bindufy wrapper. That’s it.

​
Step 1: Create agent_config.json

{
  "author": "your.email@example.com",
  "name": "my_existing_agent",
  "description": "My agent with Bindu superpowers",
  "version": "1.0.0",
  "deployment": {
    "url": "http://localhost:3773",
    "expose": true
  }
}
See the Configuration Reference for all available options including A2A, AP2, and X402 protocol settings.

​
Step 2: Wrap Your Agent With bindufy

from bindu.penguin.bindufy import bindufy
from agno.agent import Agent
from agno.models.openai import OpenAIChat
import json

# Load your config
with open("agent_config.json", "r") as f:
    config = json.load(f)

# Your existing agent
my_agent = Agent(
    instructions="Your agent instructions",
    model=OpenAIChat(id="gpt-4o"),
)

# Handler function
def agent_handler(messages: list[dict[str, str]]):
    result = my_agent.run(input=messages)
    return result

# Bindufy it!
bindufy(my_agent, config, agent_handler)
Done. Your agent is now live. Ready to communicate with other agents in the Internet of Agents. No infrastructure setup.
No protocol implementation.
No weeks of DevOps work.
Check out examples for different agent frameworks like LangChain, CrewAI, and more.

​
What Happens During Setup?

When you run the cookiecutter command, you’ll be prompted for:
  • Project details - Name, description, author info
  • Agent framework - Agno, LangChain, CrewAI, etc.
  • Features - Authentication, DID, observability, CI/CD
  • License type - MIT, Apache, BSD, GPL, ISC
Then your agent project is ready with: 
your-agent/
├── agent_config.json          # Agent configuration with A2A/AP2/X402 settings
├── your_agent/
│   ├── main.py               # Agent entry point (Bindu-fied!)
│   └── __init__.py
├── skills/                   # Template for adding agent skills
├── tests/                    # Pre-configured pytest tests
├── pyproject.toml            # Dependencies managed by uv
├── Dockerfile                # Ready for containerization
├── .github/workflows/        # CI/CD pipelines
└── README.md                 # Complete setup instructions
Each piece has a job:
  • agent_config.json holds the agent configuration with A2A, AP2, and X402 settings
  • main.py is the generated entry point where the agent is already Bindu-fied
  • skills/ gives you the starting structure for agent skills
  • tests/ comes pre-configured for pytest
  • pyproject.toml keeps dependencies managed by uv
  • Dockerfile makes containerization straightforward
  • .github/workflows/ sets up CI/CD pipelines
  • README.md gives you the generated setup instructions

​
What You Just Got

All of this comes out of the box. No extra setup phase. No separate infrastructure sprint.

Protocol Support

Built-in A2A, AP2, and X402 protocol compliance.

Authentication

Secure authentication with Auth0 and DID support.

Observability

Phoenix, Langfuse, and Jaeger integration.

CI/CD

GitHub Actions workflows for testing and deployment.

Testing

Pre-configured pytest with coverage reporting.

Documentation

MkDocs setup for beautiful documentation.

Containerization

Docker/Podman ready for easy deployment.

Code Quality

Ruff, ty, and pre-commit hooks configured.

​
Learn More

Complete guide to all configuration options.Path: Configuration Reference
Learn more about create-bindu-agent.Path: Template Overview
Understand Bindu’s core concepts.Path: Key Concepts
Configure authentication for your agent.Path: Authentication
Set up Decentralized Identifiers.Path: DID Setup
Monitor your agent with Phoenix or Langfuse.Path: Observability

​
When Things Go Wrong

Most of the time the template path is smooth. When it is not, the failures are usually familiar ones.

uv Not Found

Install uv first with curl -LsSf https://astral.sh/uv/install.sh | sh, then restart your terminal and try again.

Port Already In Use

Something is already running on port 3773. Change the deployment_port in agent_config.json to something else, or stop the process using that port.

Authentication Errors

You probably have not set up Auth0 credentials yet. Check the generated README for environment variables, or disable auth in your config while testing.

Dependencies Not Installing

Sometimes the virtual environment gets corrupted. Remove it, run uv sync again, and retry.
Sunflower LogoBindu helps you get fromagent idea to live agent, without spending the next three weeks buried in infrastructure.