Auxilia

https://github.com/user-attachments/assets/3236f9da-28c5-44c8-8c2c-4c68199f187c

auxilia is a web platform for running AI agents as a team. An admin sets up MCP servers and agents once, and the whole workspace shares them — no more everyone configuring their own assistant with their own prompts and credentials. Anyone can create an agent and experiment, zero technical skills required: agents chat in the browser or in Slack, use your internal tools, ask a human for approval before sensitive actions, and run on schedules or in the background. An agent is only as good as the environment you give it. That's where auxilia comes in: iterating quickly is how you find what's missing — a tool it needed, a doc that's outdated, data that isn't as clean as you thought. The more gaps you close, the more reliable your agents become; when one proves itself, plug it into your own products through the API. You pick the LLM provider (Anthropic, OpenAI, Google, DeepSeek) and can switch anytime — and because it's self-hosted, conversations, credentials, and usage data never leave your infrastructure. Everything that matters — the documentation, the data models, the MCP servers you build to make your agents work — is yours, and it follows you to any other agentic platform.

🤔 Why auxilia

Most MCP clients are desktop apps tied to a single user: every teammate reinvents the same agent, alone, in their own tool. auxilia is the middle ground between "everyone has their own ChatGPT tab" and building a custom AI platform:

• 🧪 A playground for the whole company — business users build and test agents themselves, no code. Not every experiment is a keeper — that's the point: everyone gets hands-on intuition for what agents can (and can't) do, cheaply.
• 👥 One place, shared agents — register MCP servers and agents once; the whole team reuses them, with workspace roles and per-agent permissions.
• 🏠 Your infra, your data — self-hosted; conversations, API keys (AES-GCM encrypted at rest) and per-user OAuth tokens stay in your own database and Redis.
• 🔓 No provider lock-in — swap Anthropic, OpenAI, Google, or DeepSeek per agent as pricing and quality shift.
• ✅ Guardrails built in — each tool can be always-allowed, require human approval (in chat or Slack), or be disabled.
• 🔌 Remote MCP native — any remote (Streamable HTTP) MCP server becomes a tool: internal services or one-click Notion, Linear, GitHub, HubSpot, BigQuery, Slack, Sentry.

🚀 Quick start

All you need is Docker and one LLM API key (Anthropic, OpenAI, Google, or DeepSeek).

git clone https://github.com/keurcien/auxilia.git
cd auxilia
cp .env.example .env      # paste at least one LLM API key
make build && make up

Open http://localhost:3000 — the first account you create becomes the workspace admin. Add an MCP server, create an agent, and start chatting.

PostgreSQL and Redis are started and wired up by Docker Compose; every other setting has a working dev default. The .env at a glance:

Developing? make dev runs PostgreSQL, Redis, the FastAPI backend (migrations applied) and the Next.js frontend in parallel, all with hot reload. Full walkthrough in the Get Started guide.

✨ Features

🤝 Integrations

LLM providers

MCP servers — one-click install: Notion · Linear · GitHub · HubSpot · BigQuery · Slack · Sentry — or paste the URL of any custom remote MCP server with its OAuth credentials or API key.

Workspace tools: Slack, Langfuse, Google OAuth SSO.

💡 From playground to production

A few agents we run ourselves:

📊 A data analyst that answers with dashboards, not spreadsheets. Plugged into our BigQuery warehouse, with a custom MCP server that renders interactive charts and dashboards inside the chat. "How did sales move after the price change?" used to be a ticket for the data team; now it's a question anyone types and gets answered — with a graph — in seconds.

🎧 A super agent behind our customer support. One orchestrator dispatches specialized subagents — orders, refunds, logistics — and delivers ready-to-send suggestions straight into our support tool through the invoke API. It was built and tuned like any other workspace agent, then wired into the product without changing a line of it.

💶 A pricing analyst that does the work nobody wants twice. Hand it a spreadsheet with thousands of messy, wildly inconsistent rows, and it writes and runs its own code in an isolated sandbox to clean, cross-check, and price every one of them. The same sandbox trick stretches surprisingly far — we've used it to train and deploy small ML models.

📚 Documentation

Full docs at auxilia-docs.vercel.app:

• Get Started — run auxilia locally
• Agents — configuration, permissions, subagents
• MCP Servers — registration, auth, examples
• Tools — per-tool approval rules
• Sandbox — enable code execution for an agent
• Deployment — Docker Compose, Google Cloud Run
• Integrations — Slack, Langfuse

🗺 Roadmap

• Scheduled triggers
• Skills
• Support for more sandboxes (e.g. Daytona)
• Deployment guides
• More SSO providers (Okta, Entra ID)

Have an idea? Open an issue or start a discussion.

🤝 Contributing

Contributions are very welcome — bug reports, agent ideas, MCP server recipes, UI fixes:

1. Fork the repo and create a branch (git checkout -b feature/my-change)
2. Enable the git hooks once per clone: pre-commit install — they run ruff on changed Python and a stricter type-aware ESLint config on changed web/ files
3. Run make dev and make sure tests pass (cd backend && uv run pytest)
4. Open a pull request — the PR title must follow Conventional Commits (e.g. feat: …, fix: …); PRs are squash-merged and release-please derives versions and changelogs from the titles

Please read CLAUDE.md first — it documents the backend's layered architecture (router → service → repository → model) and naming conventions.

📄 License

AGPL-3.0 — free to use, modify, and self-host.