Nimlet Coding Agent

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

Point Nimlet 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 act mode

$ nimlet
› Fix the failing parser test and run the focused test.
plan   Inspect the parser and its tests
read   src/parser.nim, tests/parser_test.nim
edit   Apply the smallest safe change
bash   nimble test parser
done   The focused test passes.

Native binary

A small process you can keep close to the work

Nimlet compiles to native code. There is no language runtime to install, startup is fast, and memory stays low enough to run one process per branch, workspace, or CI job.

Small process

Compiled to native code, not interpreted. Startup is fast and memory use stays low, so you can run several Nimlet 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 or in ~/.nimlet/auth.json.

Parallel-friendly

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

In your repository

From a task to a tested change

Ask for the outcome you want. Nimlet 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, inspect Git history, and attach the context that matters instead of pasting files in.

Plan before you act

Start in read-only plan mode, switch to act mode when you are ready, and reuse the investigation instead of starting over.

You decide what runs

Reads, searches, and workspace edits run freely. Shell commands and extensions 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 Nimlet 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 to Nimlet. There is no client library and no language lock-in.

.nimlet/extensions/notes/extension.mjs

#!/usr/bin/env node
import readline from 'node:readline'
const send = (message) => process.stdout.write(JSON.stringify(message) + '\n')
send({
  type: 'register',
  commands: [{ name: 'note', description: 'Append a note to NOTES.md' }],
  tools: [{
    name: 'save_note',
    description: 'Save a note about the current work.',
    input_schema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] },
  }],
})
for await (const line of readline.createInterface({ input: process.stdin })) {
  const message = JSON.parse(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 .nimlet/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.

Put the nimlet binary on your PATH, set a provider key, and launch it from the workspace you want to work on.

$ export OPENROUTER_API_KEY=your-key
$ cd /path/to/your/project
$ nimlet