Lightweight AI gateway daemon orchestrating Claude Code, Codex, and Gemini CLI.

Jinn Web Dashboard

Jinn is an open-source AI gateway that wraps the Claude Code CLI, Codex SDK, and Gemini CLI behind a unified daemon process. It routes tasks to AI engines, manages connectors like Slack, and schedules background work via cron. Jinn is a bus, not a brain.

Most AI agent frameworks reinvent the wheel — custom tool-calling loops, brittle context management, hand-rolled retry logic. Then they charge you per API call on top.

Jinn takes a different approach. It wraps battle-tested professional CLI tools (Claude Code, Codex, Gemini CLI) and adds only what they're missing: routing, scheduling, connectors, and an org system.

Because Jinn uses Claude Code CLI under the hood — Anthropic's own first-party tool — it works with the 200ドル/mo Max subscription. No per-token API billing. No surprise 500ドル invoices. Flat rate, unlimited usage.

Other frameworks can't do this. Anthropic banned third-party tools from using Max subscription OAuth tokens in January 2026. Since Jinn delegates to the official CLI, it's fully supported.

Jinn adds zero custom AI logic. No prompt engineering layer. No opinions on how agents should think. All intelligence comes from the engines themselves — Claude Code already handles tool use, file editing, multi-step reasoning, and memory. Jinn just connects it to the outside world.

When Claude Code gets better, Jinn gets better — automatically.

• 🔌 Triple engine support — Claude Code CLI + Codex SDK + Gemini CLI
• 💬 Connectors — Slack (threads + reactions), WhatsApp (QR auth), Discord (bot)
• 📎 File attachments — drag & drop files into web chat, passed through to engines
• 📱 Mobile-responsive — collapsible sidebar and mobile-friendly dashboard
• ⏰ Cron scheduling — hot-reloadable background jobs
• 👥 AI org system — departments, ranks, managers, employees, task boards
• 🌐 Web dashboard — chat, org map, kanban, cost tracking, cron visualizer
• 🔄 Hot-reload — change config, cron, or org files without restarting
• 🛠️ Self-modification — agents can edit their own config, skills, and org at runtime
• 📦 Skills system — reusable markdown playbooks that engines follow natively
• 🏢 Multi-instance — run multiple isolated Jinn instances side by side
• 🔗 MCP support — connect to any MCP server
• ⏱️ Session timeouts — kill runaway sessions after configurable duration (global or per-employee)
• 🤝 Synchronous employee invocation — invoke_employee MCP tool for inline sub-tasks
• 🗜️ Session compaction — auto-summarize old messages when token count exceeds threshold
• 🪝 Hook pipeline — pre/post session and tool observation hooks (shell or JS modules)

npm install -g jinn-cli
jinn setup
jinn start

Or install via Homebrew:

brew tap hristo2612/jinn https://github.com/hristo2612/jinn
brew install jinn
jinn setup
jinn start

Then open http://localhost:7777.

 +----------------+
 | jinn CLI |
 +-------+--------+
 |
 +-------v--------+
 | Gateway |
 | Daemon |
 +--+--+--+--+---+
 | | | |
 +--------------+ | | +--------------+
 | | | |
 +-------v-------+ +------v------+ +-----------v---+
 | Engines | | Connectors | | Web UI |
 |Claude|Codex|Gem| | Slack|WA|DC | | localhost:7777|
 +----------------+ +-------------+ +---------------+
 | |
 +-------v-------+ +------v------+
 | Cron | | Org |
 | Scheduler | | System |
 +---------------+ +-------------+

The CLI sends commands to the gateway daemon. The daemon dispatches work to AI engines (Claude Code, Codex, Gemini CLI), manages connector integrations, runs scheduled cron jobs, and serves the web dashboard.

Jinn reads its configuration from ~/.jinn/config.yaml. An example:

gateway:
 port: 7777
engines:
 claude:
 enabled: true
 codex:
 enabled: false
sessions:
 maxDurationMinutes: 30 # kill sessions that run longer than this
connectors:
 slack:
 enabled: true
 app_token: xapp-...
 bot_token: xoxb-...
cron:
 jobs:
 - name: daily-review
 schedule: "0 9 * * *"
 task: "Review open PRs"
mcp:
 gateway:
 enabled: true # expose gateway tools to employees via MCP
org:
 agents:
 - name: reviewer
 role: code-review

Sessions can be time-limited at two levels. The global sessions.maxDurationMinutes in config.yaml applies to all sessions. Per-employee overrides take precedence:

# org/historian.yaml
maxDurationMinutes: 10 # override global limit for this employee

When a session exceeds its limit, the engine process is killed via SIGTERM. If the engine hasn't started yet (session queued), it is marked as interrupted directly.

Long-running sessions accumulate messages that can overflow transcript syncs and bloat API responses. Compaction automatically summarizes older messages when the estimated token count exceeds a threshold:

sessions:
 compaction:
 enabled: true
 maxEstimatedTokens: 50000 # trigger compaction above this
 preserveRecentMessages: 6 # keep last N messages verbatim

Compacted messages are replaced with a single structured summary (role: "summary") containing scope, recent user requests, key topics, pending work, and a timeline. Re-compaction merges with existing summaries. The compacted_at field on sessions tracks when compaction last ran.

Hooks provide observable middleware at session and tool-use boundaries. Define hooks in config.yaml:

hooks:
 preSession: # before engine.run() — can modify prompt or abort
 - type: shell
 command: ./hooks/inject-context.sh
 blocking: true
 timeoutMs: 5000
 postSession: # after engine.run() — fire-and-forget
 - type: module
 path: ./hooks/cost-logger.mjs
 onToolUse: # when engine starts a tool — fire-and-forget
 - type: module
 path: ./hooks/tool-usage-tracker.mjs
 onToolResult: # when a tool finishes — fire-and-forget
 - type: shell
 command: ./hooks/audit.sh

Hook types:

• shell — spawns a subprocess, pipes JSON payload to stdin, reads stdout. Exit 0 = allow, exit 2 = deny/abort.
• module — dynamically imports a JS/TS module with a default async function export. Cached after first load.

Hook events:

Fire-and-forget hooks are concurrency-limited (max 5 concurrent) and never crash the session on failure.

The invoke_employee MCP tool lets employees call other employees inline and get the result back synchronously — useful for fact-checks, lookups, and data formatting without the complexity of async child sessions:

invoke_employee(employee: "historian", prompt: "When was GE14?")
→ { status: "idle", result: "GE14 was held on 9 May 2018...", durationMs: 16045 }

Timeout is clamped to 600s max. Orphaned child sessions are automatically interrupted on timeout.

jinn/
 packages/
 jimmy/ # Core gateway daemon + CLI
 web/ # Web dashboard (frontend)
 turbo.json # Turborepo build configuration
 pnpm-workspace.yaml
 tsconfig.base.json

git clone https://github.com/hristo2612/jinn.git
cd jinn
pnpm install
pnpm setup # one-time: builds all packages and creates ~/.jinn
pnpm dev # starts gateway + Next.js dev server with hot reload

Open http://localhost:3000 to use the web dashboard.

pnpm dev starts two servers behind the scenes: the gateway daemon on :7777 (API, WebSocket, connectors) and the Next.js dev server on :3000 (web dashboard with hot reload). Next.js rewrites proxy /api/* and /ws requests from :3000 to the gateway, so you only need to visit :3000. The gateway auto-restarts when you edit backend source files via Node's built-in --watch mode. To use a non-default gateway port, set GATEWAY_PORT=<port> before running pnpm dev.

Prerequisites: Node.js 22+, pnpm 10+, and the Claude Code CLI (npm install -g @anthropic-ai/claude-code).

Jinn is under active development. Here's what's coming:

• Discord — bot integration via discord.js
• WhatsApp — Baileys-based connector with QR auth and media support
• Telegram — bot API connector with polling and user allowlist
• iMessage — macOS-native via AppleScript bridge
• Email — IMAP/SMTP connector for inbox monitoring and replies
• Webhooks — generic inbound/outbound HTTP webhooks

• Gemini CLI — Google's Gemini as a third engine option
• Local models — Ollama / llama.cpp integration for offline use
• Engine fallback chains — auto-failover to Codex when Claude is rate-limited

• Agent-to-agent messaging — direct communication without board intermediary
• Shared memory — cross-session knowledge that persists across employees
• Performance tracking — employee performance archive with task success rates and quality scoring
• Auto-promotion — promote employees to manager based on track record

• Mobile-responsive UI — collapsible sidebar, mobile-friendly chat
• Live streaming — watch agent responses stream in real-time
• File attachments — drag & drop files into chat with engine passthrough
• Approval workflows — approve/reject agent actions from the dashboard
• Cost analytics — per-employee cost tracking via hook pipeline (costs.jsonl)

• Plugin system — installable plugins for common integrations (Stripe, Linear, GitHub)
• Session timeouts — configurable maxDurationMinutes per-employee or global
• Session compaction — auto-summarize old messages to bound context growth
• Hook pipeline — pre/post session and tool observation middleware
• REST API auth — API keys for secure remote access
• Multi-user support — team access with roles and permissions
• Docker image — one-command deployment with docker run

• Skills marketplace — browse and install community skills from skills.sh
• Skill versioning — pin skill versions, auto-update with changelogs
• Skill templates — scaffolding for common patterns (blog pipeline, support inbox, etc.)

Want to suggest a feature? Open an issue.

The web dashboard UI is built on components from ClawPort UI by John Rice, adapted for Jinn's architecture. ClawPort provides the foundation for the theme system, shadcn components, org map, kanban board, cost dashboard, and activity console.

MIT

See CONTRIBUTING.md for guidelines on setting up your development environment and submitting pull requests.