openkrew

Coordinates execution of multiple AI agents across geographically distributed machines using a message-passing architecture. Agents communicate through a central coordination layer that handles task distribution, state synchronization, and result aggregation without requiring shared memory or databases. Each machine runs an agent instance that can independently process tasks while maintaining consistency through event-driven coordination patterns.

Deploys AI agents directly into chat platforms (Slack, Discord, Microsoft Teams) using native bot APIs and webhook handlers. Agents receive messages as events, process them through LLM inference, and respond back through the chat platform's message API. Integration handles authentication via OAuth/tokens, message parsing, thread context preservation, and rate limiting per platform's constraints.

Allows agents to discover available capabilities (functions, tools, other agents) at runtime through a registry system. New capabilities can be registered dynamically without restarting agents, enabling hot-loading of new functions and tools. Provides introspection APIs for agents to query available capabilities, their parameters, and usage examples.

Monitors and optimizes agent resource usage including token consumption, API call frequency, and execution time. Tracks costs per agent execution and aggregates across teams. Provides recommendations for optimization (e.g., use cheaper models, reduce context size, batch requests). Implements cost controls like token budgets and rate limiting to prevent runaway spending.

Provides a unified interface for calling multiple LLM providers (OpenAI, Anthropic Claude, local Ollama, etc.) with automatic request/response translation. Abstracts differences in API schemas, token counting, model naming conventions, and parameter mappings so agents can switch providers or models without code changes. Handles provider-specific features like function calling, vision capabilities, and streaming responses through a common abstraction layer.

Breaks down complex user requests into subtasks that agents can execute sequentially or in parallel, with dependency tracking and result aggregation. Uses LLM-based reasoning to determine task order, identify dependencies, and decide which agent should handle each subtask. Maintains execution state across tasks, passes outputs from one task as inputs to dependent tasks, and handles failures with retry logic and fallback strategies.

Maintains agent state across multiple interactions, including conversation history, task progress, and learned information. Stores state in configurable backends (in-memory, file-based, or external databases) with automatic serialization and deserialization. Provides context windowing to manage token limits by selectively including relevant historical context in LLM prompts while discarding less relevant information.

Enables agents to call external functions and APIs by generating structured function calls from LLM outputs. Defines available functions through JSON schemas that describe parameters, return types, and constraints. Validates function calls against schemas before execution, executes the function, and feeds results back to the LLM for further reasoning. Supports both synchronous and asynchronous function execution with error handling and retry logic.

Organizes multiple agents into teams with defined roles and responsibilities, automatically routing tasks to appropriate agents based on their capabilities. Uses agent metadata (skills, expertise, availability) to make routing decisions, handles inter-agent communication for collaboration, and aggregates results from multiple agents. Supports hierarchical team structures where some agents coordinate others.

Tracks agent execution in real-time, logging all decisions, function calls, LLM interactions, and results. Provides structured logs with timestamps, execution traces, and performance metrics (latency, token usage, cost). Enables debugging by replaying execution traces and identifying where agents made decisions. Integrates with observability platforms for centralized monitoring of distributed agent teams.

Implements automatic error detection and recovery for agent failures, including LLM API errors, function call failures, and timeout handling. Defines fallback strategies (retry with backoff, use alternative function, escalate to human, etc.) that execute when primary operations fail. Tracks error patterns and adapts recovery strategies based on error type and frequency.

Provides a templating system for constructing LLM prompts with variable substitution, conditional sections, and dynamic content injection. Stores prompt templates with version control, allowing A/B testing of different prompts and tracking which template version produced which results. Supports prompt optimization through feedback loops where agent performance metrics inform template refinement.