# Kimaki for Discord: OpenCode Projects, Sessions, and Local Coding Work > Kimaki maps Discord channels to local project directories and threads to OpenCode sessions, turning Discord into a control surface for coding agents. It is suited to developers who want OpenCode access from Discord, with subscriptions, queueing, worktrees, and remote review features. **remorses/kimaki** — all opencode features deeply integrated inside Discord. each project is a channel. each session a thread - Repository: https://github.com/remorses/kimaki - Website: https://kimaki.dev - Stars: 1,449 · Forks: 120 - Language: TypeScript - License: MIT - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/remorses-kimaki ## Why Kimaki Exists for OpenCode Users Kimaki solves a specific remote-control problem: how to start and manage OpenCode coding work from Discord without flattening every project and task into one conversation. The repository describes it as a collaborative agent orchestrator, and its central model is straightforward. A Discord channel represents a project. That channel is linked to a project directory on the user's machine. A Discord thread represents one OpenCode session. A message sent in the session asks the agent to work in the linked directory, where it can read files, edit code, and run commands. This structure targets developers who want to begin coding-agent work from a phone, continue it from a desktop, or return to a task without searching through unrelated messages. The separation matters because project context changes when the directory changes, while session context changes when the task changes. Kimaki keeps those boundaries visible in Discord's own interface. The intended user is therefore someone with a local development machine and an OpenCode 2 setup, rather than someone looking for a hosted SaaS coding assistant. Kimaki connects to OpenCode 2's background service, so the local machine remains part of the execution model. The project description also says that Kimaki is intended to expose every model supported by OpenCode, including access through existing Claude Pro/Max and ChatGPT/Codex subscriptions after authentication. ## How Channels and Threads Reach the Local Agent The repository layout and README describe a bridge between Discord objects and local development state. During onboarding, the agent asks which projects to use and creates a Discord channel for each one. The channel mapping points to a directory such as `/code/web-app`, `/code/api`, or `/code/docs`. The README's diagram then shows that directory feeding an OpenCode session associated with a thread. Messages travel through that mapping. An ordinary message becomes input for the relevant OpenCode session. The agent works inside the project directory and sends replies back into the thread. The README states that a message sent during an active run interrupts it, cancels pending questions, and permits the new request to take control. That makes the interface conversational, but it also means message sequencing has operational meaning rather than being just chat history. Kimaki does not stop at the channel and thread mapping. The README documents queueing, where a message ending in `. queue` is sent after the current run finishes. It also documents `btw`, which forks the current context into a new thread so a clarifying question can proceed in parallel while the original run continues. Worktrees provide a separate isolation boundary through `/new-worktree`, while `/merge-worktree` can merge commits into a local branch with rebase or squash. These features make Discord the management layer around an OpenCode run, not merely a place to display its answer. ## Installing Kimaki and Starting a Discord Project The README's Quick Start is a guided installation through the npm package runner. The command below starts the Kimaki CLI, which the documentation says walks the user through bot installation and onboarding. ```bash npx -y kimaki@latest ``` The documented setup flow expects Kimaki to open an onboarding thread after the Discord bot is installed to a server. In that thread, the agent asks which projects to configure and creates a channel for each project. A user should expect to connect a local project directory rather than merely paste a remote repository into Discord. Kimaki requires OpenCode 2. If OpenCode is not installed, the README says Kimaki installs it with the following command. If OpenCode 1 is present, the same command is documented for installing OpenCode 2 first. ```bash curl -fsSL https://opencode.ai/v2/install | bash ``` The README does not document a separate Windows installation command or a manual Discord token setup flow, so this article does not infer either. The repository's package metadata identifies the implementation as TypeScript and includes `pnpm` workspace packages, including `kimaki`, `opencode-kimaki-plugin`, and related automation packages. That layout suggests a multi-package project rather than a single isolated script, although the user-facing Quick Start is the documented entry point. ## Subscriptions, Models, and Discord Commands Kimaki relies on OpenCode for provider support. The README says Kimaki gives users access to every model OpenCode supports, including Anthropic, OpenAI, Google, and other providers. It specifically describes using existing Claude Pro/Max and ChatGPT/Codex subscriptions instead of paying per token. The documented flow starts with `/login`, selecting a provider, choosing OAuth, and authenticating with the subscription. Login data is stored by OpenCode, according to the README. The stated goal is that the same accounts work in Discord and in the OpenCode TUI. Kimaki adds the Claude Pro/Max login to OpenCode through a small plugin. This is an integration detail with operational consequences. Subscription authentication and provider configuration remain tied to OpenCode's own login state, while Discord handles the conversation and command surface. OpenCode commands and skills can become Discord slash commands. The README also documents quick agent switching through commands such as `/-agent`, changing the model or system prompt. Since Kimaki uses the OpenCode 2 background service, `/session-id` prints the command needed to open the same session in the OpenCode TUI. That path can be useful when a conversation needs a more direct local interface, although the README does not promise identical behavior for every Discord-specific orchestration feature in the TUI. ## Review, Queuing, Isolation, and Local Execution Kimaki includes several project-specific workflows that go beyond starting an agent. The diff viewer uses `/diff` to generate a shareable URL for reviewing changes from a phone or browser. This shifts code review away from copying patch text into chat, although access to that URL and the permissions around it are not described in the README. Queued messages are useful when a developer needs to issue a follow-up before the current run ends. A message ending in `. queue` waits until the current run finishes, and the README says the queued text can be edited later. The `btw` command takes a different approach: it forks context into a parallel thread. The distinction is important. Queueing preserves a requested sequence. `btw` creates a second session from the existing context. Worktrees address a separate risk. `/new-worktree` starts an isolated Git worktree so the main checkout is not touched by that session. `/merge-worktree` then merges commits into a local branch, with rebase or squash options. Kimaki also documents shell commands by prefixing a message with `!`; that command runs in the session folder. This is convenient for an agent-oriented workflow, but it means the Discord client is connected to an execution environment with local shell access. The README does not document a permission prompt, command allowlist, audit export, or Discord role model, so those controls should not be assumed. Image and file attachments, voice transcription using the project file tree, voice calls, and public tunnels extend the same local-agent model. The tunnel feature is documented as exposing a local development server to a public URL. The README does not explain tunnel authentication or cleanup behavior, which are important deployment details for any team evaluating remote access. ## Maintenance Signals and Repository Boundaries The repository is not archived, and its last push was on 2026-10-16. Recent releases include `kimaki@1.0.0`, `@kimaki/plugin-fallback@0.1.0`, and `@kimaki/automode@1.0.0`, all dated 2026-10-12. These are repository and release facts, not evidence that every integration has reached stable maturity. The release names indicate that Kimaki is published alongside plugin and automation packages rather than as an isolated Discord bot. The root `package.json` names `pnpm@9.15.9` as its package manager. It defines a root test script that delegates to the `kimaki` package, and a prepare script that builds selected workspace packages, including `errore`, `libsqlproxy`, `opencode-injection-guard`, `traforo`, `fly-admin`, `profano`, `sigillo`, and `discord-slack-bridge`. The repository also includes `opencode-fallback`, `opencode-injection-guard`, `opencode-kimaki-plugin`, and other directories related to OpenCode integration. That structure suggests more moving parts than the Quick Start reveals. The project is licensed under MIT according to the repository description. That is a permissive license identifier, but it does not answer operational questions about Discord terms, provider subscriptions, local shell access, generated code, or the handling of credentials. The README does not document a rollback procedure, supported upgrade path, database backup process, or compatibility policy beyond the OpenCode 2 requirement. Those omissions matter more to adoption than the release date because Kimaki coordinates a hosted chat service with a local development environment. ## Conclusion Developers who already use OpenCode 2 and want a mobile-friendly Discord control surface should evaluate Kimaki first against their project layout, authentication needs, and tolerance for running a local agent on their machine. Teams that need a formal audit trail, centralized access controls, or a workflow outside Discord should verify those requirements before adopting it. The first project-specific check is whether each planned project can be mapped cleanly to a local directory and each task to a separate Discord thread. ## FAQ ### How do I install Kimaki? The README documents starting the guided CLI with `npx -y kimaki@latest`. Kimaki then installs the Discord bot, opens an onboarding thread, and asks which local projects to configure. ### Does Kimaki require OpenCode 2? Yes. The README says Kimaki needs OpenCode 2. If OpenCode is missing, Kimaki documents installing it with `curl -fsSL https://opencode.ai/v2/install | bash`; the same command is given for replacing OpenCode 1. ### Can Kimaki use my ChatGPT or Claude subscription? The README says it can use existing ChatGPT/Codex and Claude Pro/Max subscriptions through OpenCode authentication. The documented command is `/login`, followed by provider selection and OAuth authentication. ## Sources - [License: MIT](https://github.com/remorses/kimaki/blob/main/LICENSE) - [Project website](https://kimaki.dev) - [README](https://github.com/remorses/kimaki/blob/main/README.md) - [Releases](https://github.com/remorses/kimaki/releases) - [remorses/kimaki on GitHub](https://github.com/remorses/kimaki) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/remorses-kimaki