dexto

Dexto enables agents to be defined entirely through YAML configuration files without requiring code changes, leveraging a configuration enrichment system that merges agent-specific settings with global preferences and LLM provider registries. The system parses agent configuration files, resolves system prompts, and initializes the DextoAgent runtime with pre-configured behavior, tool bindings, and LLM parameters. This approach decouples agent definition from deployment, allowing non-technical users to modify agent behavior through configuration alone.

Dexto implements a provider-agnostic LLM service layer that abstracts OpenAI, Anthropic, and other providers through a unified interface, enabling agents to switch models at runtime without code changes. The system tracks token consumption per request, aggregates costs across sessions, and supports custom model configurations with fallback chains. The LLM service resolves API keys from environment variables or Dexto API key provisioning, handles provider-specific request formatting (function calling schemas, reasoning effort parameters), and maintains a cost ledger for billing and analytics.

Dexto supports multimodal inputs including text, images, and other media types, enabling agents to process visual information and generate responses based on image analysis. The system handles image encoding (base64, URLs), passes images to vision-capable LLM providers (GPT-4 Vision, Claude 3 with vision), and integrates image processing into the message pipeline. Agents can receive images as input, analyze them using LLM vision capabilities, and reference image content in subsequent messages.

Dexto implements OpenTelemetry integration for distributed tracing and observability, emitting traces for agent execution, tool calls, and LLM requests. The system exports traces to OpenTelemetry-compatible backends (Jaeger, Datadog, etc.), enabling visualization of agent execution flow, performance bottlenecks, and error propagation across distributed systems. Traces include structured metadata about agent state, tool execution, token usage, and latency, providing deep visibility into agent behavior.

Dexto supports advanced LLM features like reasoning effort parameters (available on Claude models) that enable agents to request extended thinking or higher reasoning levels for complex problems. The system exposes reasoning effort configuration through agent settings, passes parameters to compatible LLM providers, and tracks additional costs associated with extended reasoning. Agents can dynamically adjust reasoning effort based on task complexity, enabling cost-effective use of advanced reasoning capabilities.

Dexto implements a tool confirmation system where sensitive or high-risk tool operations require explicit user approval before execution. When an agent attempts to call a tool marked as requiring confirmation, the system pauses execution, emits a confirmation request event, and waits for user approval through the UI, CLI, or API. The approval workflow integrates with the message processing pipeline, allowing agents to continue execution after approval or handle rejection gracefully.

Dexto's DextoAgent runtime implements an event-driven architecture where agent execution flows through a message processing pipeline that handles LLM calls, tool invocations, and state transitions. The system emits typed events (agent-started, tool-called, message-received, error-occurred) that can be subscribed to for real-time monitoring, logging, and mid-loop injection. Messages flow through a queue system that supports insertion of new messages during execution, enabling dynamic prompt injection and error recovery without restarting the agent.

Dexto implements native MCP server support, allowing agents to discover and execute tools from external MCP servers through a standardized protocol. The system maintains a tool registry that maps MCP tool definitions to executable functions, handles tool invocation with schema validation, and supports tool confirmation workflows where sensitive operations require user approval before execution. Tools are discovered dynamically from MCP servers, cached in the tool registry, and executed within the agent's message processing pipeline with full error handling and result streaming.

Dexto manages agent sessions as stateful containers that persist conversation history, maintain message context, and implement automatic context compaction to prevent token overflow. Sessions track message history with search capabilities, support message operations (edit, delete, search), and implement a compaction strategy that summarizes old messages or removes low-relevance context when token limits approach. The session lifecycle includes initialization, active conversation, and cleanup phases, with persistent storage backends (file-based or custom) for recovery across restarts.

Dexto supports multi-agent systems where parent agents can spawn and delegate tasks to sub-agents, with support for parallel execution of independent sub-agents and result aggregation. The system implements an agent registry that tracks available agents, handles agent instantiation with configuration inheritance, and manages inter-agent communication through a standardized protocol. Sub-agents execute in parallel when possible, with results collected and returned to the parent agent for further processing, enabling hierarchical task decomposition and specialization.

Dexto exposes agents through a REST API server that supports both request/response and streaming modes via Server-Sent Events (SSE), enabling real-time agent execution monitoring from web clients. The API implements standard REST endpoints for session management, message submission, and history retrieval, while SSE streaming provides real-time event delivery for agent state changes and tool execution. The A2A (Agent-to-Agent) protocol enables agents to communicate with other agents through HTTP, supporting distributed multi-agent systems and cross-service orchestration.

Dexto includes a web UI built with modern component architecture and real-time state management that connects to the API server via SSE for live agent execution updates. The UI implements reactive components that update in real-time as agent state changes, tool execution progresses, and messages arrive. State management integrates with the SSE stream to keep UI in sync with backend agent execution, providing a dashboard view of agent status, conversation history, and tool invocation results.

Dexto provides a command-line interface that supports both interactive mode for real-time agent conversation and command-based execution for scripting and automation. The CLI implements a setup wizard for initial configuration, command parsing for agent invocation, and formatted output for results and errors. Interactive mode maintains session state across multiple turns, supports readline for command history, and provides real-time feedback on agent execution including tool calls and token usage.

Dexto supports background task execution where agents can spawn long-running jobs that execute asynchronously without blocking the main agent loop. The system implements a job scheduler that tracks task status, supports job cancellation and retry logic, and enables parallel execution of independent tasks. Background tasks integrate with the event system to emit status updates, allowing monitoring of job progress through event subscriptions or polling.