saiki

Dexto (formerly Saiki)

A lightweight runtime for creating and running AI agents that turn natural language into real-world actions.

Table of Contents

1. Why Dexto?
2. Installation
3. Run Modes
4. Quick Start
5. Programmatic API
6. Configuration
7. Examples & Demos
8. Capabilities
9. LLM Providers
10. Standalone MCP Manager
11. CLI Reference
12. Next Steps
13. Community & Support
14. Contributors
15. License

Why Dexto?

Dexto is the missing intelligence layer of your stack—perfect for building AI applications, standalone chatbots, or as the reasoning engine inside larger products.

The main Dexto features are:

Installation

# NPM global
npm install -g dexto

# —or— build from source
git clone https://github.com/truffle-ai/dexto.git
cd dexto && npm i && npm run build && npm link

Run Modes

Run dexto --help for all flags, sub-commands, and environment variables.

Quick Start

Set your API keys first:

export OPENAI_API_KEY=your_openai_api_key_here

Then, give Dexto a multi-step task that combines different tools:

dexto "create a new snake game in html, css, and javascript, then open it in the browser"

Dexto will use its filesystem tools to write the code and its browser tools to open the index.html file—all from a single prompt.

Then start the Web UI:

dexto --mode web

The Web UI will load up any previous conversations you had, and also allows you to experiment with different models and MCP servers.

Programmatic API

The DextoAgent class is the core of the runtime. The following example shows its full lifecycle: initialization, running a single task, holding a conversation, and shutting down.

import 'dotenv/config';
import { DextoAgent, loadConfigFile } from 'dexto';

const cfg  = await loadConfigFile('./agents/default-agent.yml');
const agent = new DextoAgent(cfg);

await agent.start();

// Single-shot task
console.log(await agent.run('List the 5 largest files in this repo'));

// Conversation
await agent.run('Write a haiku about TypeScript');
await agent.run('Make it funnier');

agent.resetConversation();

await agent.stop();

Everything in the CLI is powered by this same class—so whatever the CLI can do, your code can too.

Check out our Typescript SDK docs for a complete guide.

Configuration

Agents are defined in version-controlled YAML. A minimal example:

mcpServers:
  filesystem:
    type: stdio
    command: npx
    args: ['-y', '@modelcontextprotocol/server-filesystem', '.']
  puppeteer:
    type: stdio
    command: npx
    args: ['-y', '@truffle-ai/puppeteer-server']

llm:
  provider: openai
  model: gpt-4o
  apiKey: $OPENAI_API_KEY

systemPrompt: |
  You are Dexto, an expert coding assistant...

Change the file, reload the agent, and chat—the conversation state, memory, and tools will update.

Check out our Configuration guide for the complete reference.

Examples & Demos

🛒 Amazon Shopping Assistant

Task: Can you go to amazon and add some snacks to my cart? I like trail mix, cheetos and maybe surprise me with something else?

# Default agent has browser tools
dexto

📧 Send Email Summaries to Slack

Task: Summarize emails and send highlights to Slack

dexto --agent ./agents/examples/email_slack.yml

More ready-to-run recipes live in agents/examples and the docs site.

Capabilities

• Dynamic LLM Switching: Change model, provider, or routing rules mid-conversation.
• Streaming Responses: Opt-in to receive tokens as they arrive for real-time output.
• Multi-Session Management: Create isolated, stateful chat sessions (think workspace tabs).
• Pluggable Memory Backends: Use the in-memory default or connect your own DB via the StorageManager.
• Lifecycle Event Bus: Subscribe to agent events for metrics, logging, or custom side-effects.
• Standalone MCP Manager: Use Dexto's core MCPManager in your own projects without the full agent.

LLM Providers

Dexto supports multiple LLM providers out-of-the-box, plus any OpenAI SDK-compatible provider.

• OpenAI: gpt-4.1-mini, gpt-4o, o3, o1 and more
• Anthropic: claude-4-sonnet-20250514, claude-3-7-sonnet-20250219, and more
• Google: gemini-2.5-pro, gemini-2.0-flash and more
• Groq: llama-3.3-70b-versatile, gemma-2-9b-it

Quick Setup

Set your API key and run. You can switch providers instantly via the -m flag.

# OpenAI (default)
export OPENAI_API_KEY=your_openai_api_key_here
export ANTHROPIC_API_KEY=your_anthropic_api_key_here
export GOOGLE_GENERATIVE_AI_API_KEY=your_google_gemini_api_key_here
dexto

# Switch providers via CLI
dexto -m claude-3.5-sonnet-20240620
dexto -m gemini-1.5-flash-latest

For comprehensive setup instructions, see our LLM Providers Guide.

Standalone MCP Manager

Need to manage MCP tool servers without the full agent? Use the MCPManager directly in your own applications.

import { MCPManager } from 'dexto';

// Create manager instance
const manager = new MCPManager();

// Connect to MCP servers
await manager.connectServer('filesystem', {
  type: 'stdio',
  command: 'npx',
  args: ['-y', '@modelcontextprotocol/server-filesystem', '.']
});

// Get all available tools across servers
const tools = await manager.getAllTools();
console.log('Available tools:', Object.keys(tools));

// Execute a tool
const result = await manager.executeTool('readFile', { path: './README.md' });
console.log('File contents:', result);

// Disconnect when done
await manager.disconnectAll();

See the MCP Manager Documentation for the complete API reference.

CLI Reference

Usage: dexto [options] [command] [prompt...]

The Dexto CLI allows you to talk to Dexto, build custom AI Agents, and create complex AI applications.

For full documentation, visit https://docs.dexto.ai.

Arguments:
  prompt                    Natural-language prompt to run once. If empty, starts interactive CLI.

Options:
  -v, --version             output the current version
  -a, --agent <path>        Path to agent config file
  -s, --strict              Require all server connections to succeed
  --no-verbose              Disable verbose output
  -m, --model <model>       Specify the LLM model to use.
  -r, --router <router>     Specify the LLM router to use (vercel or in-built)
  --mode <mode>             Runtime mode: cli | web | server | discord | telegram | mcp (default: "cli")
  --web-port <port>         Optional port for the web UI (default: "3000")
  -h, --help                display help for command

Commands:
  create-app                Scaffold a new Dexto Typescript app.
  init-app                  Initialize an existing Typescript app with Dexto.
  mcp                       Run Dexto as an MCP server.

Next Steps

• Quick Start – Get up and running in minutes.
• Configuration Guide – Configure agents, LLMs, and tools.
• Building with Dexto – Developer guides and patterns.
• API Reference – REST APIs, WebSocket, and SDKs.

Contributing

We welcome contributions! Refer to our Contributing Guide for more details.

Community & Support

Dexto is built by the team at Truffle AI.
Join our Discord to share projects, ask questions, or just say hi!

If you enjoy Dexto, please give us a ⭐ on GitHub—it helps a lot!

Contributors

Thanks to all these amazing people for contributing to Dexto!

License

Elastic License 2.0. See LICENSE for full terms.