authkestra

The Compile-Time Safe Identity & AI Agent Authorization Engine for Rust

authkestra is the primary facade crate for the Authkestra ecosystem. It unifies enterprise-grade identity (OAuth 2.1, OpenID Connect Provider/Client, Passkeys/WebAuthn, TOTP, Passwordless, DPoP, SD-JWT, SSF/CAEP) and autonomous AI agent tool authorization (Model Context Protocol (MCP) server guards, JCS cryptographic parameter binding, HITL step-up approval, and zero-trust downstream credential brokering) into a single, cohesive, compile-time safe Rust crate.

🚀 Key Highlights

• Compile-Time Safe Typestate Builder: Unrepresented or invalid auth configurations fail at compile-time, not in production.
• Unified Facade: Manage your entire identity and agent authorization stack from a single dependency via fine-grained Cargo feature flags.
• Autonomous AI Agent & MCP Security (authkestra-mcp): Protect Model Context Protocol tool endpoints with 3-tier authorization (Public, Scoped, HumanApproved), RFC 8785 JSON Canonicalization Scheme (JCS) parameter binding, Passkey/WebAuthn human-in-the-loop (HITL) step-up approval, and AES-256-GCM zero-trust downstream credential vaults.
• Framework Adapters: First-class, ergonomic integrations for both Axum (authkestra-axum) and Actix Web (authkestra-actix).
• Database & Schema Agnostic: No forced schemas or rigid user tables. Bring your own database via clean trait abstractions (KvStore, SessionStore, CredentialStore, OpStore).
• Production-Ready Tracing & Security: Full tracing instrumentation across all request lifecycles, timing-safe cryptographic comparisons, and single-use AtomicConsume execution proofs.

📦 Installation

Add authkestra to your Cargo.toml with the features you need:

[dependencies]
# Example: Axum web application with GitHub OAuth2 and in-memory store
authkestra = { version = "0.13", features = ["axum", "github", "memory"] }

Or for an MCP server protecting AI agent tool calls:

[dependencies]
# Example: Axum MCP server with Model Context Protocol security & Passkeys
authkestra = { version = "0.13", features = ["axum", "mcp", "webauthn", "memory"] }

🔐 TLS Backend

Authkestra requires an HTTPS crypto provider to speak to identity providers and token endpoints:

🛠️ Quickstart

1. Web Application Authentication (Axum + OAuth2)

use authkestra::Authkestra;
use authkestra_engine::store::memory::MemoryStore;
use authkestra_engine::{OAuth2Flow, SessionStore};
use authkestra_providers::github::GithubProvider;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let client_id = std::env::var("GITHUB_CLIENT_ID").unwrap();
    let client_secret = std::env::var("GITHUB_CLIENT_SECRET").unwrap();
    let redirect_uri = "http://localhost:3000/auth/github/callback".to_string();

    let github_provider = GithubProvider::new(client_id, client_secret, redirect_uri);
    let session_store: Arc<dyn SessionStore> = Arc::new(MemoryStore::default());

    // Compile-time typestate builder validates prerequisites
    let auth_engine = Authkestra::builder()
        .provider(OAuth2Flow::new(github_provider))
        .session_store(session_store)
        .build();
}

2. AI Agent MCP Server Guard (authkestra::mcp)

Protect your Model Context Protocol (MCP) server endpoints with granular security tiers, cryptographic parameter binding, and human-in-the-loop approval:

use authkestra::mcp::{McpRouter, McpSecurityTier, ToolHandler, ToolContext, McpError};
use authkestra_engine::reproof::ReproofRequirement;
use serde_json::{json, Value};
use std::sync::Arc;

struct TransferTool;

#[async_trait::async_trait]
impl ToolHandler for TransferTool {
    async fn call(&self, args: Value, ctx: &ToolContext) -> Result<Value, McpError> {
        let amount = args["amount"].as_i64().unwrap_or(0);
        let to = args["to"].as_str().unwrap_or("unknown");
        
        // Downstream credentials resolved securely without exposing keys to LLM context
        let api_token = ctx.get_downstream_token("bank_api", &["transfers:write"]).await;

        Ok(json!({ "status": "executed", "amount": amount, "to": to }))
    }
}

// Build the MCP security router
let mut router = McpRouter::new(session_store.clone(), kv_store.clone());

// Register a high-risk tool requiring Passkey step-up and JCS parameter binding
router.register_tool(
    "execute_transfer",
    "Execute high-value financial transfers",
    json!({
        "type": "object",
        "properties": {
            "amount": { "type": "number" },
            "to": { "type": "string" }
        },
        "required": ["amount", "to"]
    }),
    McpSecurityTier::HumanApproved {
        required_scopes: vec!["scope:transfer".into()],
        reproof: ReproofRequirement::FreshPasskey,
        approval_ttl_secs: 300,
    },
    Arc::new(TransferTool),
);

Run the complete, runnable Axum MCP server example:

cargo run -p authkestra --example axum_mcp_server --all-features

🧩 Feature Flags Reference

🧠 AI Discoverability & Claude Code Skills (llms.txt)

• Agent Index: https://authkestra.com/llms.txt
• Full API Documentation: https://docs.authkestra.com/llms-full.txt
• Official Skills Repository: https://github.com/Authkestra/skills for Claude Code, Antigravity, and Roo Code agent integration.

📜 License

Dual-licensed under MIT or Apache 2.0 at your option.