Bindu Agent Infrastructure

A unified identity, communication, orchestration, and payment layer for AI agents.

Source repo
GetBindu/Bindu
Stars
★ 10k
Last updated
2mo ago
License
NOASSERTION
Primary language
Python

At a glance

How it runs
Library / SDKSelf-hosted serviceCLI
Works with
Universal · cross-platformOpenAI API · Claude API
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
Python 3.12+uvAn API key for OpenRouter, OpenAI, or MiniMax to run the documented examplesShell / CLINetwork accessLocal filesystem
Typical use
A team with an existing Agno, LangChain, CrewAI, or custom handler that needs A2A endpoints, identity, and authorization without rewriting its core agent.
Not a fit if
  • Teams wanting a ready-made hosted API rather than running their own identity and payment infrastructure
  • Small projects that cannot take on Postgres, Redis, and USDC wallet operational dependencies
Website
docs.getbindu.com ↗ set on GitHub
Maintenance
Commits in the last 6 monthslast commit 2026-09-06latest release 2026.22.4 (2026-05-28)

What does this agent do, and when should you use it?

Bindu is a development and runtime layer that combines A2A JSON-RPC communication, DID identity, OAuth2 authorization, mTLS transport, and x402 payments for AI agents. Developers pass an existing handler to bindufy(), which exposes operations such as message/send, tasks/get, and message/stream on port 3773 while preserving a simple (messages) -> response application boundary. Python, TypeScript, and Kotlin SDKs share the same gRPC core so that protocol behavior, identity, and authentication remain consistent across languages. Bindu can wrap implementations built with Agno, LangChain, CrewAI, LangGraph, AG2, Hermes Agent, or custom code, and it supports model providers that expose OpenAI- or Anthropic-compatible APIs. Its deployment boundary spans a local server, an optional FRP public tunnel, and a bindu deploy agent.py --runtime=boxd path to a microVM. The repository also includes a Gateway for fleet orchestration, an operator inbox, storage and scheduling components, notifications, and observability integrations.

A developer registers the agent's author, name, description, deployment URL, and skills through bindufy(config, handler). Bindu receives A2A JSON-RPC requests before the application handler and can apply three checks: mTLS with certificates issued by step-ca, OAuth2 authorization through Ory Hydra introspection, and an Ed25519 DID signature over the canonical JSON body. After validation, it invokes the supplied Agno, LangChain, CrewAI, custom, or other supported handler and returns the result through the A2A task model; callers can poll tasks/get, use streaming messages, or receive push notifications. With x402 enabled, Bindu can require USDC payment before the handler runs, with five EVM networks preconfigured. Its Gateway uses a planner model to coordinate a fleet over A2A and stream the combined result, while Postgres stores tasks and messages and Redis supports retries, timeouts, and recurring work. expose: true creates an FRP tunnel, and bindu deploy can ship an agent script to a boxd microVM and return an HTTPS endpoint.

  1. A team with an existing Agno, LangChain, CrewAI, or custom handler that needs A2A endpoints, identity, and authorization without rewriting its core agent.
  2. A multi-agent system builder that needs agents to delegate work and negotiate price, latency, and SLA before execution.
  3. An operator selling analysis, advisory, or processing services who wants to require an x402 USDC payment before the handler consumes resources.
  4. A commercial team that wants public callers to see a generic capability while exposing detailed private skill descriptions only to allowlisted partner DIDs.
  5. A developer demonstrating an agent from a laptop who needs a public endpoint without configuring router port forwarding.
  6. A polyglot organization running Python, TypeScript, and Kotlin agents that should share the same DID, authentication rules, and A2A protocol.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • uv add bindu
Environment variables
OPENROUTER_API_KEY OPENAI_API_KEY MINIMAX_API_KEY
Runtime
Python 3.12+

How do you install or deploy this agent?

The Python package requires Python 3.12+ and uv:

uv add bindu

To work on Bindu itself:

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

Repository examples require at least one model-provider credential: OPENROUTER_API_KEY, OPENAI_API_KEY, or MINIMAX_API_KEY. The documented contributor setup uses:

git clone https://github.com/getbindu/Bindu.git
cd Bindu
uv venv --python 3.12.9 && source .venv/bin/activate
uv sync --dev
pre-commit run --all-files

How do you use this agent?

This is the documented first Python agent. Set OPENAI_API_KEY and run the file; it serves on http://localhost:3773, while expose: True opens an FRP tunnel.

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": "[email protected]",
    "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)

Send the first A2A JSON-RPC request with:

curl -X POST http://localhost:3773/ \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "message/send",
    "id": "<uuid>",
    "params": {
      "message": {
        "role": "user",
        "kind": "message",
        "parts": [{"kind": "text", "text": "Hello"}],
        "messageId": "<uuid>",
        "contextId": "<uuid>",
        "taskId": "<uuid>"
      }
    }
  }'

Poll tasks/get with the same taskId until its state is completed. For a hosted deployment, the documented command is:

bindu deploy agent.py --runtime=boxd

What are this agent's strengths and limitations?

Pros
  • A single bindufy() wrapper adds an A2A JSON-RPC boundary, DID identity, and deployment entry point without forcing the application to adopt one internal agent framework.
  • The security model separates transport authentication, current-operation authorization, and exact-message authorship across mTLS, Hydra OAuth2, and Ed25519 DID signatures.
  • Python, TypeScript, and Kotlin SDKs use a shared gRPC core, preserving the same DID, protocol, and authentication semantics across languages.
  • x402 payment checks occur before application execution, with five EVM networks preconfigured and a documented extension path for other EVM chains.
  • The project covers local tunneling, boxd microVM deployment, Gateway orchestration, Postgres storage, Redis scheduling, and OpenTelemetry observability.
Limitations
  • The Python path requires Python 3.12+ and uv, and the documented examples require at least one supported model-provider API key.
  • The full security stack introduces operational dependencies such as step-ca, Ory Hydra, certificate renewal, token introspection, and DID key management.
  • The claim that all three security layers are enabled by default is specifically scoped to the operator's personal agent as of version 2026.21.1, so other deployment modes need configuration review.
  • Storage and scheduling rely on Postgres and Redis respectively, while paid deployments also require USDC, wallet, and EVM network configuration.
  • The supplied repository metadata reports NOASSERTION for the license, while the README states Apache 2.0 and points to LICENSE.md; adopters should verify the actual license file before committing.

How does this agent compare with similar options?

Compared with assembling a DID library, OAuth flow, payment middleware, and A2A HTTP layer separately, Bindu places those concerns behind the same bindufy() communication and identity boundary. It is not presented as a replacement for Agno, LangChain, CrewAI, or LangGraph: those frameworks can continue to implement reasoning and tool use inside the handler while Bindu owns the external protocol, identity, authorization, payment, and deployment layers.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Bindu Agent Infrastructure This agent 55 · Major gaps Library / SDKFree + model costs ★ 10k 2mo ago Python OpenAI API · Claude API
Google ADK for TypeScript 49 · Major gaps CLIFree + model costs ★ 1.5k today TypeScript —
AgentsMesh 45 · Major gaps Self-hosted serviceFreemium ★ 2.4k 1mo ago Go Codex · Claude Code
Prismer Cloud 45 · Major gaps CLIFreemium ★ 1.4k 20d ago TypeScript Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
55/ 100 5-point scale 2.8 / 5
Trust 14/29
Reliability 6/14
Adaptability 12/18
Convention 12/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust14 / 29 · 2.4/5

The files describe OAuth2, DID signing, and mTLS configuration and purpose, warn users to protect keys, and document a cloud dry run, sensitive-file exclusion, and health checks. These support partial transparency and confirmation. Deductions: the quickstart sets expose=true for a public tunnel, development authentication is off by default, and scopes remain broad; the packet does not fully explain key storage, revocation, or data handling by external services. The deployment skill stops the old container before starting the new one and describes rollback only as an objective, without recovery steps. The README and docs name protocols and upstream projects but do not verify publisher identity.

Reliability6 / 14 · 2.1/5

The packet acknowledges gaps in gRPC streaming, TLS, reconnection, pooling, and metrics, and documents some error responses and recovery advice. Deductions: README, CLAUDE.md, and limitations material differ on database, mTLS defaults, and SDK capabilities; critical services depend on external Hydra, step-ca, storage, and cloud runtime services without availability evidence.

Adaptability12 / 18 · 3.3/5

The README addresses existing agent developers and offers Python, TypeScript, Kotlin, framework examples, deployment, and protocol paths; the limitations doc distinguishes Python and gRPC capabilities. Deductions: capability boundaries are spread across documents, and skill triggers chiefly describe contributor tasks rather than clearly defining product fit and exclusions. Development requires Python 3.12+ and may rely on external services.

Convention12 / 18 · 3.3/5

The README, topic guides, examples, known issues, and troubleshooting form a clear information structure; installation, quickstart, FAQ-like error guidance, and detailed limitations are present. Deductions: naming and version references show signs of inconsistency; Apache 2.0 is claimed in the README while metadata is NOASSERTION, and the packet does not include the license text. Version-change information is scattered, and named maintainers do not establish release responsibility or an update commitment.

Effectiveness7 / 13 · 2.7/5

The framework combines identity, A2A communication, authentication, payments, and deployment into an agent integration flow, with copyable calls, examples, and troubleshooting. Deductions: value is supported mainly by repository claims, without comparative evidence or reproducible user outcomes; deployment, LLM, Hydra, and cloud services add setup and ongoing costs that are only partly described.

Verifiability4 / 8 · 2.5/5

README feature claims link to topic guides, and the security, authentication, and gRPC limitations docs provide flows, configuration, and concrete error cases; known limitations are explicitly stated. Deductions: the packet includes no independently verifiable run results or test artifacts; files differ on security defaults and architecture, and many performance and security comparisons are repository assertions.

Risks and how to mitigate them
  • The quickstart enables expose=true, creating an internet-accessible tunnel; configure access controls and authentication deliberately before deployment.
  • Security defaults and architecture descriptions differ across the packet. In particular, authentication is described as off by default and gRPC as lacking TLS; confirm settings for the intended deployment.
  • Cloud deployment requires a boxd API key, and the docs warn that idle VMs may continue to incur charges. External Hydra, step-ca, and storage services also affect operation.
Evidence confidence: Low Reviewed Nov 08, 2026 Reviewed revision d4efe4816cbe
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/bindu.svg)](https://followagents.com/en/agents/bindu)
<a href="https://followagents.com/en/agents/bindu"><img src="https://followagents.com/badge/bindu.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. 2026.22.4 2026.22.4: x402 settle-first + scenario hardening
    Release notes excerpt
    Release: x402 settle-first + scenario hardening ==================================================== Version: 2026.22.4 Date: May 28, 2026 Author: Raahul Dutta OVERVIEW -------- This release closes issue #562 — the verify-vs-settle gap in Bindu's x402 payment middleware — in two steps. First (#563): a failed settlement no longer delivers the artifact. The worker now gates artifact delivery on settle success, and persists the EIP-3009 nonce, full authorization, and network on every failed-settle path so an operator can reconcile against the chain instead of seeing …
    View on GitHub ↗
  2. 2026.20.7 2026.20.7: bindu-communication Inbox and Secured Outbound A2A
    Release notes excerpt
    Release: bindu-communication Inbox and Secured Outbound A2A Version: 2026.20.7 Date: May 17, 2026 OVERVIEW -------- This release ships bindu-communication, an operator inbox for watching agent-to-agent traffic, together with the authentication and observability work that lets it talk to Hydra-protected peers end-to-end. The inbox is a three-pane Gmail-shape surface backed by SQLite that stitches outbound sends, agent webhooks, and gateway plan traces into one conversation per A2A context_id. Outbound calls are now JWT-bearer plus DID-signed using the operator's personal agent as …
    View on GitHub ↗
  3. v2026.12.5 v2026.12.5: Document Analyzer & Reliability Improvements
    Release notes excerpt
    Release: Document Analyzer & Reliability Improvements Version: 2026.12.5 Date: March 19, 2026 OVERVIEW -------- Maintenance and feature release focused on document analysis, payment robustness, scheduler and storage reliability, and usability improvements across the UI and configuration. This release also introduces a DSPy agent example, structured LangGraph workflow integration, and multiple accessibility and documentation enhancements contributed by the community. PROBLEM SOLVED -------------- Before this release: …
    View on GitHub ↗

FAQ

Does adoption require a specific agent framework?
No. The handler only needs to accept messages and return a response. The repository lists Agno, AG2, CrewAI, Hermes Agent, LangChain, LangGraph, Notte, and custom implementations.
Is Bindu limited to OpenAI models?
No. The examples accept OpenRouter, OpenAI, or MiniMax credentials, and the README states that providers exposing an OpenAI- or Anthropic-compatible API work.
Are mTLS, OAuth2, and DID signing always enabled automatically?
The request pipeline supports all three, but the explicit default-on statement is limited to the operator's personal agent as of version 2026.21.1. Other deployments should verify their security configuration.
How are paid requests handled?
With x402 enabled, the agent can require USDC before the handler executes. Base, Base Sepolia, Ethereum, Ethereum Sepolia, and SKALE Europa are preconfigured; other EVM networks can be added through extra_networks.
Can an agent move from local testing to hosted deployment?
Yes. The example serves locally on port 3773, expose: true provides an FRP public tunnel, and bindu deploy agent.py --runtime=boxd deploys the script and prints an HTTPS URL.
Is Bindu Agent Infrastructure open source?
The source code is public on GitHub (GetBindu/Bindu), but the repository does not declare a recognised licence, so the rights to reuse or modify it are unclear. Ask the author or check the README before building on it.
Is Bindu Agent Infrastructure safe to use?
FollowAgents' FARS review (Nov 08, 2026) scored Bindu Agent Infrastructure 14/29 on trust and safety. None of the eight safety controls the review checks for was missing outright.
Is Bindu Agent Infrastructure still maintained?
Development has slowed: the latest commit on GitHub is from 2026-09-06, within the last six months but not the last 30 days. The latest release is 2026.22.4 (2026-05-28).
Who makes Bindu Agent Infrastructure?
Bindu Agent Infrastructure is published on GitHub by the account GetBindu. FollowAgents has not verified which person or company is behind that account.
What is Bindu Agent Infrastructure's official website?
The project's GitHub repository lists https://docs.getbindu.com as its website. That link is set by the repository owner; the source code itself is on GitHub (GetBindu/Bindu).
Was this page helpful?
View on GitHub ↗ Install ↓