Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
npx -y [email protected]Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
claude mcp add jinn-cli -- npx -y jinn-cli@0.33.4รันในเทอร์มินัล
{ "mcpServers": { "jinn-cli": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดจากผู้เผยแพร่
Agent CLIs are powerful alone. Jinn gives them shared structure, ownership, and history.
PATH and adds no AI logic. Better engines make Jinn better automatically.Lightweight AI gateway daemon orchestrating Claude Code, Codex, Grok, and Antigravity CLI
Jinn is beta. It works today and moves fast; read the upgrade notes when you bump versions.
Prerequisites: Node.js 22 or newer (the repository pins 24.13.0 in
.nvmrc), and at least one agent CLI installed and signed in. Jinn orchestrates your engines and can't run a session without one.
# 1. Install Jinn
npm install -g jinn-cli
# 2. Install + sign in to at least one engine (example: Claude Code)
npm install -g @anthropic-ai/claude-code
claude # run once, use /login, then quit
# 3. Set up ~/.jinn (probes your engines, writes config, seeds your company)
jinn setup
# 4. Start the gateway - opens the dashboard for you
jinn start
Open http://localhost:7777 and send your first message.
Or install via Homebrew:
brew tap hristo2612/jinn https://github.com/hristo2612/jinn
brew install jinn
jinn setup && jinn start
--version≠ signed in. Jinn drives the official engine CLIs, so authenticate each one beforejinn start(runclaude→/login, runcodexto sign in, and so on). Without this, sessions can't reach the models - the most common fresh-install gotcha.
Docker needs Docker Engine or Docker Desktop with Compose v2, but it does not need Node.js or an agent CLI installed on the host. The image includes Claude Code. Containerising bounds the engine's permission-free access to the directories you explicitly mount instead of your whole home directory:
git clone https://github.com/hristo2612/jinn.git
cd jinn
# Edit docker-compose.yml and uncomment at least one "Project mounts" entry.
# Without one, /work is empty and the agents have nothing to work on.
docker compose up -d --build
docker compose exec jinn claude # run once, use /login, then quit
docker compose exec jinn jinn pair # prints a code for the browser
Then open http://localhost:7777 and enter the code at the pairing prompt. The gateway binds 0.0.0.0 inside the container, so it requires auth, and your browser reaches it through Docker's NAT rather than loopback — which is why pairing replaces the automatic sign-in a host install gets.
The compose image runs one Jinn instance. Additional instances need separate containers, dedicated Jinn/Claude volumes and separately published ports. The writable blast radius includes those state volumes (OAuth, sessions and plugins), every writable project mount, and unrestricted network egress; see the Docker guide before mounting sensitive data.
The image ships the claude engine only. codex, grok and hermes are not included, and neither are ffmpeg/whisper-cli for speech-to-text — the same as a Homebrew or npm install, which leave those to you. See docs/docker.md for the mount model, what persists across upgrades, how to add speech-to-text, and what the isolation does and does not cover.
Everyday commands for a native install:
jinn start # start the gateway daemon (auto-opens the dashboard)
jinn stop # stop it
jinn restart # restart safely (detached; works even from inside a session)
jinn status # is the daemon running?
Docker owns the gateway lifecycle instead — jinn start, jinn stop, and jinn restart are intentionally unavailable inside the container:
docker compose ps # status and health
docker compose logs -f jinn # follow gateway logs
docker compose restart jinn # restart safely
docker compose down # stop; named volumes remain intact
After upgrading an older install, run jinn migrate. Your COO applies the latest operating doctrine without overwriting your customizations.
Jinn exposes a small set of building blocks and handles the machinery underneath.
Employees are editable YAML roles with a name, department, rank, and engine. One employee can run several sessions; different roles can use different engines.
Todos are the durable work ledger. They track assignee, priority, status, sub-tasks, discussion, approvals, and reviewer-owned completion across sessions.
Workflows are reusable graph procedures with sequential, conditional, parallel, and switch paths. Phases can choose engines and models, require approval, and preserve evidence and run history. Triggers start them from schedules, webhooks, polls, or Todo changes.
Chat operates the company. Delegations, callbacks, Todo changes, and Workflow operations appear beside the conversation as durable activity receipts.
Notes are durable Markdown knowledge: plain .md files under ~/.jinn/knowledge/, in folders of your choosing. Typed tools read and write them, and every update carries the revision it expects, so two sessions cannot silently overwrite each other.
Experiments are bets written down before the answer is known: a hypothesis, a baseline, the metrics that would settle it, and a horizon. Readings accumulate while one runs and a verdict closes it; see docs/experiments.md for the data model, the lifecycle, and what validation enforces.
Heartbeats are recurring self-wakes a session schedules for itself. A message is redelivered into the owning session on a fixed interval until the session stops it, or a fire limit or expiry disarms it.
Plugins extend the app itself: an enabled directory under ~/.jinn/plugins/ adds dashboard pages, sidebar rows, and status chips, and may also mount gateway HTTP routes and a supervised background task, with no build step. See docs/plugins.md for the manifest, the SDK surface, and the security posture.
Skills and Cron provide reusable playbooks and scheduled work. A built-in Jinn MCP gives engines typed tools for company operations; shell access remains available for local implementation.
Jinn is a local gateway daemon plus a web dashboard. It dispatches work to installed engines, persists company state, runs automation, and serves the UI at localhost:7777.
+----------------+
| jinn CLI |
+-------+--------+
|
+-------v--------+
| Gateway |
| Daemon |
+--+--+--+--+----+
| | | |
+--------------+ | | +--------------+
| | | |
+-------v---------+ +-----v------+ +---------v-----+
| Engines | | Connectors | | Web UI |
| claude · codex | | Slack · WA | | localhost:7777|
| grok · hermes… | | Discord·TG | | |
+-------+---------+ +-----+------+ +-------+-------+
| |
+-------v-------+ +-----------+ +--------v-------+
| Todos · | | Cron | | Jinn MCP |
| Workflows | | Scheduler | | company hands |
+---------------+ +-----------+ +----------------+
Claude runs in a real interactive terminal, so eligible turns bill against a Max/Pro subscription. Other engines use spawn-per-turn or streaming models. Jinn discovers supported models from each CLI when available.
Employees live in ~/.jinn/org/ as plain YAML:
name: research-lead
displayName: Research Lead
department: research
rank: manager
engine: claude
model: opus
reportsTo: chief-of-staff # hierarchy of any depth
persona: |
You lead market research. Break briefs into parallel sub-tasks,
delegate to your analysts, and synthesize one clear answer.
Ranks set default reporting lines; reportsTo overrides them at any depth. Managers delegate sub-tasks as Todos and roll results back up, while any employee remains directly reachable.
Reviewers choose TRUST, VERIFY, or THOROUGH oversight. Money, irreversible or public actions, and legal or security risk route to you.
Jinn detects installed agent CLIs and lets each employee or session choose an engine. It discovers model catalogs when supported and otherwise uses labels from config.yaml.
Fallback labels include Opus (Latest), Sonnet (Latest), Fable (Latest), GPT-5.5 Codex, Grok Build, and Gemini 3.5 Flash Medium / High / Low. Pi and Hermes report their models at session start.
Hermes cost note. Unlike the subscription-wrapped engines, Hermes owns its own model loop and bills per token on the provider configured in
~/.hermes. It streams over the Agent Client Protocol (ACP) and runs fully auto-approved. Seedocs/engines-hermes.md.
Jinn drives the interactive claude binary through node-pty, so eligible turns use Max/Pro subscription billing. Hooks mark turn boundaries, a loopback proxy streams model output, and transcript JSONL provides token usage.
The Chat and CLI views share one PTY. Terminal snapshots survive reconnects and gateway restarts. Codex, Grok, and Pi spawn per turn; Hermes streams over ACP.
Jinn reads ~/.jinn/config.yaml. A fresh setup includes this core shape:
gateway:
port: 7777
host: "127.0.0.1"
authRequired: true
notesEnabled: false
engines:
default: claude
claude:
bin: claude
model: opus
effortLevel: medium
fallback: [codex, grok]
codex:
bin: codex
model: gpt-5.5
grok:
bin: grok
model: grok-build
hermes:
bin: hermes
model: openai-codex:gpt-5.5
models:
claude:
default: opus
effortMechanism: claude-flag
models:
- { id: opus, label: "Opus (Latest)", supportsEffort: true, effortLevels: [low, medium, high, xhigh, max] }
logging:
file: true
stdout: true
level: info
engines.default controls new sessions.engines.<name>.fallback names the engines to try, in order of preference, when that one cannot serve a turn. Two engines may name each other; an engine may not name itself.sessions.rateLimitStrategy and sessions.fallbackEngine are deprecated in favour of engines.claude.fallback. They still work: the loader maps them forward and warns once.mcp.gateway for the built-in company tools.~/.jinn/cron/jobs.json, ~/.jinn/org/, and ~/.jinn/skills/.<JINN_HOME>/workflow-evidence; JINN_WORKFLOW_EVIDENCE_ROOT relocates it.~/.jinn/plugins/ and only run when plugins.enabled names them; see docs/plugins.md for the anatomy, lifecycle, and security posture.Everything is human-readable and yours to edit. After upgrading, run jinn migrate to merge current operating doctrine into your customized instance.
Jinn is in active beta. Shipped recently:
On deck:
See CHANGELOG.md for release history, or open an issue.
Jinn is a pnpm + turbo monorepo.
git clone https://github.com/hristo2612/jinn.git
cd jinn
pnpm install
pnpm setup # one-time: builds all packages and creates ~/.jinn
pnpm dev # gateway (:7777) + Vite dev server (:5173) with hot reload
Open http://localhost:5173. Vite proxies /api and /ws to the gateway.
pnpm build # build every package (turbo) and sync web assets
pnpm test # run the test suites across packages
pnpm typecheck # type-check without emitting
pnpm lint # lint every package
pnpm test:e2e # Playwright end-to-end tests
Prerequisites: Node.js 22 or newer; contributors should use 24.13.0, pinned by
.nvmrc+engine-strictbecause native modules likebetter-sqlite3are ABI-locked. You also need pnpm 10.6+ and at least one engine CLI. See CONTRIBUTING.md for the full setup.
See CONTRIBUTING.md for setup and pull request instructions.
Lightweight AI gateway daemon orchestrating Claude Code, Codex, Grok, and Antigravity CLI
{ "mcpServers": { "jinn-cli": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Jinn Cli ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-10-28 Lightweight AI gateway daemon orchestrating Claude Code, Codex, Grok, and Antigravity CLI