AI agent platform

Build agents once.Run them from your assistant over MCP.

XonaMind is the workspace where your agents live: prompt, model, tools, memory, skills and knowledge bases. Run them by API, widget or MCP, with cheapest-model routing.

Start free Read the docs

No card to try it. Works from Claude, ChatGPT, Cursor or your own code.

support-bot

Support agent

Live

Model: GPT-5 · OpenRouter
Tools: HTTP · Web search
Memory: Conversations and preferences
Knowledge: Help center · 128 docs
Skills: Refunds · Triage

Runs through MCP, API or widget with the same agent.

How it works

From idea to production in three steps

An agent is a prompt, a model, tools and memory. You build it; XonaMind runs it.

1
Create the agent
Pick a model, write the prompt and add memory, skills and knowledge bases.
2
Connect tools and knowledge
Add HTTP or OpenAPI tools, webhooks, schedules and OAuth connections for your end users.
3
Call it from where you work
API, OpenAI-compatible endpoint, streaming widget or MCP from your assistant.

Everything included

The infrastructure behind every agent

You do not build queues, retries, traces or provider billing. XonaMind already does.

Durable runs

Runs with retries, state and history. If something fails, you see it and requeue it.

Webhooks

Tell your app when a run finishes, fails or needs approval.

Schedules

Run agents on a cron without maintaining your own workers.

Evals

Measure answers against a set of cases before changing the prompt or model.

Traces

Every agent step, with tools, latency and tokens.

Metrics and alerts

Usage, cost, errors and latency per agent, with alerts when something goes out of range.

Cheapest-model routing

Multi-provider: OpenRouter, OpenAI, DeepSeek, Alibaba, Venice and fal, always picking the cheapest fit.

HTTP and OpenAPI tools

Connect any API with an OpenAPI schema or your own HTTP tool.

Knowledge and memory

Documents with vector search, plus per-user and per-conversation memory.

Credentials vault

Store provider keys and tool secrets without exposing them to your users.

End-user OAuth

Your customers connect their accounts without you seeing or storing their tokens.

Also: usage credits, scoped personal tokens, per-workspace roles and audit logs.

Native MCP

Your whole workspace, from your assistant

XonaMind exposes the same product over MCP. Create agents, edit prompts, connect tools, read traces and manage keys without opening the dashboard.

Open your client
Claude, ChatGPT, Cursor or any MCP-compatible client.
Point it at /mcp
Use your API URL and a personal token for your workspace.
Ask in plain language
"Create an agent that triages tickets", "show me today's traces", "add a webhook".

Read the MCP guide

MCP client configuration

{
  "mcpServers": {
    "xonamind": {
      "url": "https://xonamind-api.xonastudio.app/mcp",
      "headers": {
        "Authorization": "Bearer xm_pat_your_token"
      }
    }
  }
}

Replace the example token with a personal token from your workspace. The token is never shared with the model.

Then just ask

"Create a support agent with GPT-5, web search and my knowledge base. Publish it over the API and notify me by webhook."

Integrations

Call your agents from anywhere

The same API for your backend, your frontend, your assistant or your customers' chat.

REST API

Runs, streaming, history and webhooks from your backend.

curl -X POST "https://xonamind-api.xonastudio.app/v1/agents/support-bot/runs" \
  -H "Authorization: Bearer xm_pat_your_token" \
  -H "Content-Type: application/json" \
  -d '{"input": "Summarize today's tickets"}'

OpenAI-compatible

Change the base URL and use the OpenAI SDK you already have.

curl "https://xonamind-api.xonastudio.app/v1/openai/chat/completions" \
  -H "Authorization: Bearer xm_pat_your_token" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "xonamind/support-bot",
    "messages": [{ "role": "user", "content": "Summarize today's tickets" }]
  }'

Embeddable widget

A streaming chat for your site, with no UI to build.

<script
  src="https://xonamind-api.xonastudio.app/widget.js"
  data-agent="support-bot"
  async
></script>

SDK

A typed client to ship agents in minutes.

import { XonaMind } from "@xonamind/sdk"

const xm = new XonaMind({ apiKey: process.env.XONAMIND_API_KEY })

const run = await xm.agents.run("support-bot", {
  input: "Summarize today's tickets",
})

Pricing

Start small, scale when you need it

Plans with clear limits for agents, members, knowledge, runs and MCP tokens. No hidden fees.

Limits per plan
Credits included every month
Change or cancel anytime

From

$29/mo

Pro

See pricing and limits

FAQ

What to know before you start

Agents, models, costs and MCP, without the fluff.

What is an agent in XonaMind?+

It is a reusable configuration: prompt, model, tools, memory, skills and knowledge bases. The same definition is called by API, the OpenAI-compatible endpoint, the widget or MCP.

Can I use my own models?+

XonaMind routes across OpenRouter and direct providers such as OpenAI, DeepSeek, Alibaba, Venice and fal. You can pin a model per agent or let routing pick the cheapest option that fits the job.

How does billing work?+

Every plan includes monthly credits and usage limits. Consumption is charged against plan credits first and purchased credits second. You see the cost in the traces.

What happens if a provider fails?+

Runs are durable: they have state, retries and history. If a model fails, the run is recorded and you can retry it; webhooks notify your app.

Do I need the dashboard?+

No. Everything you can do on screen can be done over MCP: agents, tools, credentials, knowledge, webhooks, evals, keys and members. The dashboard is there for those who prefer it.

Where do my users' tokens go?+

Your end users' OAuth connections are stored in the workspace credentials vault. They authorize once and you never handle their secrets.

Your next agent starts here

Create a workspace, build your first agent and call it over MCP the same afternoon.

Create a free account Sign in