dexto

What is Dexto?

Dexto is an agent harness—the orchestration layer that turns LLMs into reliable, stateful agents that can take actions, remember context, and recover from errors.

Think of it like an operating system for AI agents:

| Component | Analogy | Role | |-----------|---------|------| | LLM | CPU | Raw processing power | | Context Window | RAM | Working memory | | Dexto | Operating System | Orchestration, state, tools, recovery | | Your Agent | Application | Domain-specific logic and clients |

Why Dexto?

• Configuration-driven: Define agents in YAML. Swap models and tools without touching code.
• Batteries included: Session management, tool orchestration, memory, multimodal support, and observability—out of the box.
• Run anywhere: Local, cloud, or hybrid. CLI, Web UI, REST API, Discord, Telegram, or embedded in your app.

What You Can Build

• Coding Agents – Build, debug, and refactor code autonomously
• Autonomous Agents – Plan, execute, and adapt to user goals
• Digital Companions – Assistants that remember context and anticipate needs
• MCP Clients & Servers – Connect tools, files, APIs via Model Context Protocol
• Multi-Agent Systems – Agents that collaborate, delegate, and solve complex tasks together

Coding Agent

Dexto ships with a production-ready coding agent you can use immediately via the CLI or Web UI.

# Launch the coding agent (default)
dexto

# Or explicitly
dexto --agent coding-agent

What it can do:

• Build new apps from scratch
• Read, write, and refactor code across your entire codebase
• Execute shell commands and run tests
• Spawn specialized sub-agents for exploration and planning
• Remember context across sessions with persistent memory
• Work with any of 50+ LLMs (swap models mid-conversation)

Ready-to-use interfaces:

• Web UI – Chat interface with file uploads, syntax highlighting, and MCP tool browser
• CLI – Terminal-native with /commands, streaming output, and session management

The coding agent is just one example of what you can build. Create your own agents by defining a YAML config—same architecture, your domain.

Quick Start

Install

# macOS / Linux / WSL (native installer, recommended)
curl -fsSL https://dexto.ai/install | bash

# Windows PowerShell
irm https://dexto.ai/install.ps1 | iex

# Or build from source
git clone https://github.com/truffle-ai/dexto.git
cd dexto && pnpm install && pnpm install-cli

Upgrade/uninstall and migration troubleshooting live in docs:

• Installation guide: https://docs.dexto.ai/docs/getting-started/installation
• CLI command reference: https://docs.dexto.ai/docs/guides/cli/overview

Run

# Start Dexto (launches setup wizard on first run)
dexto

More options:

dexto --mode cli                                   # Terminal mode
dexto -p "create a landing page for a coffee shop" # One-shot task
dexto --auto-approve "refactor this codebase"      # Skip confirmations
dexto -m claude-sonnet-4-5-20250929                # Switch models
dexto --help                                       # Explore all options

Inside the interactive CLI, type / to explore commands—switch models, manage sessions, configure tools, and more.

Manage Settings

# Configure defaults like LLM provider/model, API keys, or download local models
dexto setup

Logs are stored in ~/.dexto/logs/. Use DEXTO_LOG_LEVEL=debug for verbose output.

Core Features

50+ LLMs, Instant Switching

Switch models mid-conversation—no code changes, no restarts.

| Provider | Models | |----------|--------| | OpenAI | gpt-5.2, gpt-5.2-pro, gpt-5.2-codex, o4-mini | | Anthropic | Claude Sonnet, Opus, Haiku (with extended thinking) | | Google | Gemini 3 Pro, 2.5 Pro/Flash | | Groq | Llama 4, Qwen, DeepSeek | | xAI | Grok 4, Grok 3 | | Local | Ollama, GGUF via node-llama-cpp (Llama, Qwen, Mistral, etc.) | | + Gateways | OpenRouter, AWS Bedrock, Vertex AI, LiteLLM |

Run locally for privacy: Local models keep data on your machine with automatic GPU detection (Metal, CUDA, Vulkan).

MCP Integration (30+ Tools)

Connect to Model Context Protocol servers—Puppeteer, Linear, ElevenLabs, Firecrawl, Sora, and more.

# agents/my-agent.yml
mcpServers:
  filesystem:
    type: stdio
    command: npx
    args: ['-y', '@modelcontextprotocol/server-filesystem', '.']
  browser:
    type: stdio
    command: npx
    args: ['-y', '@anthropics/mcp-server-puppeteer']

Browse and add servers from the MCP Store in the Web UI or via /mcp commands in the CLI.

Human-in-the-Loop Controls

Fine-grained control over what your agent can do:

permissions:
  mode: manual           # Require approval for each tool
  # mode: auto-approve   # Trust mode for local development
  toolPolicies:
    alwaysAllow:
      - mcp--filesystem--read_file
      - mcp--filesystem--list_directory
    alwaysDeny:
      - mcp--filesystem--delete_file

Agents remember which tools you've approved per session.

Persistent Sessions & Memory

Conversations persist across restarts. Create memories that shape agent behavior.

# Continue last conversation
dexto -c

# Resume specific session
dexto -r session-abc123

# Search across all conversations
dexto search "database schema"

Multi-Agent Systems

Agents can spawn specialized sub-agents to handle complex subtasks. The coding agent uses this to delegate exploration:

# In your agent config
tools:
  - type: agent-spawner
    allowedAgents: ["explore-agent"]
    maxConcurrentAgents: 5
    defaultTimeout: 300000  # 5 minutes

Built-in sub-agents:

• explore-agent – Fast, read-only codebase exploration

Any agent in the Agent Registry can be spawned as a sub-agent—including custom agents you create and register.

Sub-agents run ephemerally, auto-cleanup after completion, and forward tool approvals to the parent—so users see one unified approval flow.

Run Modes

| Mode | Command | Use Case | |------|---------|----------| | Web UI | dexto | Chat interface with file uploads (default) | | CLI | dexto --mode cli | Terminal interaction | | Web Server | dexto --mode server | REST & SSE APIs | | MCP Server | dexto --mode mcp | Expose agent as an MCP server over stdio |

Platform integrations: Discord, Telegram

Transport: stdio

Connect your Dexto agent as an MCP server in Claude Code or Cursor:

dexto --mode mcp --auto-approve --no-elicitation                # Default agent
dexto --mode mcp --agent coding-agent --auto-approve --no-elicitation
npx dexto --mode mcp --agent coding-agent --auto-approve --no-elicitation

Example MCP config for Claude Code or Cursor:

{
  "command": "npx",
  "args": ["-y", "dexto", "--mode", "mcp", "--agent", "coding-agent", "--auto-approve", "--no-elicitation"]
}

--auto-approve and --no-elicitation are required for MCP mode since it runs non-interactively.

Transport: http/sse

dexto --mode server exposes your agent as an MCP server at /mcp for remote clients:

dexto --mode server --port 3001
ngrok http 3001  # Optional: expose publicly

Dexto Agents SDK

Build AI agents programmatically. Everything the CLI does, your code can too.

npm install @dexto/core

import { DextoAgent } from '@dexto/core';

const agent = new DextoAgent({
  llm: { provider: 'openai', model: 'gpt-5.2', apiKey: process.env.OPENAI_API_KEY }
});
await agent.start();

const session = await agent.createSession();
const response = await agent.generate('What is TypeScript?', session.id);
console.log(response.content);

// Streaming
for await (const event of await agent.stream('Write a story', session.id)) {
  if (event.name === 'llm:chunk') process.stdout.write(event.content);
}

// Multimodal
await agent.generate([
  { type: 'text', text: 'Describe this image' },
  { type: 'image', image: base64Data, mimeType: 'image/png' }
], session.id);

// Switch models mid-conversation
await agent.switchLLM({ mo