Skip to content

Agenkit

The foundation for AI agents.

A production-ready framework for building distributed AI agent systems with cross-language support, comprehensive middleware, and full observability.

Website Python 3.10+ Go 1.21+ License: Apache 2.0 Tests: 867 passing

🎉 Production Ready

All 5 development phases complete:

  • ✅ Phase 1: Foundation & Core (100%)
  • ✅ Phase 2: Transport Layer (100%)
  • ✅ Phase 3: Middleware & Resilience (100%)
  • ✅ Phase 4: Testing & Quality (100% - 867 tests passing)
  • ✅ Phase 5: DevOps & Release (100% - Docker + Kubernetes ready)

✨ Key Features

Core Capabilities

  • 🏗️ Minimal, Type-Safe Interfaces - Agent, Message, Tool primitives
  • 🔄 Orchestration Patterns - Sequential, Parallel, Router, Fallback, Conditional
  • 🌐 Cross-Language Support - Python ↔ Go with full compatibility
  • 🚀 Multiple Transports - HTTP, gRPC, WebSocket
  • 🛡️ Production Middleware - Circuit breaker, retry, timeout, rate limiting, caching, batching
  • 📊 Full Observability - OpenTelemetry tracing, Prometheus metrics, structured logging
  • 🐳 Container Ready - Docker images and Kubernetes manifests
  • ⚡ High Performance - <1% overhead, benchmarked and optimized

🚀 Quick Start

# Install
pip install agenkit

from agenkit import Agent, Message

# Create a simple agent
class MyAgent(Agent):
    @property
    def name(self) -> str:
        return "my-agent"

    @property
    def capabilities(self) -> list[str]:
        return ["text-processing"]

    async def process(self, message: Message) -> Message:
        return Message(
            role="agent",
            content=f"Processed: {message.content}"
        )

# Use it
agent = MyAgent()
response = await agent.process(Message(role="user", content="Hello!"))
print(response.content)  # "Processed: Hello!"

# Install
go get github.com/agenkit/agenkit-go

package main

import (
    "context"
    "fmt"
    "github.com/agenkit/agenkit-go/agenkit"
)

type MyAgent struct{}

func (a *MyAgent) Name() string {
    return "my-agent"
}

func (a *MyAgent) Capabilities() []string {
    return []string{"text-processing"}
}

func (a *MyAgent) Process(ctx context.Context, msg *agenkit.Message) (*agenkit.Message, error) {
    return &agenkit.Message{
        Role:    "agent",
        Content: fmt.Sprintf("Processed: %s", msg.Content),
    }, nil
}

func main() {
    agent := &MyAgent{}
    msg := &agenkit.Message{Role: "user", Content: "Hello!"}
    response, _ := agent.Process(context.Background(), msg)
    fmt.Println(response.Content) // "Processed: Hello!"
}

# Start full stack (agents + observability)
docker-compose up -d

# Access services
# - Python agent: http://localhost:8080
# - Go agent: http://localhost:8081
# - Jaeger UI: http://localhost:16686
# - Prometheus: http://localhost:9090

📚 Learn More

  • Getting Started

    New to Agenkit? Start here to learn the basics and build your first agent.

    Get started

  • Architecture

    Understand the layered architecture and design principles behind Agenkit.

    Learn architecture

  • Guides

    Step-by-step guides for Python, Go, cross-language communication, and deployment.

    Browse guides

  • Examples

    28+ comprehensive examples covering all features and patterns.

    View examples

🏗️ Architecture

┌─────────────────────────────────────────────────────────────┐
│                     Application Layer                        │
│  (Your agents, tools, and business logic)                   │
└────────────────────┬────────────────────────────────────────┘
                     │
┌────────────────────┴────────────────────────────────────────┐
│                  Middleware Layer                            │
│  Circuit Breaker • Retry • Timeout • Rate Limiter           │
│  Caching • Batching • Tracing • Metrics                     │
└────────────────────┬────────────────────────────────────────┘
                     │
┌────────────────────┴────────────────────────────────────────┐
│                  Transport Layer                             │
│  HTTP • gRPC • WebSocket • Protocol Adapters                │
└────────────────────┬────────────────────────────────────────┘
                     │
┌────────────────────┴────────────────────────────────────────┐
│                   Core Interfaces                            │
│  Agent • Message • Tool • Patterns                           │
└─────────────────────────────────────────────────────────────┘

📊 Performance

Agenkit is designed for production use with minimal overhead:

  • Go HTTP: 18.5x faster than Python (0.055ms vs 1.02ms)
  • Middleware overhead: <0.01% of total request time
  • Transport overhead: <1% in realistic LLM workloads
  • Message scaling: 10,000x size = 190x latency (excellent efficiency)

View detailed benchmarks →

🧪 Testing

Comprehensive test coverage with 867 tests passing (100%):

  • 76 tests - Cross-language integration (Python ↔ Go)
  • 53 tests - Chaos engineering (network failures, crashes, slow responses)
  • 37 tests - Property-based testing (invariant validation)
  • 700+ tests - Unit and integration tests

🤝 Contributing

We welcome contributions! Check out our contributing guide to get started.

📄 License

Apache License 2.0 - See LICENSE for details.

Built with ❤️ by the Agenkit team