Kimaki is a collaborative agent orchestrator that lets you drive coding agents from Discord. Each Discord channel is a project, each thread is a coding session. Send a message, an AI agent edits code on your machine.

You can try the bot in the Kimaki Discord Server to see what it can do.

Quick Start

Kimaki runs on your machine and connects to Discord. You need Node.js 18+ (or Bun) and a Discord server you own (create one with the + button in the Discord sidebar if you don't have one).

npx -y omomaki@latest

The CLI walks you through the whole setup in about a minute:

1. Install the bot — the CLI opens a Discord authorization page in your browser. Pick your server and click Authorize. This installs the shared Kimaki bot into your server with one click — no Discord Developer Portal setup needed.
2. Pick your projects — the CLI asks which folders on your machine should become Discord channels. Each channel is one project.
3. Done — the bot starts and is ready. Send a message in a project channel to start a coding session.

Keep the terminal running. The CLI process is the bridge between Discord and your machine — it runs the bot and the agent sessions. Closing it stops the bot.

What happens on first run

• The CLI checks for the agent runtime and installs it if missing.
• It generates a one-time install link and opens it in your browser. Don't share that link — it contains your credentials.
• After you authorize, the CLI waits for the bot to appear in your server, then asks you to pick project directories.
• Everything is saved locally, so the next npx -y omomaki@latest starts straight into the bot.

If you already have a server

Just run the command and authorize the bot in your existing server. You can add the bot to more servers later with kimaki bot install-url.

What is Kimaki?

Kimaki turns Discord into the control surface for your coding agents. It connects to omo, a coding agent runtime, and maps your work onto Discord's natural structure:

• Channels are projects. Each channel is linked to a project directory on your machine.
• Threads are sessions. Every message you send starts a thread that maps to one agent session.

This separation is the whole point. Other Discord/iMessage agent tools cram everything into a single channel, so sessions pile on top of each other with no clean way to partition them. Kimaki splits projects into channels and sessions into threads, so each piece of work has its own place. Switch projects by switching channels. Switch tasks by switching threads. Search, resume, and fork any of them later.

                            ┌──────────────────────────────────────────────────┐
   Discord server           │  Your machine                                    │
  ┌──────────────────┐      │                                                  │
  │ #web-app ────────┼──────┼──▶ /code/web-app   ──▶ agent session (thread) │
  │ #api ────────────┼──────┼──▶ /code/api       ──▶ agent session (thread) │
  │ #docs ───────────┼──────┼──▶ /code/docs      ──▶ agent session (thread) │
  └──────────────────┘      │        ▲                                         │
        │ thread = session  │        │  reads, edits, runs commands            │
        ▼                   │        ▼  in the project directory               │
     agent replies  ◀───────┼──── AI agent (any model, your subscriptions)     │
  └──────────────────┘      └──────────────────────────────────────────────────┘

Think of it as texting your codebase: you describe what you want, the agent does it, and the conversation lives in a thread you can return to.

Battle tested every day

I'm Tommy, the creator of Kimaki. I do all of my development through it: every project, every session, straight from Discord. I built Kimaki because I wanted one place to start agents, watch them work, jump between projects, and pick things back up from my phone. It is the tool I actually use every day.

All your models, including subscriptions

Kimaki gives you access to every model omo supports: Anthropic, OpenAI, Google, and more. The best part: you can use your existing Claude Pro/Max and ChatGPT/Codex subscriptions instead of paying per token.

Run /login, pick a provider, choose OAuth, and authenticate with your subscription. Kimaki authenticates against the provider the same way the native CLIs do, so subscription inference works and per-token costs show as zero. You can even add multiple accounts and Kimaki rotates between them on rate limits.

See Models & Subscriptions and Model & Agent Switching.

Core Features

Kimaki adds a layer of orchestration features on top of the agent runtime. The ones worth knowing first:

• Scheduled tasks — run the bot on a schedule (cron or a future time). For example, every morning read your inbox with a CLI like Zele and post an email digest thread; then reply to mark some read or unsubscribe.
• The queue — queue a message to send when the current run finishes. Great for "review this when you're done" or "commit at the end". End any message with . queue and even edit it later to update the queued text.
• btw — fork the current context into a new thread to ask a clarifying question in parallel while the agent keeps working. End a message with . btw or run /btw.
• Worktrees — /new-worktree moves a session into an isolated folder mid-plan so it never touches your main checkout; /merge-worktree rebases the commits back and lets you preserve or squash them (and asks the agent to resolve conflicts).
• Diff viewer — /diff generates a shareable URL to review changes in a real diff viewer from your phone or browser.
• Voice messages — record a voice note; Kimaki transcribes it using your project's file tree for accuracy.
• Images — attach images to your message and see images the agent produces, displayed inline in Discord.
• Agent commands — your agent commands, skills, and MCP prompts become Discord slash commands.
• Shell commands — prefix any message with ! to run a shell command in the project directory.
• Tunnels — expose a local dev server to a public URL so you can view it on your phone or another machine.
• Quick agent switching — instantly change model or system prompt with a /<name>-agent command.

How messages reach a session

When you send a message during an active run, the agent normally queues it to run after the current tool call. Kimaki adds an interrupt: if the current step is still going after ~3 seconds, Kimaki aborts it and force-sends your message, then resumes. So a message acts as an interrupt instead of waiting forever behind a long-running command. See Message Handling.

Setup

Run the CLI and follow the interactive prompts:

npx -y omomaki@latest

The setup wizard gives you two options:

• Gateway mode (default): uses Kimaki's pre-built Discord bot. No Discord Developer Portal setup needed. Click one install link, authorize the bot in your server, and you're running. Recommended.
• Self-hosted mode: create your own Discord bot at discord.com/developers. Takes 5-10 minutes. Useful if you want full control over the bot identity.

Both modes work identically after setup. Keep the CLI running; it's the bridge between Discord and your machine.

Commands

Kimaki ships a full set of slash commands and a CLI. The most common slash commands:

| Command | Description | |---|---| | /resume <session> | Resume a previous session (with autocomplete) | | /abort | Stop the current running session | | /model | Change the AI model for this channel or session | | /agent | Change the agent for this channel or session | | /login | Authenticate a provider (OAuth subscription or API key) | | /queue <message> | Queue a message to send after the current response finishes | | /btw <prompt> | Fork context into a new thread to ask a side question | | /new-worktree <name> | Move the session into an isolated git worktree | | /merge-worktree | Merge the worktree branch back into the default branch | | /diff | Generate a shareable diff URL | | /share | Generate a public URL to share the current session |

See the full Commands reference for every slash command and CLI subcommand.

Access Control

Kimaki checks Discord permissions before processing any message. Users need one of:

• Server Owner
• Manage Server permission
• Administrator permission
• "Kimaki" role — create a role with this name (case-insensitive) and assign it to trusted users

The "Kimaki" role is the recommended approach for team access. Messages from users without any of these are ignored.

• Blocking access: create a role named "no-kimaki" (case-insensitive) to block specific users, even server owners.
• Multi-agent orchestration: other Discord bots are ignored by default. Assign the "Kimaki" role to another bot to let it trigger Kimaki sessions.

Best Practices

• Create a dedicated Discord server for your agents. This keeps coding sessions separate and gives you full control over permissions.
• Use the "Kimaki" role for team access.
• Send long prompts as file attachments. Tap the plus icon and use "Send message as file" for longer prompts. Kimaki reads file attachments as your message.

Troubleshooting

If sessions stop responding, fail to start, or the bot behaves unexpectedly, run /restart-opencode-server in any channel. This restarts the backend agent runtime while keeping the bot connected to Discord. It fixes most transient issues.

If the problem persists, or if the issue is with the bot itself (crashes, messages not picked up, threads not created), run /upgrade-and-restart to update Kimaki to the latest version and do a full restart.

See the full Troubleshooting guide.

Advanced Topics

• Channels & Threads: the orchestration model in depth
• Models & Subscriptions: use your Claude and Codex subscriptions
• CI & Automation: programmatic sessions, GitHub Actions, per-session permissions
• Scheduled Tasks: cron and one-time tasks, email digests
• Advanced Setup: multiple instances, multiple Discord servers
• Docker: run Kimaki on a VPS
• Internals: how Kimaki works under the hood