The LLM is the compiler, not the runtime.
AI agents improvise at runtime — every execution a fresh roll of the dice. INXM // local moves the intelligence to compile time: describe intent in chat, the model produces a typed, versioned plan, and a deterministic Rust executor runs it. No AI improvisation in the execution path. Ever.
Chat once. Run forever.
This is the in-app chat — and you're in the loop for real: approve the spec, start the run, and decide at the pause. Nothing below moves without you.
A desktop app, not another terminal.
Chat on the left, artifacts on the right. The compiler walks you from refine (a spec with acceptance criteria and a confidence score) through design to the compiled artifact — a versioned plan you review, publish, run, and schedule.
Download. Open. Compile.
Prebuilt binaries for every release — no toolchain,
no admin rights required. Unpack, run, then pick a
compiler connection in Settings: an API key, your
existing claude or codex
CLI login, or any OpenAI-compatible local server.
Install the latest release in one command
Detects your platform, downloads the current release, and installs it per-user — no root required.
curl -fsSL https://raw.githubusercontent.com/inxm-ai/inxm-local/main/packaging/install.sh | sh
Install the latest release with PowerShell
Downloads the current Windows release and runs the per-user installer — no admin rights required.
irm https://raw.githubusercontent.com/inxm-ai/inxm-local/main/packaging/install.ps1 | iex
Install and connect your coding agents
Add --agents and the installer also
registers INXM Local's local MCP server with every
agent it finds — Claude Code, Codex, Gemini CLI,
Qwen Code, Copilot, VS Code, Cursor, Windsurf,
Cline, Roo Code, OpenCode, Goose, Hermes, and Pi —
so they can compile, run, and repair workflows
immediately. Or pick explicitly:
--claude, --cursor,
--windsurf, ...
curl -fsSL https://raw.githubusercontent.com/inxm-ai/inxm-local/main/packaging/install.sh | sh -s -- --agents
Or install system-wide with APT
Download the current .deb directly from
the latest GitHub release and install it with APT.
curl -fL https://github.com/inxm-ai/inxm-local/releases/latest/download/inxm-local-x86_64-unknown-linux-gnu.deb -o /tmp/inxm-local.deb && sudo apt install -y /tmp/inxm-local.deb
Or install without sudo
The .tar.gz installs into
~/.local for the current user only.
Add --autostart to start INXM Local
hidden in the tray when you log in;
--uninstall removes it again.
curl -fL https://github.com/inxm-ai/inxm-local/releases/latest/download/inxm-local-x86_64-unknown-linux-gnu.tar.gz | tar -xz && ./inxm-local/install.sh
1 · Type what you want
No syntax to learn — plain language in the chat starts the compiler. It asks clarifying questions and drafts a spec with acceptance criteria and a confidence score.
2 · Review the plan
Approve the solution design and you get a plan card with typed inputs, version history, and the exact steps the executor will run.
3 · Publish & schedule
Happy? Publish the plan and put
it on a cron schedule from the Schedules view.
Power users can drive everything with slash
commands like /run and
/schedule too.
Prefer to build from source?
# builds the desktop app and opens it
git clone https://github.com/inxm-ai/inxm-local
cd inxm-local && cargo run --release
Compilers solved this decades ago.
Nobody re-derives machine code from source on every run. Intent gets compiled once, checked, versioned — then a boring, fast machine executes it. We built that for AI: the plan is the artifact.
Compiled, not improvised
The LLM's only job is turning natural language into a validated, typed plan. The executor runs steps in topological order, persists state after every step, and behaves the same on Tuesday as it did on Monday.
Your machine, your models, your data
A Rust desktop app. Plans, runs, and patches live in your local data dir. Bring an API key, your existing Claude/Codex CLI login, or a local endpoint — Ollama, LM Studio, llama.cpp, vLLM.
Failures become patches, not retries
A failed run is handed back to the compiler with
/repair. The proposed fix appears
as a patch you review, apply, or reject — like a
pull request, not a prayer.
INXM // local vs. INXM // orchestrator
Both bring Compiled AI to business workflows. INXM // local is a lightweight entry point designed for open-source distribution; INXM // orchestrator is the enterprise platform for taking workflows across an organization.
INXM Local helps one person explore and prove value. INXM // orchestrator helps an organization share, govern, and operate that value.
| Dimension | INXM // local | INXM // orchestrator |
|---|---|---|
| Best for | Individuals, experiments, hackathons, and first prototypes | Teams, departments, and organization-wide use cases |
| Time to start | Install the app and begin on your own computer | Deploy as a managed platform for the organization |
| Users | Designed for a single user | Designed for many users and teams |
| Sharing | Export and pass workflows on manually | Publish, reuse, and operate workflows in a shared environment |
| Identity & access | Relies on the user's device and local credentials | Enterprise SSO/IAM, roles, permissions, and separation of duties |
| Security model | Local application boundary; the user controls tools and credentials | Centrally managed access, protected services, identity propagation, and organizational security controls |
| Visibility | Local run history and execution details | Central tracing, logs, metrics, execution history, and operational oversight |
| Governance & audit | User-managed plan versions and run records | Shared ownership, controlled access, change history, and central audit events |
| Scale & reliability | Runs on one computer for one user | Managed infrastructure for concurrent, scheduled, and long-running organizational workflows |
| Integrations | Connect the MCP tools needed for an individual use case | Centrally managed catalog of enterprise tools and MCP services across environments |
| Operations | The user installs, configures, and keeps it running | Platform teams can deploy, monitor, update, and support it centrally |
Everything engineers love about artifacts.
Typed plan inputs
Plans declare their input contract —
${input.query}, targets, limits,
recipients. Values are validated before a run or
schedule is ever created. Missing, unknown, or
mistyped inputs are rejected up front.
Human-in-the-loop steps
HUMAN_INTERACTION steps pause the
run and ask in chat — approve, reject, or answer
free-text. The run checkpoints and resumes
exactly where it stopped. Completed steps never
repeat.
Schedules that can't drift
Cron-schedule any plan with captured, validated inputs. Because the plan is compiled, the 100th scheduled run does exactly what the first one did.
Full run history
Every run persists step status, timing, resolved
inputs, outputs, and errors. Use
/inspect to audit any run.
Versioned plans
Applied repair patches create new plan versions. Every plan owns a persistent chat where you refine it with plain language.
MCP tools, managed in the UI
Add, edit, and remove MCP servers plus
subprocess and HTTP tools from the tool catalog
view. Changes persist to a plain
tools.yaml.
Three stages. One of them is smart.
Compile
Type plain language (or
/compile <intent>). The
configured model produces a plan: typed steps,
declared inputs, tool references. The validator
rejects anything malformed before it's saved.
Review
The plan is an artifact — read it, inspect its steps, and refine it in its own chat. Changeable details become typed inputs instead of being hard-coded.
Execute
The deterministic executor runs steps in order, streams live progress, persists state after every step, and pauses for humans when the plan says so. No model in the loop.
for your other agents
On launch, INXM // local serves a local HTTP MCP
endpoint at
127.0.0.1:39387/mcp. Any MCP client —
Claude Code, your own tools — can compile, execute,
inspect, repair, and schedule the same deterministic
plans. Give your improvising agents a compiler.
{
"jsonrpc": "2.0", "id": 1,
"method": "tools/call",
"params": {
"name": "execute_plan",
"arguments": {
"plan_ref": "bug-digest",
"inputs": { "query": "label:bug", "limit": 5 }
}
}
}
Stop prompting.
Start compiling plans.
INXM // local is free and open source. Star the repo,
open an issue, grab a good first issue,
or share the plan you compiled.