Ship agents to your team, not to someone's laptop.

Why auxilia

auxilia is more than a chat app. It’s a place for your team to design AI assistants, see what they can actually do with your company’s knowledge and tools, and put them to work wherever they’re needed.

• A sandbox for building better assistants — refine an assistant’s instructions, connect it to the right tools and documents (Notion pages, data models, internal guides), and quickly see what it can handle before rolling it out
• One source of truth for your team — when an assistant works well, share it with colleagues so everyone follows the same process instead of each person crafting their own prompts
• Works beyond the chat window — the same assistants can be plugged into automation tools, scheduled jobs, or embedded directly inside your existing products — customer support consoles, internal dashboards, spreadsheets, and more
• Freedom to choose the right AI model — pick the model that fits each assistant’s job and budget, and switch providers as the market evolves, without re-doing any of the setup
• Your data stays yours — auxilia runs on your own infrastructure, so conversations, credentials, and business context never leave your control

What you can build

• A CRM agent that queries HubSpot and drafts Slack replies
• A data analyst that runs BigQuery, produces charts in a sandbox, and posts results to a thread
• An on-call assistant that reads Sentry issues, searches Linear, and opens pull requests via GitHub
• A workspace-wide coordinator agent that dispatches work to specialized subagents

Architecture

auxilia is composed of three services plus an optional sandbox provider:

┌─────────────┐     ┌─────────────┐     ┌──────────────────┐
│   Browser   │────▶│   Next.js   │────▶│     FastAPI      │
│   (React)   │◀────│   (proxy)   │◀────│   (LangGraph)    │
└─────────────┘     └─────────────┘     └────────┬─────────┘
                                                 │
                                    ┌────────────┼────────────┐
                                    │            │            │
                         ┌──────────▼──┐ ┌───────▼──────┐ ┌───▼──────────┐
                         │ Remote MCP  │ │  PostgreSQL  │ │   Sandbox    │
                         │  Servers    │ │  + Redis     │ │  (optional)  │
                         └─────────────┘ └──────────────┘ └──────────────┘

Key concepts

Agents

An agent is defined by a system prompt, an avatar (emoji + color), its tools — MCP server bindings and optionally one sandbox — the skills it may follow, and optional subagents. Each agent can use tools from multiple MCP servers at once.

MCP servers

auxilia connects to remote MCP servers over HTTP (Streamable HTTP transport). Servers are registered at the workspace level by admins and can be bound to any agent.

Tools

Each tool exposed by an MCP server can be set to one of three states per agent: always allow, needs approval, or disabled. Approvals happen inline in the chat (or in Slack).

Sandbox

Bind a sandbox to an agent to give it a Linux code-execution environment with execute, ls, read_file, write_file, edit_file, glob and grep. Sandboxes are workspace resources (OpenSandbox, Daytona or Cloud Run) an admin registers once; the runtime opens the thread’s sandbox before every run.

Skills

A skill is a SKILL.md procedure — plus optional files and scripts — kept in a workspace library, written in the app or synced from a GitHub/GitLab repository, and enabled per agent.

Triggers

A trigger runs an agent on a cron schedule, in a timezone, as its owner — each firing is a new thread with a background run.

Workspace roles

• admin — manage MCP servers, sandboxes, models, users and teams, invites, personal access tokens, and every agent
• editor — create and edit agents, skills and triggers
• member — chat with agents shared with them or their team

Supported LLM providers

Configure one or more providers via environment variables. At least one is required.

Integrations

• Slack — invoke workspace agents, approve tool calls, and stream responses from Slack threads
• Langfuse — trace LLM calls, tool calls, and costs per agent and user

Where to go next

Pick the path that matches what you’re here for.

• Get Started — developers running auxilia locally with Docker Compose
• Deploy & Configure — DevOps / IT / AI engineers setting up auxilia for a team (Cloud Run, VM, environment, user management, MCP, sandbox, Langfuse, Slack)
• Build Agents — agent authors configuring instructions, tools, subagents, and permissions
• Tutorials — business-friendly how-tos (HTTP triggers, Slack, custom UIs, schedulers)
• Case Studies — real-world stories from teams using auxilia