yutha

Async Python client for Yutha — open-source infrastructure for groups of AI agents. Identity, capability, accountability, and norms — built once, framework-agnostic.

Status — early-stage pre-release. Currently v0.1.0-alpha.3. Solid enough to play with end-to-end, intentionally pre-1.0. Wire formats and API surfaces may shift before 1.0; pin tightly if you build on it.

The Python SDK gives you signed agent identities, capability-gated message sending, structured envelopes, and access to the append-only receipt log of the Yutha control plane. Adapters for LangGraph, CrewAI, OpenAI Agents, and Microsoft Agent Framework ship as optional extras, so the same SDK works regardless of how you build the agents above it.

Install

pip install yutha                       # core SDK only
pip install 'yutha[langgraph]'          # + LangGraph adapter
pip install 'yutha[crewai]'             # + CrewAI adapter
pip install 'yutha[openai-agents]'      # + OpenAI Agents adapter
pip install 'yutha[maf]'                # + Microsoft Agent Framework adapter

Python 3.11+ required. The core install pulls in grpcio, protobuf, cryptography, and pydantic; the framework extras pull in their respective dependencies (LangChain core, CrewAI, OpenAI Agents, Microsoft Agent Framework, etc.).

Quickstart

A 60-second tour of what the SDK looks like — signing keys, passports, and the client surface. Full end-to-end with a live control plane is in the LangGraph guide.

import yutha

# An agent's cryptographic identity.
signing_key = yutha.SigningKey.generate()

# Its signed passport — the artifact that lets it join a swarm.
passport = yutha.Passport(
    spec_version="1.0.0",
    agent_id=yutha.AgentId.new(),
    swarm_id=yutha.SwarmId.new(),
    agent_public_key=signing_key.public_key(),
    owner="example.com/my-agent",
    framework="langgraph",
    framework_version="0.2.0",
    accepted_constitution_version="1.0.0",
    tier=yutha.PassportTier.MINIMAL,
    issued_at=yutha.Timestamp.now(),
    expires_at=yutha.Timestamp(wall_clock="2099-01-01T00:00:00Z", monotonic_ns=2**62),
).sign(signing_key)

# Connect to a running control plane and register.
async with yutha.YuthaClient.connect(
    "127.0.0.1:50051",
    agent_id=passport.agent_id,
    swarm_id=passport.swarm_id,
    signing_key=signing_key,
) as client:
    await client.admission.register(passport)
    # ... send envelopes, issue capabilities, query receipts ...

What's next

• 15-minute LangGraph walkthrough — build a five-agent workflow with capability gating and a full audit trail.
• CrewAI walkthrough — the same SDK with CrewAI idioms.
• OpenAI Agents research-crew example — end-to-end OpenAI Agents adapter walkthrough (handoff bridging, citation-enforcing constitution, cap-gated function_tools).
• Microsoft Agent Framework DevOps example — end-to-end MAF adapter walkthrough (SRE countersign, schema-change quarantine, ChatAgent integration).
• Worked examples — runnable end-to-end demos covering customer support, code review with security boundaries, AP / invoice processing, research-crew citation enforcement, and DevOps incident-response.
• Concepts — passports, envelopes, capabilities, receipts, and the Cedar-based constitution layer in fifteen minutes.

How it fits together

    ┌──────────────────────────────────────────┐
    │  yutha.YuthaClient                       │
    │  ─────────────────                       │
    │   .admission  →  AdmissionService stub   │
    │   .capability →  CapabilityService stub  │
    │   .envelope   →  EnvelopeService stub    │
    │   .receipt    →  ReceiptService stub     │
    │   .constitution → ConstitutionService    │
    └─────────────────┬────────────────────────┘
                      │
    ┌─────────────────▼─────────────────┐
    │  yutha.auth.BearerSession         │  ← mints + refreshes
    │  (Ed25519 over canonical bytes)   │     AgentBearerToken
    └─────────────────┬─────────────────┘
                      │
    ┌─────────────────▼───────────────┐
    │  yutha._proto.*  (grpcio stubs) │
    └─────────────────────────────────┘

The client is a thin async wrapper over five gRPC services. Bearer tokens are short-lived, Ed25519-signed over the request's canonical bytes; the session handles minting and refresh transparently.

License

Apache 2.0. See LICENSE.

Contributing

Contributor setup, codegen, and the integration-test workflow are documented in the repository's CONTRIBUTING guide.