Bindu

// Overview

Bindu is the identity, communication and payments layer for AI agents. The problem it targets is the plumbing between a working agent and an agent that can actually operate in public: a DID library to integrate, an OAuth flow to set up, payment middleware, and an HTTP layer that speaks whatever protocol the rest of the agent world uses. Bindu packages all of that behind one call — you wrap your handler with `bindufy()` and the agent comes online with its own cryptographic identity, speaking A2A, optionally demanding payment before it does any work.

Your handler stays as small as `(messages) -> response`, and what runs inside it is up to you: the repository tests agents written with AG2, Agno, CrewAI, Hermes Agent, LangChain, LangGraph and Notte in Python, the OpenAI SDK and LangChain.js in TypeScript, and the OpenAI Kotlin SDK. All three SDKs share one gRPC core, so the language is a choice while the protocol and the identity stay the same, and a new SDK on top of that core is usually a few hundred lines.

Security is handled as transport rather than as an exercise for the developer. Three middlewares fire before a request body reaches your handler, each answering a question the others cannot: mTLS with an X.509 certificate from Smallstep step-ca (the DID as SAN, 24-hour TTL, auto-renewed in process) proves the socket is encrypted and mutually authenticated; an OAuth2 bearer token validated through Ory Hydra introspection proves the caller may perform this operation; and an Ed25519 `X-DID-Signature` over the canonical body proves who authored it. The same DID is the certificate SAN, the OAuth2 client_id and the message signer, and all three must agree or the request is rejected.

// What it does

• `bindufy()` puts an existing agent handler online with a W3C DID identity and A2A JSON-RPC (`message/send`, `tasks/get`, `message/stream`) on port 3773
• Three-layer default-on security: mTLS certificates from step-ca, scoped OAuth2 tokens via Ory Hydra, and Ed25519 DID signatures over the request body
• x402 payments — the agent can demand USDC before the handler runs, with Base, Base Sepolia, Ethereum, Ethereum Sepolia and SKALE Europa pre-configured and other EVM chains added through one `extra_networks` entry
• A skills system with an agent card, plus private skills that show a generic description to public crawlers and the real menu to allowlisted partner DIDs at an auth-gated endpoint
• Agent negotiation over price, latency and SLA; Postgres-backed task and message storage; Redis-backed retries, timeouts and recurring tasks
• Python, TypeScript and Kotlin SDKs over one gRPC core, plus an operator inbox UI that shows agents messaging each other with signatures verified inline
• `expose: true` opens an FRP tunnel so a local agent is reachable without port forwarding, and `bindu deploy` ships a script to a microVM with no Dockerfile

// Getting started

Bindu needs Python 3.12 or newer and uv. Running the examples also needs an API key for at least one LLM provider — OPENROUTER_API_KEY, OPENAI_API_KEY or MINIMAX_API_KEY.

uv add bindu

git clone https://github.com/getbindu/Bindu.git
cd Bindu
uv sync --dev

import os
from bindu.penguin.bindufy import bindufy
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    instructions="You are a research assistant.",
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
)

config = {
    "author": "you@example.com",
    "name": "research_agent",
    "description": "Research assistant with web search.",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering"],
}

def handler(messages: list[dict[str, str]]):
    return agent.run(input=messages)

bindufy(config, handler)

cd inbox && npm run dev

examples/agent_swarm/            # agents passing work to each other
examples/premium-advisor/        # x402: caller pays USDC before anything runs
examples/hermes_agent/           # Hermes Agent, bindufied
examples/gateway_test_fleet/     # five agents and one gateway
examples/typescript-openai-agent/

Commands and code are distilled from the project's own documentation — always check the official repo for the latest.

// When to use it

• Publish an agent on the open internet with a verifiable identity, so callers can check who authored a response instead of trusting a shared secret
• Charge for agent work directly, requiring USDC on an EVM chain before the handler executes
• Let agents built in different frameworks and languages interoperate over A2A without each one reimplementing identity and auth
• Keep commercial skill descriptions out of the public agent catalog while exposing them to allowlisted partner DIDs

// How Bindu compares

Bindu alongside other open-source multi-agent systems tools AI/TLDR tracks, ranked by GitHub stars.