GetBindu/Bindu

Bindu – Identity, communication & payments layer for AI agents

What it is – Bindu is a framework that lets you turn any LLM‑powered “agent” (whether written with LangChain, CrewAI, Agno, or your own code) into a network‑ready service with a single function call. It supplies the plumbing most agent developers spend weeks building:  * cryptographic DID‑based identity,  * mutual‑TLS transport,  * OAuth2 authorization via Ory Hydra,  * signed JSON‑RPC messages (A2A protocol),  * optional on‑chain USDC payment enforcement (x402),  * skill advertising,  * push notifications,  * cloud‑or‑local deployment helpers,  * polyglot SDKs (Python, TypeScript, Kotlin) that share the same gRPC core.

In short, Bindu makes an agent behave like a first‑class internet service while keeping the developer‑side handler as simple as def handler(messages): ….

Core concepts & features

Feature	What it does
A2A JSON‑RPC	Standard JSON‑RPC over HTTP/gRPC (`message/send`, `tasks/get`, `message/stream`).
mTLS transport	Every agent runs an HTTPS server with a short‑lived X.509 cert whose Subject‑Alt‑Name is the agent’s DID.
DID identity	Ed25519 keys sign every request body; callers verify the signature against the DID document.
OAuth2 via Hydra	Scoped bearer tokens (`agent:read`, `agent:write`, `agent:execute`) issued by Ory Hydra; the DID is also the client_id.
x402 payments	Agents can require USDC on any EVM chain before processing a request. Five chains are pre‑configured; others are added with a simple config entry.
Skills system	Declarative list of capabilities; visible on the agent’s “card” so callers know what they can ask for.
Private skills	Hide commercial skill descriptions from the public catalog; only allow‑listed DIDs can see the full list.
Negotiation	Two agents can agree on price, latency and SLA before work starts.
Push notifications	Webhook callbacks when a task changes state, eliminating polling.
Scheduler & storage	PostgreSQL stores tasks/messages; Redis backs retries, timeouts and recurring jobs.
Public tunnel (`expose: true`)	One‑click FRP tunnel that makes a locally‑run agent reachable from the internet without port‑forwarding.
Polyglot SDKs	Python (`bindu`), TypeScript (`@bindu/sdk`), Kotlin – all speak the same gRPC protocol and share the same DID.
Cloud deploy (`bindu deploy`)	Packages a script into a micro‑VM, provisions TLS, and returns a public HTTPS URL – no Dockerfile needed.
Gateway	A planner LLM that can orchestrate a fleet of agents and stream a combined response back to the caller.
Observability	OpenTelemetry traces, Sentry error reporting, health endpoint.

Quick start (Python)

# Install the library (requires Python 3.12+ and uv)
uv add bindu

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)   # launches the agent at http://localhost:3773

The same flow works in TypeScript – the SDK spawns the Python core behind the scenes.

Typical use cases

Enterprise agent swarms – e.g., the authors use Bindu for a “Trade Compliance OS” where dozens of agents negotiate, pay, and exchange customs data.
Paid AI APIs – expose a model‑backed service that only runs after the caller pays USDC on an EVM chain.
Multi‑agent orchestration – the built‑in Gateway can coordinate several specialized agents (search, summarisation, translation) and stream a unified answer.
Secure B2B integrations – mTLS + DID signatures + OAuth2 give a defense‑in‑depth model suitable for regulated environments.
Rapid prototyping – developers can spin up a local agent, expose it publicly with a single flag, and test end‑to‑end flows without Docker or cloud infra.

Ecosystem & language support

Language	SDK entry point	Tested frameworks
Python	`bindu` (pip)	Agno, LangChain, CrewAI, Hermes, LangGraph, Notte
TypeScript	`@bindu/sdk` (npm)	OpenAI SDK, LangChain.js
Kotlin	`io.github.getbindu:bindu-sdk` (Maven)	OpenAI Kotlin SDK
Others	gRPC core (`docs/grpc/`)	–

All SDKs share the same gRPC definitions, so adding a new language is a matter of a few hundred lines of wrapper code.

Maturity & community

Version – latest release shown on PyPI badge (v ?).
Tests – unit, integration and end‑to‑end suites run on every PR; coverage badge is provided.
CI – GitHub Actions enforce linting, type‑checking and test execution.
Community – Discord server, contributors list, and a growing set of example agents (20+ in examples/).
Documentation – full docs site (https://docs.getbindu.com) plus extensive markdown guides for security, deployment, payments, and troubleshooting.

License

Apache 2.0 – permissive open‑source license.

Bottom line

Bindu is a production‑grade, security‑first platform that abstracts the “identity‑transport‑payment” stack for AI agents. If you already have an LLM‑driven agent and want it to talk to other agents, charge for usage, or run securely in a multi‑tenant environment, you can get there with a single bindufy() call and a handful of configuration options.