Agent-Native Dispatch MCP Server

io.github.BuilderIO/agent-native-dispatch

Central Slack/Telegram router for agent jobs, memory, approvals, and agent-to-agent delegation

What is the Agent-Native Dispatch MCP server?

Agent-Native Dispatch is an MCP server that routes agent work through Slack and Telegram, enabling job management, persistent memory, approval workflows, and delegation between agents. It integrates with the Agent-Native framework to expose shared actions as tools for autonomous agents while maintaining synchronization with UI-based work.

This MCP server acts as a central dispatch hub for Agent-Native applications, allowing agents to receive work through Slack or Telegram channels, manage jobs with approval gates, maintain context across conversations, and delegate tasks to other agents. It bridges autonomous agent capabilities with human oversight and multi-agent coordination.

How to install Agent-Native Dispatch

Copy-paste configuration for popular MCP clients.

transport: http

Config generated by PluginBench — verify against the source before use.

~/.cursor/mcp.json

{
  "mcpServers": {
    "agent-native-dispatch": {
      "url": "https://dispatch.agent-native.com/mcp"
    }
  }
}

Tools & capabilities

Tools this server exposes to the agent.

Job Management — Create, track, and manage agent jobs with status updates and completion handling
Memory and Context — Persistent storage of agent knowledge, skills, and conversation context
Approval Workflows — Request and process human approvals for agent actions before execution
Agent-to-Agent Delegation — Route work between specialist agents in the same workspace or across connected agents
Slack Integration — Receive and send messages, delegate work, and manage approvals via Slack
Telegram Integration — Receive and send messages, delegate work, and manage approvals via Telegram

Use cases

Route agent work requests from Slack or Telegram channels and track job completion
Implement approval gates where humans review and authorize agent actions before execution
Maintain persistent agent memory and skills across multiple conversations and sessions
Delegate specialized tasks between multiple agents in a coordinated workflow
Synchronize agent work with UI-based actions so both paths share validation and permissions
Build multi-agent teams that collaborate on complex tasks across connected workspaces

Agent-Native Dispatch MCP server FAQ

What is Agent-Native Dispatch?

It's an MCP server that provides a central router for agent work via Slack and Telegram, with built-in job management, memory persistence, approval workflows, and agent-to-agent delegation capabilities.

Is Agent-Native free?

Yes, Agent-Native is open-source under the MIT license. The framework and MCP server are free to use and modify.

How do I install this in Cursor or Claude?

Add the remote MCP server endpoint https://dispatch.agent-native.com/mcp to your MCP configuration. Refer to the Agent-Native documentation for detailed setup instructions.

What authentication is required?

The README does not specify authentication requirements. Check the Agent-Native documentation or contact the project for details on API keys and workspace setup.

Can I use this with existing Slack/Telegram bots?

Agent-Native Dispatch is designed to work with the Agent-Native framework. It exposes shared actions as tools, so agents and UIs use the same underlying capabilities.

Does it support multiple agents?

Yes, it includes agent teams and delegation features that allow specialist agents to collaborate within the same workspace or across connected agents.

README (reference)

Source of truth, from the repository.

Agent-Native

Agent-Native is an open-source TypeScript framework for building agents that pair autonomous work with a purpose-built UI. Define each capability once as an action: the agent uses it as a tool, and the UI calls it from code.

Quick start

npx --yes @agent-native/core@latest create my-agent --standalone --template chat

Follow the getting started guide for a full intro to the framework.

Why build agents with UIs?

Coding agents work with more than a text box. Their environment provides context, tools, files, tests, and previews that make their capabilities and results visible.

Knowledge work needs that same kind of environment. A UI shows what an agent can do and gives people familiar ways to inspect, edit, approve, and share its work.

How Agent-Native works

Shared actions. The agent calls each capability as a tool, and the UI calls it from code. Both paths use the same validation, permissions, and implementation.
Shared data. Work done by the agent appears in the UI, and work done in the UI is available to the agent.
Shared application state. The agent receives relevant UI state, such as the current page, selected record, or active view.

The agent does not click through the UI. It works through the same action layer as the UI.

Example: a shared action

Create actions/hello.ts:

import { defineAction } from "@agent-native/core/action";
import { z } from "zod";

// One action powers every app surface: UI, agent, HTTP, MCP, A2A, and CLI.
export default defineAction({
  description: "Return a friendly greeting.",
  schema: z.object({
    name: z.string().default("world").describe("Name to greet"),
  }),
  http: { method: "GET" },
  run: async ({ name }) => {
    return { message: `Hello, ${name}!` };
  },
});

The agent receives hello as a tool. React calls the same function with useActionQuery("hello", { name: "Alex" }). Agent-Native also exposes it through HTTP, MCP, A2A, and the CLI.

Included

Agent chat: Let people delegate work, ask questions, and review results in the same UI.
Authentication and permissions: Control who can access and change shared work.
Skills and memory: Give agents reusable expertise and persistent context.
Automations: Run agent work on schedules or events.
Agent teams: Delegate work to specialist agents in the same workspace or across connected agents.
PostgreSQL backend: Use PostgreSQL in production and PGlite for local development on any Nitro-compatible host.

Example: edit a running app visually

Use /visual-edit in Claude Code to edit a running app on a canvas instead of prompting for each small UI nudge. Compare live pages together, then ask Claude to apply the chosen edits to your source. For example:

/visual-edit the onboarding flow, plus home at every breakpoint

Review the onboarding screens alongside Home at desktop, tablet, and mobile sizes, adjust a button's color or spacing directly, then ask Claude to apply the pending edits to your source. See the Visual Edit guide for the full walkthrough and sharing details.

Bring your LLM, SQL database, tools, and infrastructure. Everything you build stays yours.

See Agent-Native in action:

https://github.com/user-attachments/assets/ef51644b-6506-46d8-8083-0af7b7e5b65c