niminal

Fast to start, light on memory, no CPU until you ask.

Point niminal at a repo, describe the change, and it inspects, edits, runs the commands you approve, and keeps the session. Extend it in any language so it works the way you do.

your-project

$ niminal
› Fix the failing parser test and run the focused test.
read   src/parser.cpp, tests/parser_test.cpp
edit   Apply the smallest safe change
bash   ./dev check --fast
done   The focused test passes.

Native binary

A small process you can keep close to the work

niminal compiles to a native C++ binary. Startup is fast, memory stays low, and the process waits on you, the provider, or a subprocess instead of polling.

Small process

Compiled to native code, not interpreted. You can run several niminal processes without a heavy runtime behind each one.

Idle when waiting

It waits on you, a provider, or a subprocess. No polls, no timers, no idle CPU.

Your provider, your keys

Requests go straight to the API you pick. Credentials stay in your environment, your local auth file, or a one-process --api-key override.

Parallel-friendly

Run independent processes for separate workspaces, branches, or jobs. Each one has its own session and queues.

In your repository

From a task to a tested change

Ask for the outcome you want. niminal gathers context from the project, makes the smallest edit that fits, and runs the checks you approve.

See the whole workspace

Read files, search by pattern, and attach the context that matters instead of pasting files in.

Smallest useful change

Read before edit, use version tokens from read, and keep unrelated work intact.

You decide what runs

Reads, searches, and workspace edits run freely. Shell commands and extension tools ask the first time, with per-session and per-project grants.

Come back later

Queue the next thought while a turn runs, resume a saved session, and let compaction make room for longer tasks.

Extend it

Any language. No SDK.

An extension is a program niminal starts and keeps running. Python, Go, Rust, JavaScript, a shell script: if it can read stdin and write stdout, it can add tools, slash commands, hooks, and live status. There is no client library and no language lock-in.

.niminal/extensions/hello/extension.py

#!/usr/bin/env python3
import json, sys

def send(value):
    print(json.dumps(value), flush=True)

send({
  type: 'register',
  commands: [{ name: 'hello', description: 'Say hello' }],
  tools: [{
    name: 'hello_tool',
    description: 'Return a greeting.',
    input_schema: { type: 'object' },
    capabilities: ['read'],
  }],
})

for line in sys.stdin:
  message = json.loads(line)
  if message['type'] == 'shutdown': break

Stay in the language you ship

JSON lines on stdin and stdout. No plugin host, no bundle step, no FFI into the agent process.

Spawn a tool, or keep a process

A tool.json executable runs per call. An extension stays up, sees session events, and can push status whenever it likes.

Commands, tools, and hooks

Register slash commands, model tools, and lifecycle hooks from the same program. Reply when you have something to change.

Files next to the work

Put extensions in .niminal/extensions or the portable ~/.agents/extensions layout other agents already share.

Persistent extensionsA long-running program in any language: tools, commands, hooks, and live status. External toolsExpose a one-shot executable as a typed model tool. SkillsLoad Markdown procedures only when a task calls for them. Prompt templatesTurn recurring requests into slash commands. InstructionsSet project and personal rules that reach every request.

One agent, several surfaces

Use the interface that fits the job

The same agent is an interactive TUI, a one-shot command, a JSON event stream, or a long-running RPC process.

TUIWork in the terminal with queues, mentions, and shortcuts. Print modeRun one turn and keep stdout to the final answer, including from a pipe. JSON modeEmit versioned JSONL events for a single run. RPC modeDrive a long-running process with prompts, steering, follow-ups, and interrupts.

Start in a few lines

Bring your provider. Keep your project.

Install the release binary on macOS or Linux, set a provider key, and launch niminal from the workspace you want to work on.

$ curl -fsSL https://niminal.dev/install.sh | sh
$ export OPENROUTER_API_KEY=your-key
$ cd /path/to/your/project
$ niminal