Stop Coding Alone! Control AI Agents From Discord With Kimaki

What if your entire development team could orchestrate AI coding agents without leaving Discord? No more context switching. No more "hey, can you check if the build passed?" No more solitary terminal sessions where only you witness the magic—or the meltdown.

Here's the brutal truth: most developers are still coding like it's 2010. They open their IDE, open a terminal, open Slack, open email, and fracture their attention into a dozen shards. Meanwhile, a quiet revolution is happening. Teams are moving their entire AI-assisted development workflow into Discord, where collaboration is native, async is effortless, and every coding session becomes a searchable, shareable thread.

Kimaki is the bridge between that chaotic reality and the future of collaborative AI development. Born from the mind of developer remorses, this open-source Discord bot transforms your server into a mission control center for OpenCode coding agents. Send a message in a channel, and an AI agent starts editing code on your machine—while your entire team watches, contributes, and learns.

Ready to stop coding alone? Let's dive deep into why Kimaki is the secret weapon top development teams are deploying right now.

What is Kimaki? The Jarvis Your Team Actually Needs

Kimaki is a Discord bot that creates a seamless, bidirectional connection between your Discord server and OpenCode—a powerful AI coding agent in the same lineage as Claude Code. But calling it a "bot" undersells what it actually does. Kimaki is infrastructure for collaborative AI development.

The project was created by remorses, a developer known for building tools that eliminate friction between where teams communicate and where work actually happens. Kimaki's tagline says it all: "Iron Man's Jarvis for coding agents, inside Discord."

Here's the architectural elegance: each Discord channel maps to a project directory on your local machine. Each session spins up as a thread within that channel. When you type "refactor the auth module to use JWT tokens," Kimaki doesn't just echo your message—it launches an OpenCode session that reads your codebase, proposes changes, runs tests, and reports back in real-time. Your teammates see the entire thought process, can jump in with follow-ups, and even fork the session from any point.

Why is Kimaki trending now? Three forces converged:

1. AI coding agents matured—OpenCode, Claude Code, and similar tools can now handle complex, multi-file refactoring with reliability.
2. Remote/async development normalized—Teams need persistent, searchable records of decisions, not ephemeral Zoom calls.
3. Discord evolved beyond gaming—It's now the default community platform for developers, with superior thread mechanics and permission systems.

Kimaki rides all three waves. And unlike walled-garden solutions, it's fully open-source, self-hostable, and free.

Key Features That Separate Kimaki From Everything Else

Let's dissect what makes Kimaki not just functional, but transformational for team-based AI development.

Native Discord Integration, Not a Hack

Kimaki doesn't bolt a chat UI onto your IDE or force you into yet another web app. It lives where your team already communicates. Threads become sessions. Channels become projects. Reactions become approvals. This isn't superficial—it's deep structural integration that respects how teams actually work.

Voice-to-Code Pipeline

Record a voice message in Discord. Kimaki transcribes it using Google's Gemini API, but here's the critical detail: the transcription uses your project's file tree for accuracy. It recognizes function names, file paths, and domain-specific terminology you mention. Say "update the handleOAuthCallback in auth.ts" and it gets the spelling right. This isn't generic speech-to-text; it's context-aware transcription.

Granular Permission System

Security isn't an afterthought. Kimaki implements a layered access model:

• Server owners and administrators have full access
• Create a "Kimaki" role for trusted team members
• Create a "no-kimaki" role to block anyone—even server owners
• Other bots are ignored unless explicitly granted the Kimaki role

This means you can safely add Kimaki to existing servers without chaos.

Persistent Memory Across Sessions

Kimaki reads a MEMORY.md file from your project root at every session start. The AI can update this file to store learnings, architectural decisions, and context worth preserving. Imagine never having to re-explain your project's conventions to the AI again. The memory compounds.

Session Management Superpowers

• Resume any previous session with autocomplete
• Fork from any message to explore alternative approaches
• Share public URLs for external collaboration
• Queue follow-up messages while the AI is still working
• Undo/Redo assistant messages with full file change reversion

CI & Automation Bridge

Kimaki's CLI supports programmatic session triggering. Integrate with GitHub Actions, schedule tasks, or trigger sessions from other tools. The send command turns Discord into both a human interface and an API endpoint.

Use Cases: Where Kimaki Absolutely Dominates

1. Distributed Team Pair Programming

Your senior engineer in Berlin, junior in São Paulo, and AI agent on your server. They share a Discord channel linked to the project. The junior asks "how does our error handling work?" The AI explores the codebase, explains the pattern, and proposes a refactor—all in a thread the entire team can follow asynchronously. No timezone synchronization required.

2. On-Call Incident Response

3 AM. Production is down. The on-call engineer opens Discord on their phone, drops into the incident channel, and tells Kimaki: "check the last deployment's database migrations, look for locking issues." The AI investigates while the engineer commutes. By the time they're at their laptop, they have a full analysis and proposed fix. Voice messages make this possible from anywhere.

3. Code Review & Knowledge Transfer

Instead of static PR comments that miss context, use Kimaki threads for interactive review. "Explain why this uses a semaphore instead of a mutex." The AI analyzes, explains, and updates MEMORY.md with the decision rationale. Future team members inherit the reasoning, not just the code.

4. Rapid Prototyping & Spikes

Need to evaluate three architectural approaches? Fork the session from your baseline message. Explore option A in one thread, option B in another. Compare results. Merge the winner. Kimaki makes exploration cheap and visible.

5. Accessibility & Inclusion

Voice messages lower barriers for developers with motor impairments or those who process information better audibly. The context-aware transcription means spoken technical language translates accurately to executed code.

Step-by-Step Installation & Setup Guide

Getting Kimaki running takes about 60 seconds with the recommended path. Here's the complete walkthrough.

Prerequisites

• Node.js 18+ installed
• A Discord server where you have admin rights
• An OpenCode installation on your machine
• (Optional) Gemini API key for voice transcription

Step 1: Launch the CLI

# Run without installing permanently
npx -y kimaki@latest

This downloads and executes the latest Kimaki CLI, which starts an interactive setup wizard.

Step 2: Choose Your Mode

The wizard presents two options:

Gateway Mode (Recommended)

• Uses Kimaki's pre-built Discord bot
• No Discord Developer Portal configuration
• Click one install link, authorize in your server
• Total setup time: ~1 minute

Self-Hosted Mode

• Create your own bot at discord.com/developers/applications
• Full control over bot identity and branding
• Takes 5-10 minutes
• Useful for enterprise environments with strict vendor policies

Step 3: Link Projects to Channels

After bot installation, add your existing OpenCode projects:

# Add a project directory as a Discord channel
npx -y kimaki project add /path/to/your/project

Or create new projects directly:

# Create new project folder and Discord channel
npx -y kimaki create-new-project my-new-service

Step 4: Configure Permissions

In your Discord server:

1. Create a role named "Kimaki" (case-insensitive)
2. Assign it to team members who should trigger AI sessions
3. Optionally create "no-kimaki" to block specific users

Step 5: Keep the Bridge Running

The CLI process is the bridge between Discord and your machine. Run it in a persistent session:

# Using tmux for persistence
tmux new -s kimaki
npx -y kimaki@latest

# Or use a process manager like pm2
pm2 start "npx -y kimaki@latest" --name kimaki

Step 6: Configure Your AI Model

Edit your project's opencode.json:

{
  "model": "anthropic/claude-sonnet-4-20250514"
}

Supported formats: provider/model-name. Popular options include anthropic/claude-opus-4-20250514, openai/gpt-4o, and google/gemini-2.5-pro.

REAL Code Examples From the Repository

Let's examine actual code patterns from Kimaki's documentation, with detailed explanations of how they work in practice.

Example 1: The Core Architecture (ASCII Diagram)

┌─────────────┐         ┌─────────────────────────────────────────┐
│   Discord   │         │  Your Machine                           │
│             │         │                                         │
│  You send a │─────────▶  Kimaki CLI ──▶ OpenCode Server ──▶ AI  │
│  message in │         │                    │                    │
│  a channel  │◀────────│     responses      ▼                    │
│             │         │              Reads, edits, and          │
└─────────────┘         │              runs commands in           │
                        │              your project directory     │
                        └─────────────────────────────────────────┘

What's happening here: This diagram reveals Kimaki's elegant simplicity. Your Discord message travels through three layers: the Kimaki CLI (the bridge), the OpenCode Server (the agent runtime), and finally the AI model itself. Responses flow backward through the same path. The critical insight: your code never leaves your machine. The AI operates on your local filesystem via the OpenCode Server, with Kimaki merely ferrying messages and results. This is fundamentally different from cloud-based coding assistants that require code upload.

Example 2: Model Configuration in opencode.json

{
  "model": "anthropic/claude-sonnet-4-20250514"
}

Deep dive: This configuration file sits in your project root and controls AI behavior. The provider/model-name format is intentionally flexible—you're not locked to one vendor. Switch to openai/gpt-4o for tasks where you need broader knowledge, or google/gemini-2.5-pro for multimodal capabilities. The /model slash command overrides this per-channel or per-session, enabling A/B testing of models on identical prompts. For teams, this means empirical model selection: run the same refactoring task through Claude and GPT-4, compare outputs, and standardize on the winner.

Example 3: Programmatic Session Triggering

# Start the bot (interactive setup on first run)
npx -y kimaki@latest

# Add a project directory as a Discord channel
npx -y kimaki project add [directory]

# Start a session programmatically
npx -y kimaki send --channel <channel-id> --prompt 'your prompt'

# Upgrade kimaki and restart
npx -y kimaki upgrade

Practical implementation: The send command is where Kimaki transcends "chatbot" and becomes infrastructure. Imagine a GitHub Action that triggers on PR creation:

# .github/workflows/kimaki-review.yml
name: AI Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Request Kimaki Review
        run: |
          npx -y kimaki send \
            --channel "${{ secrets.KIMAKI_REVIEW_CHANNEL }}" \
            --prompt "Review PR #${{ github.event.pull_request.number }} for security issues and performance anti-patterns. Focus on the changed files."

This pattern automates expertise distribution: every PR gets AI review without human scheduling, with results posted to a shared Discord channel for team visibility.

Example 4: Queue System for Complex Workflows

# Explicit queue command
/queue implement rate limiting with Redis, then add tests

# Inline queue shorthand (append . queue to any message)
Refactor the user service to use dependency injection. queue

Why this matters: AI coding agents can take minutes for complex tasks. Without queuing, you'd either wait idle or risk context-switching away and forgetting your follow-up. Kimaki's queue system lets you stack instructions like a todo list, maintaining your creative momentum. The . queue shorthand is particularly clever—it's invisible to the AI (stripped before processing), but signals Kimaki to hold the message. This is UX design that respects developer cognition.

Example 5: Session Forking and Sharing

# Generate public URL to share session
/share

# Fork from a previous message to explore alternative
/fork

Collaboration pattern: You're debugging with Kimaki and reach a decision point: "should we optimize for latency or memory?" Instead of committing to one path, use /fork to create a branch in the conversation from that message. Explore the latency optimization in one thread, memory in another. Share promising forks with specialists via /share public URLs. This brings git-style branching to AI conversations—a paradigm shift from linear chatbot interactions.

Advanced Usage & Best Practices

Dedicated Server Architecture

Create a separate Discord server exclusively for Kimaki. This eliminates permission complexity, keeps coding noise out of community servers, and gives you clean channel-to-project mapping. Name channels after repositories: #api-service, #ml-pipeline, #infrastructure.

Memory-Driven Development

Invest in your MEMORY.md. Structure it as living documentation:

# Project Memory

## Architecture Decisions
- ADR-001: Use event sourcing for order history (2024-01-15)
- ADR-002: PostgreSQL↗ Bright Coding Blog over MongoDB for transactional consistency (2024-02-03)

## Conventions
- All API errors use RFC 7807 Problem Details
- Database migrations must be reversible
- Test files mirror source structure under `__tests__/`

## Known Issues
- Rate limiter has 2% false positive on burst traffic (see #447)

The AI reads this at every session start. The quality of your memory file directly impacts the quality of AI assistance.

Git Worktree Integration

# Create isolated branch workspace
/new-worktree feature/redis-cache

# Merge when complete
/merge-worktree

This leverages git worktrees for parallel AI sessions on different branches without stashing or context switching. Each worktree gets its own Discord channel, enabling true parallel development streams.

Screen Sharing for Visual Debugging

# Share screen via browser-accessible VNC tunnel
/screenshare
# Auto-stops after 1 hour for security

When the AI asks "what does the error dialog look like?" or you need to demonstrate a UI bug, this eliminates screenshot friction. The VNC tunnel is reverse-proxied through Kimaki's infrastructure—no firewall configuration needed.

Comparison With Alternatives

The verdict: Kimaki wins where team context, async workflows, and infrastructure control matter. Standalone tools optimize for individual speed; Kimaki optimizes for organizational leverage.

FAQ: What Developers Actually Ask

Is my code sent to Discord or third-party servers?

No. Your code never leaves your machine. Discord only sees messages and responses. The OpenCode server runs locally, with AI API calls going directly to your chosen provider (Anthropic, OpenAI, Google). Kimaki's hosted component is just the Discord gateway; all code execution is local.

Can I use Kimaki with multiple projects simultaneously?

Absolutely. Each Discord channel links to a distinct project directory. Run /add-project for existing projects or /create-new-project for new ones. There's no practical limit—organize channels by project, team, or even branch (with worktrees).

What happens if the CLI disconnects?

Active sessions pause and resume when the CLI reconnects. For production reliability, run Kimaki under a process manager like pm2 or systemd. The SQLite-backed state means no session data is lost on temporary disconnections.

Do I need a paid Discord plan?

No. Kimaki works with free Discord servers. The only potential costs are AI API usage (pay-per-token to Anthropic/OpenAI/Google) and optional Gemini API for voice transcription.

Can Kimaki work with my existing OpenCode configuration?

Yes. Kimaki is a thin layer over OpenCode. Your opencode.json, custom tools, and MCP servers work unchanged. Kimaki adds Discord integration without replacing OpenCode's core capabilities.

How does voice transcription handle technical jargon?

Kimaki sends your project's file tree to Gemini as context for transcription. This means function names, variable names, and file paths you mention are recognized with dramatically higher accuracy than generic speech-to-text. Say "update getUserByEmail in auth/repository.ts" and it just works.

Is there a limit to queued messages?

The queue is unbounded by default, but practical limits apply (Discord message history, API rate limits). Use /clear-queue if you need to reset. The . queue shorthand is processed client-side before sending, so it doesn't consume API tokens.

Conclusion: The Future of Coding Is Collaborative, Async, and AI-Native

Kimaki isn't just a Discord bot. It's a fundamental reimagining of where and how development happens. By collapsing the distance between team communication and code execution, it eliminates the friction that kills flow states and buries institutional knowledge in private terminal sessions.

The teams that adopt Kimaki today are building a competitive moat. Their AI-assisted sessions are visible, searchable, and forkable. Their architectural decisions accumulate in MEMORY.md instead of evaporating in 1:1 calls. Their onboarding time drops because every past session is a tutorial waiting to be discovered.

This is the Jarvis moment—not a single genius with a private AI, but entire teams augmented by shared, persistent, collaborative intelligence.

The setup takes 60 seconds. The transformation is permanent.

Install Kimaki now and turn your Discord server into the most powerful development environment your team has ever used. Star the repo, join the community, and start coding like the future already arrived—because with Kimaki, it has.

Found this guide valuable? Share it with your team, star the repository, and follow remorses for more tools that eliminate developer friction.