Skip to main content

​
Frequently Asked Questions

Find answers to common questions about Bindu, the protocol, and agent development.

​
General Questions

Bindu is a framework that transforms your AI agent into an A2A (Agent-to-Agent) and AP2 (Agent Protocol 2) compliant living server. It enables agents to communicate seamlessly with other agents and microservices across the open web using standardized protocols.
A2A (Agent-to-Agent) is a protocol for agent communication, defining how agents discover, authenticate, and exchange messages.AP2 (Agent Protocol 2) extends A2A with commerce capabilities, enabling agents to negotiate, transact, and trade services.Bindu implements both protocols, making your agents compatible with the broader agent ecosystem.
Bindu eliminates the complexity of implementing A2A and AP2 protocols manually. Instead of writing hundreds of lines of protocol code, you simply use the @pebblify decorator and Bindu handles:
  • Protocol compliance
  • Message serialization
  • Task management
  • Context handling
  • Security and authentication
  • Error handling
Yes! Bindu is open source under the MIT license. You can use it freely in personal and commercial projects.View on GitHub
Currently, Bindu supports Python 3.12+. We’re planning SDKs for:
  • JavaScript/TypeScript
  • Go
  • Rust
Join our Discord to stay updated!

​
Getting Started

Install Bindu using pip or uv:
# Using pip
pip install bindu

# Using uv (recommended)
uv add bindu
See the Quickstart Guide for complete setup instructions.
  • Python 3.12 or higher
  • An AI framework (Agno, LangChain, CrewAI, etc.)
  • API keys for your chosen LLM provider (OpenAI, Anthropic, etc.)
  • Basic understanding of Python and async programming
Yes! Bindu is designed to wrap existing agent implementations. Simply add the @pebblify decorator to your agent function:
@pebblify(
    author="Your Name",
    name="My Agent",
    description="My existing agent"
)
def my_existing_agent(messages: list[str]) -> str:
    # Your existing agent code
    return response
No! Bindu abstracts away the protocol complexity. You can build agents without deep protocol knowledge. However, understanding the protocols helps you leverage advanced features.Check out our Protocol Documentation to learn more.

​
Technical Questions

Bindu supports multiple authentication methods:
  • Bearer Tokens: Simple token-based auth
  • mTLS: Mutual TLS for secure agent-to-agent communication
  • OAuth2: Standard OAuth2 flows
  • API Keys: Header or query parameter keys
Configure authentication in your agent’s deployment settings.
Yes! That’s the core purpose of Bindu. Agents can:
  • Discover other agents via DIDs (Decentralized Identifiers)
  • Send messages using the A2A protocol
  • Share contexts for conversation continuity
  • Reference previous tasks
  • Negotiate and collaborate
Bindu provides comprehensive error handling:
@pebblify(name="My Agent")
def my_agent(messages: list[str]) -> str:
    try:
        return process_messages(messages)
    except ValueError as e:
        raise InvalidParamsError(f"Invalid input: {e}")
    except Exception as e:
        raise InternalError(f"Processing failed: {e}")
Errors are automatically formatted as JSON-RPC error responses.
Bindu agents are standard Python applications. Deploy them using:
  • Docker: Containerize your agent
  • Cloud Platforms: AWS, GCP, Azure
  • Serverless: AWS Lambda, Google Cloud Functions
  • VPS: Any server with Python support
See our Examples for deployment configurations.
Yes! Bindu works with any Python AI framework:
  • Agno (recommended)
  • LangChain
  • CrewAI
  • Custom implementations
You can even mix frameworks in multi-agent systems.
Bindu provides built-in monitoring:
@pebblify(
    name="My Agent",
    monitoring=True,
    telemetry=True,
    debug_mode=True
)
Integrate with external tools like Prometheus, Grafana, or custom dashboards.See Monitoring Guide for details.

​
Multi-Agent Systems

Create multiple agents and coordinate them:
# Agent 1
@pebblify(name="Research Agent")
def research_agent(query: str) -> dict:
    # Research implementation
    pass

# Agent 2
@pebblify(name="Analysis Agent")
def analysis_agent(data: dict) -> dict:
    # Analysis implementation
    pass

# Orchestrator
async def orchestrate(query: str):
    research = await research_agent(query)
    analysis = await analysis_agent(research)
    return analysis
See Multi-Agent Systems for patterns.
Use context IDs to maintain conversation continuity:
context_id = "550e8400-e29b-41d4-a716-446655440027"

# Agent 1 creates task
task1 = agent1.send_message(context_id=context_id)

# Agent 2 references task 1
task2 = agent2.send_message(
    context_id=context_id,
    reference_task_ids=[task1.id]
)
Yes! Bindu supports the negotiation protocol:
  • Agents submit bids for tasks
  • Orchestrators evaluate proposals
  • Winning agents execute tasks
  • Losers are notified
This enables market-based task allocation.

​
Performance & Scaling

Performance depends on:
  • Your agent’s complexity
  • LLM provider rate limits
  • Server resources
  • Concurrent request handling
Typical agents handle 10-100 requests/second. Use load balancing and horizontal scaling for higher throughput.
  • Cache responses: Store common queries
  • Batch requests: Process multiple messages together
  • Use faster models: GPT-3.5 instead of GPT-4 for simple tasks
  • Optimize prompts: Reduce token usage
  • Async processing: Use async/await for I/O operations
  • Connection pooling: Reuse HTTP connections
Yes! Run multiple agents on different ports:
# Agent 1 on port 8030
@pebblify(
    name="Agent 1",
    deployment_config=DeploymentConfig(url="http://localhost:8030")
)

# Agent 2 on port 8031
@pebblify(
    name="Agent 2",
    deployment_config=DeploymentConfig(url="http://localhost:8031")
)

​
Security & Privacy

Bindu provides security features:
  • Encryption: mTLS for agent communication
  • Authentication: Multiple auth methods
  • Access Control: Trust levels and permissions
  • Audit Logging: Track all interactions
You’re responsible for securing your deployment and managing secrets.
Best practices:
  • Use environment variables
  • Never commit keys to version control
  • Use secret management services (AWS Secrets Manager, HashiCorp Vault)
  • Rotate keys regularly
  • Use different keys for dev/staging/production
Yes! Bindu is self-hosted by default. Deploy on:
  • Your own servers
  • Private cloud
  • On-premises infrastructure
  • Air-gapped networks
You have full control over your deployment.

​
Troubleshooting

  1. Check logs: Look for error messages
  2. Verify API keys: Ensure LLM provider keys are valid
  3. Test connectivity: Can you reach the agent URL?
  4. Check ports: Is the port open and not blocked?
  5. Review configuration: Validate your agent config
  6. Test locally: Run agent locally first
  • Verify your Bearer token is correct
  • Check token hasn’t expired
  • Ensure Authorization header is properly formatted
  • Confirm agent requires authentication
  • Check trust levels and permissions
Enable debug mode:
@pebblify(
    name="My Agent",
    debug_mode=True,
    debug_level=2  # Maximum verbosity
)
This logs all protocol messages and state transitions.

​
Contributing

We welcome contributions!
  • Code: Fix bugs, add features
  • Documentation: Improve docs, add examples
  • Community: Help others on Discord
  • Testing: Report bugs, test new features
See our Contributing Guide.
  1. Check if it’s already reported on GitHub Issues
  2. Create a new issue with:
    • Clear description
    • Steps to reproduce
    • Expected vs actual behavior
    • Environment details
    • Code samples if applicable

​
Still Have Questions?

Discord Community

Ask questions in real-time

GitHub Discussions

Start a discussion

Documentation

Read the full docs

Email Support

Contact: raahul@saptha.me
⌘I