Paladin Documentation

Welcome to the Paladin documentation! Paladin is a Rust-based enterprise multi-agent orchestration framework built with Hexagonal Architecture and Domain-Driven Design principles.

🚀 Getting Started

New to Paladin? Start here:

1. Quickstart Guide - Get your first Paladin agent running in 15 minutes
2. Installation - Detailed setup instructions for all platforms
3. Examples Gallery - Working code examples for common use cases

📚 User Guides

Learn how to build with Paladin:

• Autonomous Agent Features - Auto-planning, prompt generation, dynamic temperature, and agent handoffs
• Battalion Orchestration - Multi-agent coordination with orchestration patterns
• Maneuver Flow DSL - Declarative workflows with Flow DSL syntax
• Tool Integration (Arsenal) - Integrate external tools via MCP protocol
• Memory Management (Garrison) - Conversation context and persistence
• Output Formatting (Herald) - Format and stream agent responses
• WarEngine: Superstep Execution - Battlefield state, Waypoint checkpointing, and cyclic graph execution
• Control Flow - Dynamic routing and subgraphs
• Parley & Chronicle - Pause, resume, history and graceful shutdown
• Aegis: Fault Tolerance - Retry, timeout, error handlers, model fallback and node caching
• Agent Runtime - Middleware, context management, vault memory, structured output and the reasoning agent
• Eval Harness - Evaluate Paladin agent quality and catch regressions
• CLI Usage Guide - Complete command-line interface reference

🏗️ Architecture

Understand Paladin's design:

• Architecture Overview - Three-layer hexagonal architecture
• Hexagonal Design - Port/adapter pattern implementation
• Domain Model - DDD entities and relationships
• Commissary - Input-side, per-call window-rationing officer
• Design Patterns - Patterns used throughout Paladin

🧭 Deployment Topologies

Choose how to run Paladin:

• Choosing a Topology - Compare embedded library, orchestrated Battalion, HTTP service host, queue/worker and sidecar deployments

🚢 Deployment

Deploy Paladin to production:

• Docker - Containerized deployment
• Kubernetes - Cloud-native orchestration
• CI/CD - Automated pipelines with GitHub Actions
• Production Best Practices - Security, scaling, and reliability
• Platform API - Runs, threads, assistants, schedules and webhooks REST surface
• Versioning Policy - Lockstep versioning rules and transition criteria
• Release Checklist - Dependency-aware release and publish workflow

🔧 Operations

Monitor and maintain Paladin:

• Observability - Traces, sinks and persistence
• Logging - Structured logging configuration
• Monitoring - Metrics and dashboards
• Troubleshooting - Common issues and solutions
• Performance Tuning - Optimize for throughput and latency

🤝 Contributing

Extend and improve Paladin:

• Contribution Guide - How to contribute
• Adapter Development - Create custom adapters
• Testing Guide - Testing requirements and patterns

📖 API Reference

Comprehensive API documentation is available via rustdoc:

cargo doc --open

Or browse online at: https://docs.rs/paladin (when published)

🎯 Key Concepts

Medieval Military Theme

Paladin uses a consistent Medieval Military naming convention. This is a short excerpt — see Domain Model for the complete ubiquitous-language table of every Medieval-Military term Paladin uses:

Architecture Layers

Paladin follows hexagonal (ports and adapters) architecture:

• Core Layer - Pure domain logic, no external dependencies
• Application Layer - Use cases and port definitions (interfaces)
• Infrastructure Layer - Adapter implementations for external systems

Dependencies flow inward only: Infrastructure → Application → Core

💡 Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Documentation: You're reading it!

📄 License

See LICENSE for details.