Simple and fast harness.
Batteries included.

The request prefix is tiny and stays byte-stable for the conversation's lifetime: a very small base prompt and a deliberately small frozen direct toolset, so provider caches stay hot turn after turn. Everything else is progressive discovery — one discover/invoke away, entering as history instead of prompt bloat. Fewer tokens per turn, quicker round trips — and the numbers are measured in bench/ against pi, opencode and claudecode, not asserted.

None of the following is exclusive to Niffler. But the lean harnesses make you give most of it up, and the big ones hide it behind their UI. Here it is all in one small box:

None of this is exotic — you expect it in a serious harness. Some minimal ones make you give it up. Niffler ships all of it:

Niffler runs headless as a shared local service: the agent, its tools, background jobs and history live in the instance — not in a window. Clients are thin attachers over the bus; several can share one running instance at once. A client boots the harness on demand, an autostarted core turns itself off when the last client leaves — and closing your terminal mid-task loses nothing: background jobs keep running and wake the conversation when they settle.

• niffler-tuithe terminal chat client — a plugin that boots the harness on demand
• clithe headless driver: call tools, install packages, run whole turns from a script or CI
• consolesubscribes the bus and renders every envelope live — better than nats sub
• desktop UIan experimental spin-off package (gokr/niffler-ui) — same wire, its own repo

Service mode runs with no terminal at all (niffler < /dev/null) — and niffler in a terminal is an admin shell (status, catalog, sessions), not a chat.

Every capability is a separate process that does one thing — its own lifecycle, its own failures, isolated from the agent's mind. One wire connects them all: JSON envelopes over NATS. So the agent can write, compile and spawn a new tool mid-conversation, and teardown is just exit(). The OS is the disposer.

{
  "v": 1,
  "id": "1760825…-4242-1",
  "kind": "call",
  "tool": "bash",
  "args": { "command": "uname -a" },
  "caller": "cli"
}

Niffler is meant to be easily extended — a trait it shares with Pi, its biggest influence. It wears its sources on its sleeve. What we took, and from where:

curl -fsSL https://raw.githubusercontent.com/gokr/niffler/main/scripts/bootstrap.sh | bash
# asks before creating ~/niffler — or pick a location: | bash -s -- /your/dir
# or manually, from a clone:
git clone https://github.com/gokr/niffler.git && cd niffler
make setup && make build
cp .env.example .env   # add a model API key
make install-tui       # the terminal client (a plugin)
niffler-tui            # boots the harness on demand

• ✓ nim 2.2.12+
• ✓ go
• ✓ node / npm — optional: npx skills, npm MCP servers, TypeScript components (the core, clients and the TUI are Nim/Go — the installer asks)
• ✓ trafilatura — optional, richer HTML extraction

Niffler is built from source and distributed that way — there are no prebuilt binaries. The one-line installer brings in everything missing (git, make, Go, Node.js, the Nim toolchain and nimble packages); building by hand, make doctor reports what is missing. The bus is bundled — core spawns its own nats-server. The desktop UI is an experimental spin-off — install it like any package: cli install gokr/niffler-ui. Full story in the manual ↗.