daimon

The open source data science agent for Discord, Slack and Microsoft Teams.

daimon joins your team's chat, writes and runs code, fits Bayesian models with PyMC, and posts charts and runnable notebooks back into the thread.

Add it to your server in one click → or self-host it from this repo.

Documentation site · Quickstart · Slack setup · Teams setup · Claude Code plugin · Changelog

What it does

• Answers in the thread. @mention the bot in a channel and it opens a thread, runs the analysis, and replies with a fitted model, a chart, a plain-English read on the uncertainty, and a marimo notebook that reproduces the result.
• Works with the whole team. Anyone in the server can follow up in the same thread. Sessions keep their context across turns.
• Runs on a schedule. Routines run recurring analyses headlessly and post the results where you ask.
• Connects to your tools. Ask it to connect Notion, Linear or any other MCP server. Token-based servers are shared per agent; OAuth servers are connected per person. GitHub repos connect through the GitHub App: ask it to connect GitHub, or run /github.
• Reachable from Claude Code. The bundled plugin logs in through Slack or Discord OAuth and exposes every daimon you belong to as an MCP server.
• One deployment, many communities. Deploy once on your own Anthropic API key. Any number of Discord servers and Slack workspaces can install it, each as an isolated tenant with its own agent, memory and data. On Teams, a deployment serves one Microsoft 365 organisation.

Everything is done in conversation. Slash commands (/here, /agent-setup, /github, /routines, /billing, /privacy, /help) exist for people who prefer them; on Teams they are plain words (setup, routines, help) sent in a 1:1 chat with the bot.

Example prompts

"Here's last quarter's sales export. We changed pricing in week 6. Did it actually help?"

"Is variant B actually better than A, or is that just noise?"

"Forecast next month's signups, with uncertainty bands."

"Every Monday at 9am, pull the weekend's numbers and post a summary here."

Quickstart

The quickstart has the full walkthrough. In short, you need Docker and an Anthropic API key in a workspace dedicated to this deployment. Want to run on just an OpenAI key instead, no Anthropic account at all? Skip to Run on OpenAI below.

1. Configure the environment.

   git clone https://github.com/pymc-labs/daimon.git && cd daimon
   cp .env.example .env
   

   In .env, set DAIMON_ANTHROPIC__API_KEY, DAIMON_MCP__JWT_SECRET (any random string), DAIMON_MCP__PUBLIC_URL (http://localhost:8765/mcp for local use), POSTGRES_PASSWORD and DAIMON_CRYPTO__KEYS (a Fernet key, without which agent keys can't be saved).

2. Create a Discord bot in the Developer Portal, enable the Message Content Intent and Server Members Intent, put its token in .env as DAIMON_DISCORD__BOT_TOKEN, and invite it to a server you control.

3. Start the stack.

   docker compose up --build -d
   

   This brings up Postgres, runs migrations, seeds the default agents and skills, and starts the MCP, Discord and scheduler services.

@mention the bot in a channel. It replies in a new thread. If it stays silent, check docker compose logs discord.

Run on OpenAI

No Anthropic account needed — leave DAIMON_ANTHROPIC__API_KEY unset and provision an OpenAI agent instead, after step 3 above. First add DAIMON_CHANNEL_OPENAI_KEY=<key> and DAIMON_TURN__PROVIDER_RUNTIME_FILE=/app/runtime/openai.json to .env. Your tenant UUID is the id field in the output of docker compose run --rm init "daimon tenants list --json".

docker compose run --rm init "daimon openai init --tenant-id <your-tenant-uuid> --project <openai-project-id> --model <openai-model-id>"
docker compose run --rm init "daimon agents backend set <agent-name-or-id> openai"

The first command creates an OpenAI agent, a hosted environment and seeds the default skill set; the second routes that agent's channels to it. Then run docker compose up -d so the services read the new values. See Run on OpenAI for the OpenAI key setup, per-channel routing, verifying the install, and what's different on OpenAI (no multi-agent delegation, no cross-turn memory, and a few other gaps listed there).

The documentation covers production setup, Slack, Microsoft Teams, GitHub, MCP servers and the Claude Code plugin. Prefer to skip all of that? The hosted version at daimon.decision.ai installs in one click, no API key or server required.

How it works

flowchart LR
    subgraph adapters
        direction TB
        Discord
        Slack
        Teams
        CLI
        MCP
        Scheduler
    end
    adapters --> core["daimon core<br>turn pipeline"]
    core <--> ma["Anthropic Managed Agents<br>agents · sessions · skills"]
    core --> pg[("Postgres<br>tenants · thread↔session map")]

daimon is built on Anthropic Managed Agents. A turn works like this: the adapter derives the tenant from platform identity, core opens or resumes a Managed Agents session, streams its events, and the adapter renders the deltas into the thread until the session goes idle.

• daimon.core owns the schema, stores and turn pipeline and imports no adapters. Each adapter owns one platform's I/O and auth, and adapters never import each other. import-linter enforces both rules in CI.
• Managed Agents holds the agents, environments, sessions and skills. Postgres holds only metadata: tenant identity, thread-to-session mappings, config, credentials and billing.
• One Discord guild, Slack workspace or Microsoft 365 organisation is one tenant. Isolation is enforced at the database tenant_id layer, so one Anthropic key can safely serve every install.

Repository layout

Path	What it is
packages/core/	daimon-core: Managed Agents client, stores, turn pipeline
packages/adapters/discord/	Discord bot adapter
packages/adapters/slack/	Slack adapter (optional, early)
packages/adapters/teams/	Microsoft Teams adapter (optional, early)
packages/adapters/web/	Web app adapter (optional, early)
packages/adapters/mcp/	MCP server adapter and agent tools
packages/adapters/scheduler/	Routines scheduler
packages/adapters/cli/	daimon admin CLI
packages/mux/	Provider-agnostic managed-agent interface
packages/testing/	Shared test fixtures
apps/notebook-host/	Standalone marimo notebook host
apps/report-host/	Standalone report host
plugin/	Claude Code plugin
defaults/	YAML defaults seeded into Managed Agents and the database
docs/	Operator documentation
tests/	Cross-package integration and platform-parity tests

Status

Early. Self-hosting works and is documented. Expect rough edges and breaking changes while things settle; see the changelog for what moved.

Contributing

Bug reports and pull requests are welcome. Start with CONTRIBUTING.md for the dev setup and the quality gates every PR keeps green, and look for issues labelled good first issue.

SDK tests use explicit fixture keys. Before local runs, unset exported ANTHROPIC_*, OPENAI_*, GOOGLE_* and GEMINI_* settings, including empty values, and the TLS/proxy overrides listed in the test SDK guide. Their presence raises AmbientSDKConfigurationError before client construction. To remove a single exported key for one run: env -u ANTHROPIC_API_KEY uv run pytest.

Report vulnerabilities privately as described in SECURITY.md. What a deployment stores about its users is in PRIVACY.md.

About

daimon is built by PyMC Labs, the team behind the PyMC project.

Licensed under the MIT License.