GitHub - GetBindu/Bindu: Bindu: Turn any AI agent into a living microservice - interoperable, observable, composable.

The identity, communication & payments layer for AI agents

Bindu (read: binduu) is an operating layer for AI agents that provides identity, communication, and payment capabilities. It delivers a production-ready service with a convenient API to connect, authenticate, and orchestrate agents across distributed systems using open protocols: A2A, AP2, and X402.

Built with a distributed architecture (Task Manager, scheduler, storage), Bindu makes it fast to develop and easy to integrate with any AI framework. Transform any agent framework into a fully interoperable service for communication, collaboration, and commerce in the Internet of Agents.

🌟 Register your agent • 🌻 Documentation • 💬 Discord Community

🎥 Watch Bindu in Action

📋 Prerequisites

Before installing Bindu, ensure you have:

Python 3.12 or higher - Download here
UV package manager - Installation guide

Verify Your Setup

# Check Python version
python --version  # Should show 3.12 or higher

# Check UV installation
uv --version

📦 Installation

Windows users note (Git & GitHub Desktop)

On some Windows systems, git may not be recognized in Command Prompt even after installation due to PATH configuration issues.

If you face this issue, you can use GitHub Desktop as an alternative:

Install GitHub Desktop from https://desktop.github.com/
Sign in with your GitHub account
Clone the repository using the repository URL: https://github.com/getbindu/Bindu.git

GitHub Desktop allows you to clone, manage branches, commit changes, and open pull requests without using the command line.

# Install Bindu
uv add bindu

# For development (if contributing to Bindu)
# Create and activate virtual environment
uv venv --python 3.12.9
source .venv/bin/activate  # On macOS/Linux
# .venv\Scripts\activate  # On Windows

uv sync --dev

Common Installation Issues (click to expand)

Issue	Solution
`uv: command not found`	Restart your terminal after installing UV. On Windows, use PowerShell
`Python version not supported`	Install Python 3.12+ from python.org
Virtual environment not activating (Windows)	Use PowerShell and run `.venv\Scripts\activate`
`Microsoft Visual C++ required`	Download Visual C++ Build Tools
`ModuleNotFoundError`	Activate venv and run `uv sync --dev`

🚀 Quick Start

Option 1: Using Cookiecutter (Recommended)

Time to first agent: ~2 minutes ⏱️

# Install cookiecutter
uv add cookiecutter

# Create your Bindu agent
uvx cookiecutter https://github.com/getbindu/create-bindu-agent.git

🎥 Create Production Ready Agent in Minutes

That's it! Your local agent becomes a live, secure, discoverable service. Learn more →

💡 Pro Tip: Agents created with cookiecutter include GitHub Actions that automatically register your agent in the Bindu Directory when you push to your repository. No manual registration needed!

Option 2: Manual Setup

Create your agent script my_agent.py:

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

# Define your agent
agent = Agent(
    instructions="You are a research assistant that finds and summarizes information.",
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
)

# Configuration
config = {
    "author": "your.email@example.com",
    "name": "research_agent",
    "description": "A research assistant agent",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering", "skills/pdf-processing"]
}

# Handler function
def handler(messages: list[dict[str, str]]):
    """Process messages and return agent response.

    Args:
        messages: List of message dictionaries containing conversation history

    Returns:
        Agent response result
    """
    result = agent.run(input=messages)
    return result

# Bindu-fy it
bindufy(config, handler)

Your agent is now live at http://localhost:3773 and ready to communicate with other agents.

Option 3: Minimal Echo Agent (Testing)

View minimal example (click to expand)

Smallest possible working agent:

from bindu.penguin.bindufy import bindufy

def handler(messages):
    return [{"role": "assistant", "content": messages[-1]["content"]}]

config = {
    "author": "your.email@example.com",
    "name": "echo_agent",
    "description": "A basic echo agent for quick testing.",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": []
}

bindufy(config, handler)

Run and test:

# Start the agent
python examples/echo_agent.py

Test the agent with curl (click to expand)

Input:

curl --location 'http://localhost:3773/' \
--header 'Content-Type: application/json' \
--data '{
    "jsonrpc": "2.0",
    "method": "message/send",
    "params": {
        "message": {
            "role": "user",
            "parts": [
                {
                    "kind": "text",
                    "text": "Quote"
                }
            ],
            "kind": "message",
            "messageId": "550e8400-e29b-41d4-a716-446655440038",
            "contextId": "550e8400-e29b-41d4-a716-446655440038",
            "taskId": "550e8400-e29b-41d4-a716-446655440300"
        },
        "configuration": {
            "acceptedOutputModes": [
                "application/json"
            ]
        }
    },
    "id": "550e8400-e29b-41d4-a716-446655440024"
}'

Output:

{
    "jsonrpc": "2.0",
    "id": "550e8400-e29b-41d4-a716-446655440024",
    "result": {
        "id": "550e8400-e29b-41d4-a716-446655440301",
        "context_id": "550e8400-e29b-41d4-a716-446655440038",
        "kind": "task",
        "status": {
            "state": "submitted",
            "timestamp": "2025-12-16T17:10:32.116980+00:00"
        },
        "history": [
            {
                "message_id": "550e8400-e29b-41d4-a716-446655440038",
                "context_id": "550e8400-e29b-41d4-a716-446655440038",
                "task_id": "550e8400-e29b-41d4-a716-446655440301",
                "kind": "message",
                "parts": [
                    {
                        "kind": "text",
                        "text": "Quote"
                    }
                ],
                "role": "user"
            }
        ]
    }
}

Check the status of the task

curl --location 'http://localhost:3773/' \
--header 'Content-Type: application/json' \
--data '{
    "jsonrpc": "2.0",
    "method": "tasks/get",
    "params": {
        "taskId": "550e8400-e29b-41d4-a716-446655440301"
    },
    "id": "550e8400-e29b-41d4-a716-446655440025"
}'

Output:

{
    "jsonrpc": "2.0",
    "id": "550e8400-e29b-41d4-a716-446655440025",
    "result": {
        "id": "550e8400-e29b-41d4-a716-446655440301",
        "context_id": "550e8400-e29b-41d4-a716-446655440038",
        "kind": "task",
        "status": {
            "state": "completed",
            "timestamp": "2025-12-16T17:10:32.122360+00:00"
        },
        "history": [
            {
                "message_id": "550e8400-e29b-41d4-a716-446655440038",
                "context_id": "550e8400-e29b-41d4-a716-446655440038",
                "task_id": "550e8400-e29b-41d4-a716-446655440301",
                "kind": "message",
                "parts": [
                    {
                        "kind": "text",
                        "text": "Quote"
                    }
                ],
                "role": "user"
            },
            {
                "role": "assistant",
                "parts": [
                    {
                        "kind": "text",
                        "text": "Quote"
                    }
                ],
                "kind": "message",
                "message_id": "2f2c1a8e-68fa-4bb7-91c2-eac223e6650b",
                "task_id": "550e8400-e29b-41d4-a716-446655440301",
                "context_id": "550e8400-e29b-41d4-a716-446655440038"
            }
        ],
        "artifacts": [
            {
                "artifact_id": "22ac0080-804e-4ff6-b01c-77e6b5aea7e8",
                "name": "result",
                "parts": [
                    {
                        "kind": "text",
                        "text": "Quote",
                        "metadata": {
                            "did.message.signature": "5opJuKrBDW4woezujm88FzTqRDWAB62qD3wxKz96Bt2izfuzsneo3zY7yqHnV77cq3BDKepdcro2puiGTVAB52qf"  # pragma: allowlist secret
                        }
                    }
                ]
            }
        ]
    }
}

Postgres Storage

Bindu uses PostgreSQL as its persistent storage backend for production deployments. The storage layer is built with SQLAlchemy's async engine and uses imperative mapping with protocol TypedDicts.

Its Optional - InMemoryStorage is used by default.

📊 Storage Structure

The storage layer uses three main tables:

tasks_table: Stores all tasks with JSONB history and artifacts
contexts_table: Maintains context metadata and message history
task_feedback_table: Optional feedback storage for tasks

⚙️ Configuration

View configuration example (click to expand)

Configure PostgreSQL connection in your environment or settings: provide the connection string in the config of the agent.

config = {
    "author": "your.email@example.com",
    "name": "research_agent",
    "description": "A research assistant agent",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering", "skills/pdf-processing"],
    "storage": {
        "type": "postgres",
        "database_url": "postgresql+asyncpg://bindu:bindu@localhost:5432/bindu",  # pragma: allowlist secret
        "run_migrations_on_startup": False,
    },
}

💡 Task-First Pattern: The storage supports Bindu's task-first approach where tasks can be continued by appending messages to non-terminal tasks, enabling incremental refinements and multi-turn conversations.

Redis Scheduler

Bindu uses Redis as its distributed task scheduler for coordinating work across multiple workers and processes. The scheduler uses Redis lists with blocking operations for efficient task distribution.

Its Optional - InMemoryScheduler is used by default.

⚙️ Configuration

View configuration example (click to expand)

Configure Redis connection in your agent config:

config = {
    "author": "your.email@example.com",
    "name": "research_agent",
    "description": "A research assistant agent",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering", "skills/pdf-processing"],
     "scheduler": {
        "type": "redis",
        "redis_url": "redis://localhost:6379/0",
    },
}

All operations are queued in Redis and processed by available workers using a blocking pop mechanism, ensuring efficient distribution without polling overhead.

Retry Mechanism

Automatic retry logic with exponential backoff for resilient Bindu agents

Bindu includes a built-in Tenacity-based retry mechanism to handle transient failures gracefully across workers, storage, schedulers, and API calls. This ensures your agents remain resilient in production environments.

⚙️ Default Settings

If not configured, Bindu uses these defaults:

Operation Type	Max Attempts	Min Wait	Max Wait
Worker	3	1.0s	10.0s
Storage	5	0.5s	5.0s
Scheduler	3	1.0s	8.0s
API	4	1.0s	15.0s

Sentry Integration

Real-time error tracking and performance monitoring for Bindu agents

Sentry is a real-time error tracking and performance monitoring platform that helps you identify, diagnose, and fix issues in production. Bindu includes built-in Sentry integration to provide comprehensive observability for your AI agents.

⚙️ Configuration

View configuration example (click to expand)

Configure Sentry directly in your bindufy() config:

config = {
    "author": "gaurikasethi88@gmail.com",
    "name": "echo_agent",
    "description": "A basic echo agent for quick testing.",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": [],
    "storage": {
        "type": "postgres",
        "database_url": "postgresql+asyncpg://bindu:bindu@localhost:5432/bindu",  # pragma: allowlist secret
        "run_migrations_on_startup": False,
    },
    # Scheduler configuration (optional)
    # Use "memory" for single-process (default) or "redis" for distributed multi-process
    "scheduler": {
        "type": "redis",
        "redis_url": "redis://localhost:6379/0",
    },
    # Sentry error tracking (optional)
    # Configure Sentry directly in code instead of environment variables
    "sentry": {
        "enabled": True,
        "dsn": "https://252c0197ddeafb621f91abdbb59fa819@o4510504294612992.ingest.de.sentry.io/4510504299069520",
        "environment": "development",
        "traces_sample_rate": 1.0,
        "profiles_sample_rate": 0.1,
    },
}

def handler(messages):
    # Your agent logic
    pass

bindufy(config, handler)

🚀 Getting Started

Create Sentry Account: Sign up at sentry.io
Get Your DSN: Copy from project settings
Configure Bindu: Add sentry config (see above)
Run Your Agent: Sentry initializes automatically

📚 See the full Sentry documentation for complete details.

Skills System

Rich capability advertisement for intelligent agent orchestration

The Bindu Skills System provides rich agent capability advertisement for intelligent orchestration and agent discovery. Inspired by Claude's skills architecture, it enables agents to provide detailed documentation about their capabilities for orchestrators to make informed routing decisions.

💡 What are Skills?

Skills in Bindu serve as rich advertisement metadata that help orchestrators:

🔍 Discover the right agent for a task
📖 Understand detailed capabilities and limitations
✅ Validate requirements before execution
📊 Estimate performance and resource needs
🔗 Chain multiple agents intelligently

Note: Skills are not executable code—they're structured metadata that describe what your agent can do.

📋 Complete Skill Structure

View complete skill.yaml structure (click to expand)

A skill.yaml file contains all metadata needed for intelligent orchestration:

# Basic Metadata
id: pdf-processing-v1
name: pdf-processing
version: 1.0.0
author: raahul@getbindu.com

# Description
description: |
  Extract text, fill forms, and extract tables from PDF documents.
  Handles both standard text-based PDFs and scanned documents with OCR.

# Tags and Modes
tags:
  - pdf
  - documents
  - extraction

input_modes:
  - application/pdf

output_modes:
  - text/plain
  - application/json
  - application/pdf

# Example Queries
examples:
  - "Extract text from this PDF document"
  - "Fill out this PDF form with the provided data"
  - "Extract tables from this invoice PDF"

# Detailed Capabilities
capabilities_detail:
  text_extraction:
    supported: true
    types:
      - standard
      - scanned_with_ocr
    languages:
      - eng
      - spa
    limitations: "OCR requires pytesseract and tesseract-ocr"
    preserves_formatting: true

  form_filling:
    supported: true
    field_types:
      - text
      - checkbox
      - dropdown
    validation: true

  table_extraction:
    supported: true
    table_types:
      - simple
      - complex_multi_column
    output_formats:
      - json
      - csv

# Requirements
requirements:
  packages:
    - pypdf>=3.0.0
    - pdfplumber>=0.9.0
    - pytesseract>=0.3.10
  system:
    - tesseract-ocr
  min_memory_mb: 512

# Performance Metrics
performance:
  avg_processing_time_ms: 2000
  avg_time_per_page_ms: 200
  max_file_size_mb: 50
  max_pages: 500
  concurrent_requests: 5
  memory_per_request_mb: 500
  timeout_per_page_seconds: 30

# Rich Documentation
documentation:
  overview: |
    This agent specializes in PDF document processing with support for text extraction,
    form filling, and table extraction. Handles both standard text-based PDFs and
    scanned documents (with OCR).

  use_cases:
    when_to_use:
      - User uploads a PDF and asks to extract text
      - User needs to fill out PDF forms programmatically
      - User wants to extract tables from reports/invoices
    when_not_to_use:
      - PDF editing or modification
      - PDF creation from scratch
      - Image extraction from PDFs

  input_structure: |
    {
      "file": "base64_encoded_pdf_or_url",
      "operation": "extract_text|fill_form|extract_tables",
      "options": {
        "ocr": true,
        "language": "eng"
      }
    }

  output_format: |
    {
      "success": true,
      "pages": [{"page_number": 1, "text": "...", "confidence": 0.98}],
      "metadata": {"total_pages": 10, "processing_time_ms": 1500}
    }

  error_handling:
    - "Encrypted PDFs: Returns error requesting password"
    - "Corrupted files: Returns validation error with details"
    - "Timeout: 30s per page, returns partial results"

  examples:
    - title: "Extract Text from PDF"
      input:
        file: "https://example.com/document.pdf"
        operation: "extract_text"
      output:
        success: true
        pages:
          - page_number: 1
            text: "Extracted text..."
            confidence: 0.99

  best_practices:
    for_developers:
      - "Check file size before processing (max 50MB)"
      - "Use OCR only when necessary (3-5x slower)"
      - "Handle errors gracefully with user-friendly messages"
    for_orchestrators:
      - "Route based on operation type (extract/fill/parse)"
      - "Consider file size for performance estimation"
      - "Chain with text-analysis for content understanding"

# Assessment fields for skill negotiation
assessment:
  keywords:
    - pdf
    - extract
    - document
    - form
    - table

  specializations:
    - domain: invoice_processing
      confidence_boost: 0.3
    - domain: form_filling
      confidence_boost: 0.3

  anti_patterns:
    - "pdf editing"
    - "pdf creation"
    - "merge pdf"

  complexity_indicators:
    simple:
      - "single page"
      - "extract text"
    medium:
      - "multiple pages"
      - "fill form"
    complex:
      - "scanned document"
      - "ocr"
      - "batch processing"

🔌 API Endpoints

List All Skills:

Get Skill Details:

GET /agent/skills/{skill_id}

Get Skill Documentation:

GET /agent/skills/{skill_id}/documentation

📚 See the Skills Documentation for complete examples.

Negotiation

Capability-based agent selection for intelligent orchestration

Bindu's negotiation system enables orchestrators to query multiple agents and intelligently select the best one for a task based on skills, performance, load, and cost.

🔄 How It Works

Orchestrator broadcasts assessment request to multiple agents
Agents self-assess capability using skill matching and load analysis
Orchestrator ranks responses using multi-factor scoring
Best agent selected and task executed

🔌 Assessment Endpoint

View API details (click to expand)

Request:

{
  "task_summary": "Extract tables from PDF invoices",
  "task_details": "Process invoice PDFs and extract structured data",
  "input_mime_types": ["application/pdf"],
  "output_mime_types": ["application/json"],
  "max_latency_ms": 5000,
  "max_cost_amount": "0.001",
  "min_score": 0.7,
  "weights": {
    "skill_match": 0.6,
    "io_compatibility": 0.2,
    "performance": 0.1,
    "load": 0.05,
    "cost": 0.05
  }
}

Response:

{
  "accepted": true,
  "score": 0.89,
  "confidence": 0.95,
  "skill_matches": [
    {
      "skill_id": "pdf-processing-v1",
      "skill_name": "pdf-processing",
      "score": 0.92,
      "reasons": [
        "semantic similarity: 0.95",
        "tags: pdf, tables, extraction",
        "capabilities: text_extraction, table_extraction"
      ]
    }
  ],
  "matched_tags": ["pdf", "tables", "extraction"],
  "matched_capabilities": ["text_extraction", "table_extraction"],
  "latency_estimate_ms": 2000,
  "queue_depth": 2,
  "subscores": {
    "skill_match": 0.92,
    "io_compatibility": 1.0,
    "performance": 0.85,
    "load": 0.90,
    "cost": 1.0
  }
}

📊 Scoring Algorithm

Agents calculate a confidence score based on multiple factors:

score = (
    skill_match * 0.6 +        # Primary: skill matching
    io_compatibility * 0.2 +   # Input/output format support
    performance * 0.1 +        # Speed and reliability
    load * 0.05 +              # Current availability
    cost * 0.05                # Pricing
)

🎯 Skill Assessment

View assessment metadata example (click to expand)

Skills include assessment metadata for intelligent matching:

assessment:
  keywords:
    - pdf
    - extract
    - table
    - invoice

  specializations:
    - domain: invoice_processing
      confidence_boost: 0.3
    - domain: table_extraction
      confidence_boost: 0.2

  anti_patterns:
    - "pdf editing"
    - "pdf creation"

  complexity_indicators:
    simple:
      - "single page"
      - "extract text"
    complex:
      - "scanned document"
      - "batch processing"

💡 Example: Multi-Agent Selection

# Query 10 translation agents
for agent in translation-agents:
  curl http://$agent:3773/agent/negotiation \
    -d '{"task_summary": "Translate technical manual to Spanish"}'

# Responses ranked by orchestrator
# Agent 1: score=0.98 (technical specialist, queue=2)
# Agent 2: score=0.82 (general translator, queue=0)
# Agent 3: score=0.65 (no technical specialization)

⚙️ Configuration

View configuration example (click to expand)

Enable negotiation in your agent config:

config = {
    "author": "your.email@example.com",
    "name": "research_agent",
    "description": "A research assistant agent",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering", "skills/pdf-processing"],
    "storage": {
        "type": "postgres",
        "database_url": "postgresql+asyncpg://bindu:bindu@localhost:5432/bindu",  # pragma: allowlist secret
        "run_migrations_on_startup": False,
    },
    "negotiation": {
        "embedding_api_key": os.getenv("OPENROUTER_API_KEY"),  # Load from environment
    },
}

📚 See the Negotiation Documentation for complete details.

Task Feedback and DSPy

Bindu collects user feedback on task executions to enable continuous improvement through DSPy optimization. By storing feedback with ratings and metadata, you can build golden datasets from real interactions and use DSPy to automatically optimize your agent's prompts and behavior.

Submitting Feedback

Provide feedback on any task using the tasks/feedback method:

curl --location 'http://localhost:3773/' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer <your-token>' \
--data '{
    "jsonrpc": "2.0",
    "method": "tasks/feedback",
    "params": {
        "taskId": "550e8400-e29b-41d4-a716-446655440200",
        "feedback": "Great job! The response was very helpful and accurate.",
        "rating": 5,
        "metadata": {
            "category": "quality",
            "source": "user",
            "helpful": true
        }
    },
    "id": "550e8400-e29b-41d4-a716-446655440024"
}'

Feedback is stored in the task_feedback table and can be used to:

Filter high-quality task interactions for training data
Identify patterns in successful vs. unsuccessful completions
Optimize agent instructions and few-shot examples with DSPy
We are working on the DsPY - will release soon.

📬 Push Notifications

Bindu supports real-time webhook notifications for long-running tasks, following the A2A Protocol specification. This enables clients to receive push notifications about task state changes and artifact generation without polling.

Quick Start

Start webhook receiver: python examples/webhook_client_example.py

Configure agent in examples/echo_agent_with_webhooks.py:

manifest = {
    "capabilities": {"push_notifications": True},
    "global_webhook_url": "http://localhost:8000/webhooks/task-updates",
    "global_webhook_token": "secret_abc123",
}

Run agent: python examples/echo_agent_with_webhooks.py
Send tasks - webhook notifications arrive automatically

View webhook receiver implementation (click to expand)

from fastapi import FastAPI, Request, Header, HTTPException

@app.post("/webhooks/task-updates")
async def handle_task_update(request: Request, authorization: str = Header(None)):
    if authorization != "Bearer secret_abc123":
        raise HTTPException(status_code=401)

    event = await request.json()

    if event["kind"] == "status-update":
        print(f"Task {event['task_id']} state: {event['status']['state']}")
    elif event["kind"] == "artifact-update":
        print(f"Artifact generated: {event['artifact']['name']}")

    return {"status": "received"}

View notification event types (click to expand)

Status Update Event - Sent when task state changes:

{
  "kind": "status-update",
  "task_id": "123e4567-...",
  "status": {"state": "working"},
  "final": false
}

Artifact Update Event - Sent when artifacts are generated:

{
  "kind": "artifact-update",
  "task_id": "123e4567-...",
  "artifact": {
    "artifact_id": "456e7890-...",
    "name": "results.json",
    "parts": [...]
  }
}

⚙️ Configuration

View configuration example (click to expand)

Using bindufy:

from bindu.penguin.bindufy import bindufy

def handler(messages):
    return [{"role": "assistant", "content": messages[-1]["content"]}]

config = {
    "author": "you@example.com",
    "name": "my_agent",
    "description": "Agent with push notifications",
    "deployment": {"url": "http://localhost:3773"},
    "capabilities": {"push_notifications": True},
    "global_webhook_url": "https://myapp.com/webhooks/global",
    "global_webhook_token": "global_secret"
}

bindufy(config, handler)

Per-Task Webhook Override:

"configuration": {
    "long_running": True,  # Persist webhook in database
    "push_notification_config": {
        "id": str(uuid4()),
        "url": "https://custom-endpoint.com/webhooks",
        "token": "custom_token_123"
    }
}

Long-Running Tasks:

For tasks that run longer than typical request timeouts (minutes, hours, or days), set long_running=True to persist webhook configurations across server restarts. The webhook config will be stored in the database (webhook_configs table).

📖 Complete Documentation - Detailed guide with architecture, security, examples, and troubleshooting.

🎨 Chat UI

Bindu includes a beautiful chat interface at http://localhost:3773/docs

🌐 Bindu Directory

The Bindu Directory is a public registry of all Bindu agents, making them discoverable and accessible to the broader agent ecosystem.

✨ Automatic Registration with Cookiecutter

When you create an agent using the cookiecutter template, it includes a pre-configured GitHub Action that automatically registers your agent in the directory:

Create your agent using cookiecutter
Push to GitHub - The GitHub Action triggers automatically
Your agent appears in the Bindu Directory

🔑 Note: You need to collect the BINDU_PAT_TOKEN from bindus.directory and use it to register your agent.

📝 Manual Registration

We are working on a manual registration process.

🌌 The Vision

a peek into the night sky
}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
{{            +             +                  +   @          {{
}}   |                *           o     +                .    }}
{{  -O-    o               .               .          +       {{
}}   |                    _,.-----.,_         o    |          }}
{{           +    *    .-'.         .'-.          -O-         {{
}}      *            .'.-'   .---.   `'.'.         |     *    }}
{{ .                /_.-'   /     \   .'-.\.                   {{
}}         ' -=*<  |-._.-  |   @   |   '-._|  >*=-    .     + }}
{{ -- )--           \`-.    \     /    .-'/                   }}
}}       *     +     `.'.    '---'    .'.'    +       o       }}
{{                  .  '-._         _.-'  .                   }}
}}         |               `~~~~~~~`       - --===D       @   }}
{{   o    -O-      *   .                  *        +          {{
}}         |                      +         .            +    }}
{{ jgs          .     @      o                        *       {{
}}       o                          *          o           .  }}
{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{

Each symbol is an agent — a spark of intelligence. The tiny dot is Bindu, the origin point in the Internet of Agents.

NightSky Connection [In Progress]

NightSky enables swarms of agents. Each Bindu is a dot annotating agents with the shared language of A2A, AP2, and X402. Agents can be hosted anywhere—laptops, clouds, or clusters—yet speak the same protocol, trust each other by design, and work together as a single, distributed mind.

💭 A Goal Without a Plan Is Just a Wish.

🛠️ Supported Agent Frameworks

Bindu is framework-agnostic and tested with:

Agno
CrewAI
LangChain
LlamaIndex
FastAgent

Want integration with your favorite framework? Let us know on Discord!

🧪 Testing

Bindu maintains 70%+ test coverage:

pytest -n auto --cov=bindu --cov-report= && coverage report --skip-covered --fail-under=70

Troubleshooting

Common Issues

Issue	Solution
`Python 3.12 not found`	Install Python 3.12+ and set in PATH, or use `pyenv`
`bindu: command not found`	Activate virtual environment: `source .venv/bin/activate`
`Port 3773 already in use`	Change port in config: `"url": "http://localhost:4000"`
Pre-commit fails	Run `pre-commit run --all-files`
Tests fail	Install dev dependencies: `uv sync --dev`
`Permission denied` (macOS)	Run `xattr -cr .` to clear extended attributes

Reset environment:

rm -rf .venv
uv venv --python 3.12.9
uv sync --dev

Windows PowerShell:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

🤝 Contributing

We welcome contributions! Join us on Discord. Pick the channel that best matches your contribution.

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

📖 Contributing Guidelines

📜 License

Bindu is open-source under the Apache License 2.0.

💬 Community

We 💛 contributions! Whether you're fixing bugs, improving documentation, or building demos—your contributions make Bindu better.

💬 Join Discord for discussions and support
⭐ Star the repository if you find it useful!

👥 Active Moderators

Our dedicated moderators help maintain a welcoming and productive community:

_{Raahul Dutta}

_{Paras Chamoli}

_{Gaurika Sethi}

_{Vishaal LS}

_{Abhijeet Singh Thakur}

_{Rajesh Somasundaram}

Want to become a moderator? Reach out on Discord!

�� Acknowledgements

Grateful to these projects:

🗺️ Roadmap

GRPC transport support
Sentry error tracking
Ag-UI integration
Retry mechanism
Increase test coverage to 80% - In progress
Redis scheduler implementation
Postgres database for memory storage
Negotiation support
AP2 end-to-end support
DSPy integration - In progress
MLTS support
X402 support with other facilitators

💡 Suggest features on Discord!

🎓 Workshops

AI Native in Action: Agent Symphony - Slides

⭐ Star History

Built with 💛 by the team from Amsterdam
Happy Bindu! 🌻🚀✨

From idea to Internet of Agents in 2 minutes.
Your agent. Your framework. Universal protocols.

⭐ Star us on GitHub • 💬 Join Discord • 🌻 Read the Docs