24/7 AI agent powered by Claude, running entirely on your desktop

No server setup. No cloud required. Just install the app and start working.

👉 User Guide - Complete setup and usage guide

KIRA = KRAFTON INTELLIGENCE ROOKIE AGENT

KIRA is an open-source project that repackages KRIS (KRAFTON Intelligence System)—an AI agent system successfully used internally at KRAFTON—into a "virtual coworker" concept that anyone can install and use as a standalone desktop application.

KIRA is an AI virtual coworker that runs as a desktop application. Once installed:

• 🤖 Chat in Slack: Natural conversations in DMs, channels, and threads
• 📧 Email Monitoring: Auto-extract tasks from Outlook emails
• 📝 Document Tracking: Monitor Confluence and Jira updates
• 🧠 Memory System: Automatically remembers conversations and project context
• 🔒 Privacy First: All data stays on your computer

🤖 Bot Mode

• Install on your computer
• Use your own Slack account or bot app
• Personal AI assistant that you manage
• Stops when your computer is off

👤 Virtual Employee Mode

• Install on a dedicated computer (or VM/server)
• Create a dedicated Slack account for the AI (e.g., "KIRA Kim")
• Runs 24/7 independently as a real team member
• Shared by the entire team

💡 KRAFTON Use Case: KRAFTON provides a dedicated company account and computer to run KIRA as a virtual employee, just like onboarding a new hire.

• macOS 10.15 or later
• Slack workspace (admin access required)
• Claude API key (Google Cloud Vertex AI)

Download the latest release:

https://kira.krafton-ai.com

Or build from source:

# Clone repository
git clone https://github.com/krafton-ai/kira.git
cd kira

# Install Python dependencies
uv sync

# Build Electron app
cd electron-app
npm install
npm run build

# Install the generated .dmg file
open dist/KIRA-*.dmg

Follow the detailed guide: Slack App Setup

1. Launch KIRA app
2. Enter Slack tokens in Settings
3. Configure bot information
4. Click "Save Settings" and "Start"

@KIRA Hello!

🎉 Done! You can now chat with KIRA.

kira/
├── app/                   # Python AI server
│   ├── main.py           # Server entry point
│   ├── cc_agents/        # AI agent modules
│   ├── cc_checkers/      # Proactive monitors (email, docs)
│   ├── cc_tools/         # MCP tool implementations
│   ├── cc_web_interface/ # Web interface (voice input)
│   └── config/           # Configuration files
│
├── electron-app/         # Electron desktop app
│   ├── main.js          # Electron main process
│   ├── renderer/        # UI (settings, logs)
│   └── dist/            # Build output (.dmg)
│
├── vitepress-app/       # Documentation site
│   ├── index.md         # Homepage
│   ├── getting-started.md
│   ├── setup/           # Setup guides
│   └── features/        # Features guide
│
└── README.md            # This file

KIRA uses a multi-agent pipeline where each agent has a specific role. This design enables cost optimization (simple tasks use lighter models) and clear separation of concerns.

┌─────────────────────────────────────────────────────────────┐
│  SLACK MESSAGE RECEIVED                                     │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  DEBOUNCING (2 sec)                                         │
│  - Merge consecutive messages from same user                │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  BOT CALL DETECTOR (Haiku)                                  │
│  - Determine if message requires bot response               │
│  - DM: Always respond                                       │
│  - Channel: Only when mentioned                             │
│  - Thread: Additional context analysis                      │
└─────────────────────────────────────────────────────────────┘
                 ↓                              ↓
    ┌────────────────────┐         ┌────────────────────────┐
    │  SIMPLE CHAT       │         │  OPERATOR              │
    │  (Haiku, no MCP)   │         │  (Opus, full MCP)      │
    │  - Quick responses │         │  - Complex tasks       │
    │  - Casual chat     │         │  - Tool execution      │
    └────────────────────┘         └────────────────────────┘
              ↓                              ↓
              └──────────────┬───────────────┘
                             ↓
              ┌────────────────────────────────┐
              │  MEMORY MANAGER (Sonnet)       │
              │  - Save conversation context   │
              │  - Organize into categories    │
              └────────────────────────────────┘

KIRA uses a hierarchical queue system to handle concurrent messages efficiently:

┌─────────────────────────────────────────────────────────────┐
│  CHANNEL QUEUES (per-channel)                               │
│  - 8 workers per channel                                    │
│  - Fast response for simple messages                        │
│  - Independent processing per channel                       │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  ORCHESTRATOR QUEUE (global)                                │
│  - 3 workers                                                │
│  - Heavy tasks requiring MCP tools                          │
│  - Prevents API rate limiting                               │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  MEMORY QUEUE (global)                                      │
│  - 1 worker (sequential)                                    │
│  - Ensures consistent file system writes                    │
│  - Prevents race conditions in memory storage               │
└─────────────────────────────────────────────────────────────┘

Why this design?

• Channel Queues: Users in different channels get fast responses without blocking each other
• Orchestrator Queue: Limits concurrent heavy tasks to prevent excessive CPU/memory usage
• Memory Queue: Single worker ensures no conflicts when writing to local memory files

• Chat: Natural conversations in Slack DMs, channels, and threads
• Task Execution: Search, document writing, email management, Jira/GitLab integration
• Memory System: Auto-remembers team info and project context
• Task Scheduling: Execute tasks at specific times

• Email Monitoring: Auto-check Outlook emails (5min interval)
• Confluence Tracking: Document update notifications (1hr interval)
• Jira Tracking: Monitor assigned issues (30min interval)

• Analyzes memory and proactively suggests needed tasks
• 7 intervention patterns (research, scheduling, documentation, drafting, connecting, predicting, routine)

• Perplexity (web search)
• DeepL (translation)
• Outlook (email)
• Confluence & Jira (Rovo MCP)
• GitLab (code repository)
• X (Twitter)
• Clova Speech (transcription, meeting notes)
• Playwright (browser automation)

# Python server (hot reload)
uv run python dev.py

# Electron app (separate terminal)
cd electron-app
npm start

# Build macOS installer
cd electron-app
npm run build

# Output: electron-app/dist/KIRA-*.dmg

# Run docs dev server
cd vitepress-app
npm install
npm run docs:dev

# Deploy to S3
npm run deploy

~/.kira/
├── config.env          # Environment variables
└── server.log          # Server logs

~/Documents/KIRA/       # FILESYSTEM_BASE_DIR
├── db/                 # SQLite databases
│   ├── waiting_answer.db
│   ├── confirm.db
│   ├── email_tasks.db
│   └── jira_tasks.db
└── memories/           # Memory (Markdown files)
    ├── channels/
    ├── projects/
    ├── users/
    ├── decisions/
    └── index.md

• ✅ All data stored locally
• ✅ External communication only with Claude API and enabled MCP servers
• ✅ config.env file has owner-only read/write permissions
• ⚠️ Never share API keys or tokens

For complete setup and usage guides, visit KIRA Documentation

• Getting Started
• Setup Guides
• Features Guide

Contributions are welcome!

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Open a Pull Request

Apache License 2.0 - See LICENSE for details.

KIRA is a fully local, on-premise AI agent that runs entirely on your device.

KRAFTON does NOT collect, store, or process any user data. All data and memory are stored locally on your computer and under your sole control.

You are responsible for managing your own Claude API key and usage, including any usage fees and security.

KRAFTON is not responsible or liable for any data processed through, or any actions taken by, third-party services (e.g., Slack, Outlook, Confluence, Jira, GitLab, Anthropic Claude API) that you choose to integrate with KIRA. By using KIRA, you agree to comply with all applicable third-party terms, including Anthropic's Claude API Terms of Service.

This software is provided "AS IS", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall KRAFTON or any contributor be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.

The names KRAFTON, KIRA, and associated logos are trademarks of KRAFTON, Inc. Permission to use these trademarks is not granted by the open-source license and requires separate written permission.

KIRA incorporates open-source libraries under MIT, Apache-2.0, BSD, ISC, MPL-2.0, and other compatible licenses. For a complete list of dependencies and their licenses, please refer to the THIRD-PARTY-NOTICES.md file.

• Built with Claude by Anthropic
• Powered by Electron
• Documentation by VitePress

Made with ❤️ by KRAFTON AI