Docs
Set it up. Understand how it works.
Install the alpha, choose a model and give it a task. This guide covers the runtime, memory, tools and boundaries around self-improvement. Start with a workspace you can safely test in.
Follow the setup below, or jump to Architecture to inspect the implementation. For the latest details, check the repo, which is updated first.
Install
One command finds your OS. On Linux and macOS. On Windows get the installer from Releases.
Linux & macOS
- Linux with a display → installs the desktop app (.deb / .rpm).
- Linux headless → builds the cinderpaw CLI + gateway from source (
-s -- --headless). - macOS → downloads the right .dmg, installs to /Applications, clears quarantine.
Windows 10/11
Get the newest .exe from Releases and run it. SmartScreen may warn on first run. Not signed yet. Click More info → Run anyway.
Just the CLI (npm)
The npm package provides the terminal agent with cloud inference. It has no local llama.cpp engine in it. For local GGUF models get the desktop app above.
Quick start
- 1Get Cinderpaw. Open it. Complete onboarding and name your agent.
- 2Get a model. For local inference, browse Models and download a model that fits your hardware. For cloud inference, add your API key in Settings → Cloud Keys. Keys are stored locally and sent to the selected provider for authentication.
- 3Chat. Or flip to Agent mode. Agent mode enables the sidecar for tool use, persistent memory, file operations and web research.
Like the terminal? cinderpaw chat opens a full screen chat. Same chats. Same recall. Same models. cinderpaw setup runs the guide. And cinderpaw gateway runs it in the back.
What's inside
Chat
Chat with supported local or cloud models. Organize conversations into groups.
Agent Mode
A TypeScript sidecar with tool use, persistent memory and an execution loop.
Memory Layers
Working context, searchable history, durable facts and hierarchical summaries for retrieval across sessions.
Self-forging tools
Generate, update and retire tools at runtime through tool_forge, with checks, permissions and logging.
Self-Improvement (BRSI)
Evaluate changes to configuration, adapters, tools and code through bounded promotion policies. See Self-improvement below.
Connectors
Talk to your helper from WhatsApp (QR pair), Discord, or Slack. Same configured model and local memory.
Deep Research
Search the web, read sources and produce a cited Markdown report.
Local Models
Load and unload GGUF models from disk, with active-model status and hardware suitability estimates.
Model Fitness Scoring
Local models receive a 0–100 suitability score based on hardware fit, speed and context capacity.
Browse HuggingFace
Find and download models from Hugging Face inside the app.
SkillHub
Add and find skills that grow what the AI can do.
Cloud Keys (BYOK)
Bring your own key for OpenAI, Anthropic, Gemini, DeepSeek, Groq, Mistral, OpenRouter, Kimi, GLM, MiniMax, or a compatible custom endpoint.
Privacy Tags
Wrap words in <private>…</private> and they never touch the recall base.
Tool Health Monitor
Per tool win rates and speed tracking. The agent can identify unreliable tools.
Workspace Scanner
Finds hidden passwords and bad code bits in the workspace. Before you send them to GitHub.
Hardware Monitor
GPU, VRAM and RAM readings, plus Vulkan availability checks.
Auto-updater
Background checks for available updates, with minisign verification.
Architecture
One repo. Four parts. Three ways they talk. You came to copy it and read the code. This part and the next two are the map. They match ARCHITECTURE.md in the repo. That file is updated first.
┌───────────────────────────┐ ┌───────────────────────────┐
│ Desktop UI (React/Vite) │ │ TUI (Go + Bubble Tea) │
└─────────────┬─────────────┘ └─────────────┬─────────────┘
│ Tauri IPC │ HTTP
┌─────────────┴───────────────────────────────┴─────────────┐
│ Rust host - crates/cinderpaw-core │
│ ├── desktop: src-tauri/ ├── headless: cinderpaw-cli/ │
│ ├── llama.cpp answering engine (:11435) │
│ └── OpenAI / Ollama-compatible HTTP API + bearer token │
└─────────────────────────────┬─────────────────────────────┘
│ JSON-lines on stdout
┌─────────────────────────────┴─────────────────────────────┐
│ Sidecar - CinderpawAgent/ (Bun + TypeScript, one binary) │
│ └── helper loop · BRSI engine · recall · tools · sandbox │
└───────────────────────────────────────────────────────────┘The four parts
| Part | Built with | Does |
|---|---|---|
Desktop UIfrontend-react/ | React + Vite + Zustand | Rendering, chat surfaces, the mascot, settings UX. |
Rust host (desktop)src-tauri/ + crates/cinderpaw-core/ | Tauri 2 + llama.cpp | IPC, filesystem, GGUF answering, the 127.0.0.1:11435 HTTP API, sidecar watch. |
Rust host (gateway)crates/cinderpaw-cli/ | Rust, no UI | The same cinderpaw-core headless. Exposes the cinderpaw subcommands and the HTTP API for terminal and automation. |
SidecarCinderpawAgent/ | Bun + TypeScript, one compiled binary | The helper loop, BRSI engine, recall, tools, safe answering router. |
TUItui/ | Go + Bubble Tea | Terminal chat, onboarding, connectors wizard. API client only. |
Five rows. Four parts. The desktop shell and the headless gateway are two hosts of the same cinderpaw-core crate.
The three ways they talk
| Name | Between | How they talk | Checked by |
|---|---|---|---|
| Tauri IPC | UI ↔ host | invoke() / listen('cinderpaw://…') | Command registry in src-tauri/src/commands/ |
| JSON-lines on stdout | host ↔ sidecar | {type:"…", …} one per line | CinderpawAgent/src/transports/tauri.ts + types.ts |
| OpenAI/Ollama-compat HTTP | any client ↔ host loopback | JSON over HTTP | crates/cinderpaw-core/src/api.rs, per-launch bearer token |
Provider credentials are injected by the Rust host. The desktop host adds stored credentials when configuring the sidecar. Audit that boundary starting at cinderpaw_set_model.
Layer map (L0-L6)
The BRSI stack is true code. Not just an idea. Each step owns a part of the tree. Hard deals rule them. One rule will bounce your PR. Respect layer boundaries. All talk goes through rsi/sidecar.ts, rsi/engine.ts and rsi/mod.ts. Paths below start at CinderpawAgent/src/ unless they say more.
| Layer | Job and rules | Where in the code |
|---|---|---|
| L0Substrate | Git-backed journal, the bounded-ratchet boundary, integrity. | rsi/infra/journal.ts · rsi/infra/hash-chain.ts · cinderpaw-core/src/rsi/repo.rs |
| L1Config evolution | Mutates the 7-field GenomeConfig, bounded by schema. May not touch code or weights. | rsi/l1-config/ |
| L2Personal adaptation | LoRA over your own signal. May not mutate base weights. | rsi/l2-adapt/ |
| L3Code RSI | Unified diffs over CinderpawAgent source, applied through a worktree. May not skip the worktree or touch the host. | rsi/l3-code/ |
| L4Architecture evolution | Subsystem hot-plug behind two v1 seams: retrieval_strategy and planner. May not write into CinderpawAgent/src/. | rsi/l4-modules/ |
| L5Governance evolution | Tunes parameters inside SandboxBounds. Reversible. May not bypass tier-0. | rsi/l5-gov/ · cinderpaw-core/src/rsi/sandbox_bounds.rs |
| L6Meta evolution | Tunes the algorithm that produces those parameters. Never skips the human gate. | rsi/l6-meta/meta-evolution.ts |
| infraCross-layer | Bus events, envelopes, budget, paths, the contract FSM, confidence gate. | rsi/infra/ |
Full file list lives at CinderpawAgent/src/rsi/README.md. Safety deals live in docs/invariants.md. Big ideas live in docs/brsi-spec.md.
Where do I add X
Each new helper asks one of these in the first hour. So here they are first.
A new answering provider
Four places, in this order: cinderpaw-core/src/byok.rs provider_catalog() is the canonical list; CinderpawAgent/src/egress/inference-providers.ts only if you need a new protocol family; check the auto-seeded vector in brain/capability-registry.ts; the Cloud Keys UI wires itself through useCatalog().
A new built-in tool
One file: CinderpawAgent/src/tools/builtin/<name>.ts. Declare the manifest (permissions, parameters) in the same file and boot.ts picks it up. Add a smoke test under CinderpawAgent/tests/.
A new chat connector
Catalog entry in cinderpaw-core/src/connectors.rs, desktop IPC in src-tauri/src/connectors.rs, connection owner in CinderpawAgent/src/egress/mcp-manager.ts. Persistence flows through cinderpaw-core so desktop and gateway agree.
A new L4 seam module
modules/<id>/manifest.json + module.ts. The registry at modules/registry.json is the runtime source of truth. Never edit CinderpawAgent/src/ for a module - that's the L3 trust boundary.
A new memory strategy
Pick the layer first. Same engine, different scoring goes in rsi/l1-config/fitness.ts. A new retriever joins the GenomeConfig.retrievalStrategy pool. A new storage layout belongs in CinderpawAgent/src/memory/fractal/.
If you add a file under rsi/ update the step list in ARCHITECTURE.md and rsi/README.md in the same PR. Old docs count as a true bug. The next reader will trust the wrong thing. Human or helper.
Agent runtime
Flip the switch to Agent mode. Your words go to the Bun and TypeScript sidecar. It recalls good recall. It sends words live. It loops tool calls till it has an answer. Up to 10 loops per note. 50 for hard long jobs like deep research.
user message
│
▼
[Recall] adds good old recall (FTS5 and saved facts)
│
▼
[Answering] sends words live to screen
│
├── tool call? → execute → feed result back → loop
└── no tool call → final answer, save to recall, doneTired web tools try again. They wait a bit more each time. They move down the web_search → deep_research → read_webpage chain.
Memory layers
Cinderpaw keeps lots of kinds of recall. They stay past each chat. From a word log you can search. Up to a smart tree that gets what you truly said.
| Recall | Kept in | What it keeps |
|---|---|---|
| Working | RAM | The live conversation transcript. Auto-compresses older turns when it runs over the token budget. |
| Episodic | SQLite + FTS5 | Every message, tool result and typed observation, keyword-searchable full-text. |
| Semantic | SQLite | Durable facts pulled from each turn: your name, role, language, preferences, constraints. |
| Fractal Memory | RAPTOR tree | The semantic layer. Events are embedded, k-means-clustered, and each cluster is summarized into a tree; recall embeds your query and walks the tree for related memories across every session. Built offline, and it augments FTS5 instead of replacing it. |
| Recall Engine | - | Joins all of the above. Adds the best hits first. Before each answering call. |
Fractal Memory uses a RAPTOR-style tree. Raw events form the leaves; k-means groups related events and the model summarizes each cluster. Retrieval traverses this hierarchy to find the idea of old work. Not just same word matches. SQLite and FTS5 provide a keyword fallback, so keyword retrieval remains available before the summary tree is built.
Privacy tags. Wrap sensitive text in <private>…</private>. It is excluded from memory persistence. The model still receives it for the current turn, including a cloud provider if selected.
Self-improvement (BRSI)
The adaptation system is called BRSI: Bounded Recursive Self-Improvement, six adaptation layers above the L0 substrate. Candidates compete against the current champion under evaluation and promotion policies. The system records changes and supports rollback. A passing evaluation is evidence for that test, not universal improvement.
| Step | What it changes | Promotion constraints |
|---|---|---|
| L1Config Evolution | Its own settings - sampling, memory, retrieval and tool parameters. Runs “dream cycles” while you're away. | A population competes on a fitness score; the champion is only replaced on a measured win. |
| L2Personal Adaptation | A private LoRA adapter trained on how you actually work, on your own GPU. | Gated by an A/B evaluation before promotion; passing an evaluation does not guarantee improvement on every task. |
| L3Self-Code Modification | Its own source code. Cinderpaw proposes patches, tests them, and keeps only what passes. | Bounded diff size, an immutable core it can't touch, sandboxed, auto-rollback on regression. |
| L4Tool / Module Evolution | Its own tools. It builds new ones autonomously, improves them over time, and retires the ones that stop earning their keep. | Every module is eval-scored and lifecycle-managed behind a module wall. |
| L5Governance Evolution | The knobs of the improvement policy itself - confidence thresholds, fitness weights, mutation rates, budgets. | Only moves within agent-immutable bounds it cannot widen; every change is reversible. |
| L6Meta Evolution | The algorithm that produces those knobs - how it decides what to try and how it learns. Genuine recursive self-improvement. | Always human-gated. Research preview, behind the strictest promotion gate. |
Bounded by policy. Activation and approval depend on the layer. Deeper layers are disabled by default; meta-evolution requires human approval. The scorer and fixed policy bounds sit outside the mutable scope.
Built-in tools
A small taste of the built in tools. Persona and chat builds add more. Like capture_lead and schedule_meeting. And with tool_forge the helper writes its own tools too. So the list never ends. Each tool states its needs at sign up. No state means no run. Web calls go through a safe gate. With SSRF guard and speed cap and a log. File tools heed a hard no list on ~/.cinderpaw and ~/.ssh.
| Tool | Needs | What it does |
|---|---|---|
| tool_forge | process | Create, update or delete its OWN tools. New tools transpile-check, hot-register instantly, persist in ~/.cinderpaw/tools and run sandboxed - the agent extends its own tool surface at runtime. |
| list_tools | - | Discover and enable optional tools on demand, keeping the base set lean (the tool drawer). |
| tool_health | - | Per-tool success rate and latency report; the agent diagnoses its own failing tools. |
| web_search | network | Ranked web results via a self-hosted SearXNG instance. |
| read_webpage | network | Clean Markdown from any URL via Jina Reader. |
| deep_research | network | Iterative plan → search → read → extract → synthesize; returns a cited report. |
| fetch_url | network | Fetch any public HTTPS URL (SSRF-guarded, rate-limited, audited). |
| http_request | network | Full HTTP client for APIs: GET/POST/PUT/PATCH/DELETE with headers and JSON. |
| read_file | fs:read | Read a file from the workspace. |
| write_file | fs:write | Write a file; creates intermediate directories. |
| edit_file | fs:write | Precise find-and-replace edits in place, not just whole-file writes. |
| list_directory | fs:read | List directory contents. |
| file_search | fs:read | Find files by name or glob under an allowed root. |
| grep | fs:read | Regex search across files, ripgrep-style. |
| git_status | process | Run git (status, diff, log) in the workspace. |
| shell_exec | process | Run shell commands. Gated by CINDERPAW_ENABLE_SHELL_EXEC. |
| scan_workspace | fs:read | Detect hardcoded secrets and code anti-patterns. Never exposes secret values. |
| code_quality | fs:read | Plain code health check on the workspace. |
| recall | - | Search past conversations (episodic + Fractal Memory) for relevant context. |
| remember | - | Write a durable fact into semantic memory on demand. |
| self_describe | - | Introspect its own recent activity, tools and state. |
| delegate_task | - | Hand a self-contained sub-task to a fresh sub-agent (optionally in parallel), depth-guarded. |
| ask_user | - | Pause and ask you when the task genuinely forks - routed to wherever you are. |
| escalate_to_human | - | Hand off to the human owner when it shouldn't act alone. |
| connectors_manage | - | List and configure its own Discord / Slack / WhatsApp connectors (tokens write-only). |
| control_app | process | Drive desktop apps through the OS accessibility tree: read the UI, find elements, click and type. |
| list_skills / read_skill | fs:read | Discover and read installed SkillHub skills. |
| calculator · time_date · todo_write | - | Everyday helpers: exact math, dates and times, and a working to-do list across a task. |
Privacy, honestly
- Local models. Local inference runs on your computer, with local memory storage. Network tools, connectors and update checks are separate. The installer sends a one-time version/OS count unless you opt out on the last setup screen.
- Cloud models (BYOK). The desktop runtime calls your selected provider directly. Prompts and selected context leave your computer when cloud inference runs, including agent or background tasks using that model. Your key authenticates those requests.
- Web tools. Tools such as web_search and deep_research make network requests through an egress gateway with SSRF checks, rate limits and logging.
- Update check. Once per start Cinderpaw asks GitHub Releases if a new build is out. Just the build ask. No use data. Turn it off in Settings then General for a fully offline app.
Environment variables
The sidecar reads these settings. Configure filesystem access and tool permissions for your workload. The full list is in the README.
| Setting | If you do nothing | What it does |
|---|---|---|
| CINDERPAW_WORKSPACE | cwd + home | Filesystem roots file tools may touch. Set it to RESTRICT. |
| CINDERPAW_FS_DENY | - | Extra paths file tools may never touch (on top of ~/.cinderpaw + ~/.ssh). |
| CINDERPAW_BASE_URL | 127.0.0.1:11435 | Answering spot. Cinderpaw's own llama.cpp engine. |
| CINDERPAW_API_KEY | - | Bearer token for the answering spot (BYOK / local token). |
| CINDERPAW_MODEL | qwen2.5:7b | Model name (overridden to cinderpaw-local by the desktop app). |
| CINDERPAW_ENABLE_SHELL_EXEC | true | Register the shell_exec tool. Set false to disable shell access. |
| CINDERPAW_SEARXNG_URL | - | Origin of a SearXNG instance for web_search. |
| CINDERPAW_FETCH_DOMAINS | - | Domain allowlist for fetch_url. Unset = all public hosts (SSRF guard still applies). |
License
One license for everything: Apache-2.0. The desktop app, the TUI, the agent runtime and the smart core. The full text lives in the repo LICENSE file.
- ✅ Free for all. Home use. Work use. Big firms too. Self host. Changed. Shared. Even as a hosted serve.
- ✅ No legal review needed. Apache-2.0 is an OSI license most companies already allow.
- 🕓 It used to be BSL 1.1. That changed in September 2026, so older pages or posts may still say BSL.
Ready to try it?
Get it in one command. Or take the installer for your OS from GitHub.