Vibeleaderboard
Index / tool
Visit dexto.ai
Category
AI Agents
Rank
Pricing
Open Source
Type
TOOL
Use case
Agent Building
Interfaces
CLI · Web · API · MCP
Builder
truffle-ai
GitHub
651 stars
Latest release
dexto@1.13.5
Date

About

Dexto is an open-source agent harness that orchestrates LLMs into stateful, tool-using agents with persistent memory, session management, and human-in-the-loop approvals. It ships with a ready-to-use coding agent and supports 50+ LLMs, MCP tool integration, multi-agent spawning, and deployment via CLI, Web UI, REST API, or as an MCP server itself.

What it does

Dexto is a runtime that wraps a language model so it can act like a long-running assistant: it keeps track of what happened earlier in a conversation, decides which outside actions to reach for, and can pause to check with a person before doing something consequential. Out of the box it comes preloaded with an assistant tuned for writing and fixing code, and the same underlying engine lets you swap in almost any model, run several linked assistants at once, or expose the whole thing as a chat window, a command-line program, or a network service other software can call.

Why it's ranked here

It earns a look for how deliberately layered the codebase is: business logic, HTTP routes, approval handling and the command-line entry point each live in separate packages with typed errors and schema-validated configuration rather than one sprawling script. The interface support is broad without being a thin wrapper: a documented REST API generated from route definitions, a command-line tool, and the ability to run as its own protocol server for other agent tools to call into. The license is Elastic 2.0, not a permissive open-source license, so anyone planning to resell this as a hosted service should read the terms before building on it.

What's good

The approval system is genuinely fine-grained: policies can require confirmation for every tool call, auto-approve for trusted local work, or allow-list specific actions by name, and the tool remembers what a person has already approved within a session so it does not re-ask. Persistent memory and session history mean a conversation can be resumed, searched, or handed to a different model mid-stream without losing context. The sub-agent system lets a coding assistant delegate a bounded, read-only exploration task to a helper that cleans itself up afterward, which keeps a long task from ballooning into one giant untrimmed context window.

Tradeoffs

The license is Elastic 2.0, not a standard open-source license: it blocks anyone from hosting Dexto itself as a competing managed service, which matters for a team hoping to build directly on top of it. Running models locally depends on the machine's own GPU being detected correctly, trading a cloud provider's reliability for setup work that varies by hardware. The codebase spans a dozen or more packages for the command line, web interface, server, registry and individual tool integrations: real separation of concerns, but more ground for a newcomer to cover before a first meaningful change.

How to use it well

This fits a developer who wants one coding assistant they can point at different models by cost or capability, instead of being locked to a single vendor. Start in manual approval mode to see exactly what it wants to run before trusting auto-approve on a real codebase. Wire it in through its own protocol-server mode rather than the chat interface when the goal is plugging it into another agent's toolchain, not using it directly. It is not the right pick for someone who wants a finished product with one fixed model and nothing to configure, since real use starts by writing a configuration file by hand.

Technical notes+

The public surface is organized as barrel exports: packages/core/src/agent/index.ts exposes the DextoAgent class along with generate/stream APIs and session-title generation types; packages/core/src/session/index.ts exposes SessionManager and ChatSession; packages/core/src/memory/index.ts exposes MemoryManager with Zod-validated CreateMemoryInput and UpdateMemoryInput schemas; packages/core/src/approval/index.ts exposes ApprovalManager plus a typed ApprovalRequest/ApprovalResponse union covering tool-call, elicitation and custom approval flows; and packages/core/src/mcp/index.ts exposes MCPManager and DextoMcpClient with schema-validated stdio, SSE and HTTP server configs. packages/server/src/hono/index.ts assembles the REST surface with a createDextoApp() factory that mounts per-domain OpenAPIHono routers (messages, sessions, mcp, approvals, agents, tools, memory, schedules, skills, plus an A2A/JSON-RPC set) behind CORS and auth middleware, falling back to a dummyAgentsContext stub when multi-agent routing is unavailable. packages/cli/src/index.ts is a thin bootstrap that resolves a DEXTO_PACKAGE_ROOT environment variable for standalone binaries and applies layered environment loading before the interactive CLI starts. package.json marks this a pnpm-only monorepo (an only-allow pnpm preinstall guard, a pinned packageManager version) built with turbo and tsup, with vitest driving separate unit, coverage and integration test scripts, and a license field of Elastic-2.0 that matches the full Elastic License 2.0 text in LICENSE. AGENTS.md and CLAUDE.md carry identical repo-convention content: DextoAgent is documented as the validation boundary (public methods validate, internal layers assume validated input), z.infer is disallowed in favor of z.input/z.output, and packages/registry/src/mcp/index.ts is confirmed as the MCP server preset registry's export surface. CONTRIBUTING.md documents a registry-driven path for contributing new bundled agents, requiring an entry in a central registry file plus a build script that copies the agent's directory into the CLI's shipped output.

Observed

License
Elastic License 2.0 (ELv2), a source-available license (not OSI-approved open source) that bars offering the software to third parties as a hosted or managed service.
Language
TypeScript, structured as a pnpm-only monorepo (an only-allow pnpm preinstall guard) built with Turborepo.
Interfaces
a CLI binary, a web UI, a REST/SSE API (Hono, with OpenAPI-generated documentation), and an MCP server mode over stdio or HTTP/SSE transport.
Packaging
Also distributed as an installable SDK package exposing an agent class with session, streaming, and multimodal generation methods for embedding in other Node.js applications.
Structural
Configuration is YAML-based: models, tools, and agent behavior are declared in config files rather than in code.
Structural
Validation is schema-first via Zod across the core package, with a documented convention of explicit input/output type extraction rather than a common shortcut inference pattern.
Structural
Test suite uses Vitest with separate unit and integration test configurations.
Structural
Core package defines two typed error base classes, one for single failures and one for multi-issue validation, instead of throwing plain Error objects.

Read from README.md, package.json, packages/core/src/agent/index.ts, packages/core/src/session/index.ts, packages/core/src/tools/index.ts, packages/core/src/mcp/index.ts, packages/core/src/memory/index.ts, packages/core/src/approval/index.ts, packages/cli/src/index.ts, packages/server/src/hono/index.ts, packages/registry/src/mcp/index.ts, AGENTS.md, CLAUDE.md, LICENSE, CONTRIBUTING.md.

What it can do

  • Orchestrate LLMs into stateful, tool-using agents

    LLM configuration → Stateful agent

  • Require human-in-the-loop approval for agent actions

    Agent action request → Approved or denied action

  • Provide a ready-to-use coding agent

    Coding task → Code output

  • Integrate external tools via MCP

    MCP tool definitions → Tool-enabled agent

Tags

agent-harnessmcpclisdkcoding-agentllm-orchestrationopen-sourcetypescript

Tech Stack

Node.jsDockerTypeScript

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.