re-agent

README

0xAF-Re

An authorized reverse-engineering & CTF terminal agent. One static Go binary that combines a planner and an executor model seat, local RE tools, workflow modes, queued prompts, session resume, and a live view of every turn.

Language: English | 中文

Links: Project page · Architecture map · Architecture · Architecture diagrams · Comparison diagram

Table of Contents

• Motivation
• Features
• Demos
• Overview
• Architecture
• Developer Highlights
• Install
• Quick Start
• Workflow Modes
• Context Compaction
• Providers and Models
• Skills and Knowledge
• Safety
• Common Commands
• Roadmap
• More Docs

Bilingual Map

The English and Chinese READMEs keep the same structure for quick switching.

English	中文
Motivation	动机
Features	功能特性
Demos	演示
Overview	概览
Architecture	架构设计
Developer Highlights	开发者亮点
Install	安装
Quick Start	快速开始
Workflow Modes	Workflow 模式
Context Compaction	上下文压缩
Providers and Models	Provider 与模型
Skills and Knowledge	Skills 与知识库
Safety	安全策略
Common Commands	常用命令
Roadmap	未来设想
More Docs	更多文档

Motivation

Reverse engineering is already a pipeline: file, strings, entropy, r2, JADX, Frida, a scratch script, and a note somewhere. The slow part is rarely any single tool — it is holding the thread across all of them and re-deriving what you already knew two hours ago. 0xAF-Re exists to keep that thread: a planner model writes the route, an executor model drives the tools, and every fact lands in a transcript you can resume, diff, and hand to someone else.

Three principles shape it:

1. Local and evidence-first. Reads stay inside the workspace; writes, network, and sensitive paths are off until you say otherwise. Facts come from real tools (/scan, radare2, JADX, Frida, …) before they come from a model.
2. Two seats, not one. A strong reasoner plans; a cheap executor collects evidence. /planner, /executor, and /model re-route at runtime.
3. You watch it work and can steer mid-turn. Plan rows, tool calls, reasoning, tokens, and timings render live; /think expand, /tasks collapse, /queue edit, /model take effect while the turn is running.

Features

Area	What you get
Live dashboard	One boxed view: FLOW (animated dataflow strip), TOOLS (tool cards), PLAN (task list + progress), THINK (reasoning tail), TELE (throughput/tokens/clock). Tight terminals shed gracefully down to the current step.
Dual-model routing	planner / executor / researcher seats, pinned or per-role, switchable mid-run.
Workflow modes	off / auto / specialist / caveman plus purpose-built research / writeup / ctf / reverse / engineering — each wraps the prompt with a focused contract.
Session resume	Append-only JSONL transcripts; `--resume <hash
Context compaction	Mechanical elision every request + /compact; optional snapcompact archives dropped history as PNG frames a vision model reads back.
Reference context	--context "know:…" seeds the system prompt from the knowledge base, --context "file:…" from a workspace file, raw notes pass through.
Knowledge & skills	/know search + synthesis from the local knowledge index; built-in RE skills; MCP servers join the same tool registry.
Approvals, live	Tiered policy (read/write/exec) with safety-concern prompts; one-shot runs ask y/a/d/n interactively on a TTY instead of restarting with new flags.
Remote mode	Background SSH connections to saved machines; plan locally, execute remotely from the same window. (See Remote mode.)
Publishing	go install @vX.Y.Z plus GitHub Releases with prebuilt darwin/linux binaries on every tag.

Demos

Real terminal output, captured from the actual binary:

Demo	Description
	Live dashboard mid-turn (FLOW / TOOLS / PLAN / THINK / TELE).
	Same view, animated.
	/sessions — hash aliases for --resume.
	The command deck.

Animated cast walkthroughs (SVG, render inline): quickstart · deck · scan.

More static captures: boot · reply · approval · auth · tools · providers · palette · shell · verify.

Quick taste:

0xaf --smoke                                  # offline wiring check
0xaf -p "triage ./ctf/chall" --workspace ./ctf
0xaf --workflow reverse -p "static + dynamic analysis, then a PoC"
0xaf --context "know:android packer" -p "identify the packer"

Overview

Overview

• Local first: slash commands run file triage, strings, entropy, carving, APK inspection, mitigations, and reverse-tool inventory directly on your disk.
• Two seats: planner and executor providers can be different models or vendors. Switch them at runtime with /planner, /executor, and /model.
• Visible turns: the HUD shows route, phase, task list, tools, token counts, and timing while the turn is still running.
• Scoped by default: reads stay inside the workspace; writes, network, and sensitive actions need explicit policy changes.
• Installable binary: prompts and built-in skills are embedded, while project-local files can override them when OXAF_RE_HOME points at a checkout.

For the full design, see docs/ARCHITECTURE.md. For the visual overview, start with the Cocoon AI-style architecture map.

Architecture

The core design is a small loop rather than a chatbot bolted onto a shell: terminal input enters a Go host, the host routes each turn by role/provider/model, workflow mode shapes the context, and local evidence tools feed facts back into the next turn.

Open the exportable architecture map or browse the full diagram index.

Layer	Design Intent
Terminal surface	Keep queueing, slash commands, shell escapes, and live HUD in one workspace.
Agent loop	Route planner/executor/researcher seats, compact context, stream events, and persist JSONL sessions.
Workflow modes	Use specialist routes when available; otherwise split RE tasks into bounded local-evidence executor packets.
Policy gate	Keep reads workspace-scoped and require explicit approval for writes, network, sensitive paths, and risky commands.
Evidence layer	Prefer direct local facts from /scan, radare2, JADX, Frida, angr, Burp/mitmproxy, skills, and knowledge before model claims.

Developer Highlights

If you build agents, 0xAF-Re is a compact RE-focused reference implementation: one Go binary with provider routing, tool governance, live telemetry, prompt/skill overrides, queueing, and audit logs. It is small enough to read, but opinionated enough to show the parts most agent demos skip.

• Single-file install feel: one static binary, one Go dependency, no Node or browser runtime in the critical path.
• Composable model seats: planner, executor, and researcher can use different providers, models, and editable prompts.
• Evidence-first workflows: specialist routes use GPT Cyber / CC CVP / Grok style subscriptions directly; caveman mode isolates ordinary executors to read-only local evidence packets.
• Visible agent loop: HUD, trace lines, token/timing telemetry, task state, and JSONL sessions make each turn debuggable.
• Hackable surface area: built-in RE tools, MCP tools, skills, knowledge import, project-local overrides, and runtime queue editing.

Project Motivation

0xAF-Re grew out of daily authorized RE/CTF work where coding-agent risk controls tightened and general models became more cautious around reverse-engineering language. The goal is not to hide intent. The agent keeps work local, authorized, and auditable, then improves the experience by splitting roles and composing models.

• Model composition: use one model for planning, another for tool execution, and a researcher role for background context.
• Specialist routes: GPT Cyber, Claude Code CVP, Grok, or similar security-research-friendly routes make workflow auto smoother.
• Ordinary-provider path: caveman mode narrows the task into local evidence packets so cautious executors can still collect file facts safely.
• Roadmap: local models and reproducible benchmark cases will be added so provider/workflow quality can be measured and improved over time.

Install

go install github.com/overkazaf/re-agent/cmd/0xaf@v0.1.11
0xaf --version
0xaf --welcome

From source:

git clone https://github.com/overkazaf/re-agent
cd re-agent
make build
./bin/0xaf --version

go install ...@v0.1.11 is the recommended install path. @main can lag behind through the Go module proxy cache, and @latest resolves to the newest tag.

Requires Go 1.21 or newer (go.mod declares go 1.21, so no toolchain download is triggered). On macOS, older Go toolchains (1.21.x on macOS 26+) cannot produce runnable binaries because the system linker requires an LC_UUID load command — upgrade to Go 1.22 or newer if dyld: missing LC_UUID appears, or download the prebuilt binaries from GitHub Releases.

Prebuilt binaries are attached to every release tag by .github/workflows/release.yml (darwin/linux, amd64/arm64) — no Go toolchain needed:

# example: download and run the darwin-arm64 build of v0.1.14
curl -sL https://github.com/overkazaf/re-agent/releases/download/v0.1.14/0xaf-darwin-arm64 -o 0xaf
chmod +x 0xaf
./0xaf --version

If go install fails with //go:build comment without // +build comment

.../re-agent@v0.1.11/internal/app/repl.go:22:2: //go:build comment without // +build comment
.../re-agent@v0.1.11/internal/ui/live.go:23:2: //go:build comment without // +build comment

Nothing is wrong with those two lines — they are the imports of golang.org/x/sys/unix and golang.org/x/term. A Go toolchain older than 1.17 cannot parse the bare //go:build constraints those dependencies use, and it reports the failure at the import site rather than in the dependency. Check and upgrade:

go version          # need go1.21+
# then reinstall, e.g. via your package manager or https://go.dev/dl/

Quick Start

0xaf --smoke                    # offline wiring check, no API key required
0xaf --workspace ./demos/reverse-lab

Inside the REPL:

/scan artifact.txt
/decode auto ZmxhZ3s...
/policy
/help

The default route uses local CLIs when available. Check what 0xAF-Re can see:

0xaf auth status
codex login status
claude auth status --text

Inside the REPL, use /auth for the same check. Prefix raw CLI commands with !, for example !codex login status.

Basic Demos

Use the built-in demo workspace first, then replace paths with your own files.

Goal	Start With
Open the guided tour	0xaf --welcome
Verify offline wiring	0xaf --smoke
Start a demo workspace	0xaf --workspace ./demos/reverse-lab
Identify an unknown file	/scan ./chall
Check binary protections	/mitigations ./chall
Find packed or encrypted regions	/entropy ./chall
Carve embedded payloads	/carve ./blob
Decode a token or flag-like string	/decode auto ZmxhZ3s...
Inspect an APK	/apk ./app.apk
Check local RE tools	/retool inventory
Prepare mobile/API traffic capture	/retool mitmproxy template api.example.test
Ask for a solve plan	0xaf --role planner -p "triage ./chall and propose next checks"
Run delegated local evidence mode	0xaf --workflow caveman -p "triage ./app.apk"

The fast path does not need a model: /scan, /decode, /entropy, /mitigations, /carve, and /apk are direct local tools.

Worked Case: solve a challenge end to end

Everything below is a real run against demos/welcome, which ships with the repo. The plan text, the commands, the timings and the answer are copied from the session transcript — you can reproduce it with the same two lines.

Case A — no model at all

demos/welcome/chall.js compares your input against a token it builds at startup. Before asking anyone to think, look at the file:

0xaf --workspace ./demos/welcome

/read chall.js
# const key = 0x2a;
# const encoded = [26, 82, 75, 76, 81, 93, 75, 88, 71, 95, 90, 117, 78, 79, 73, 65, 87];

!node -e 'const k=0x2a,e=[26,82,75,76,81,93,75,88,71,95,90,117,78,79,73,65,87];console.log(e.map(v=>String.fromCharCode(v^k)).join(""))'
# 0xaf{warmup_deck}

!node chall.js '0xaf{warmup_deck}'
# accepted

That is the whole solve, at zero token cost. The same shape works on real samples: /scan to classify, /hex <file> 0x20 to read the header you care about, /carve to pull embedded payloads, /r2 <file> when you want a disassembler instead of an answer.

Case B — let the agent run the case

Same workspace, one sentence, and now you can watch it plan:

0xaf --workspace ./demos/welcome

Recover the expected token from chall.js, verify it by actually running the
checker, and explain how the check works.

The planner opens a route. codex writes four steps before any tool runs, and the HUD tracks them as they land:

PLAN 0/4 · via codex
  1  Locate chall.js and identify its runtime/checker interface
  2  Reverse the validation logic and derive the expected token
  3  Run the checker with the recovered token and capture the result
  4  Explain the check in concise solve notes

The executor works the steps. Every command is a real tool call against the workspace, gated by the policy and logged in order:

rg --files                              inventory the workspace
file chall.js                           classify the target
node -v                                 confirm the runtime exists
sed -n '1,240p' chall.js                read the check
sha256sum chall.js && wc -c chall.js    pin the exact bytes examined
node chall.js '0xaf{warmup_deck}'       accepted · exit=0
node chall.js 'wrong'                   rejected · exit=1

Note the last two lines. It did not stop at "the token decodes to X" — it ran the checker for a positive and a negative case, so the claim rests on observed behaviour rather than on reading the source correctly.

The answer arrives with its evidence:

Recovered token:   0xaf{warmup_deck}
Verification run:  node chall.js '0xaf{warmup_deck}'  → accepted, exit=0

How it works: chall.js:3 stores an integer array and XORs each byte with 0x2a.
Decoding that array gives 0xaf{warmup_deck}. The script then compares
process.argv[2] directly against that decoded string; exact match prints
accepted and exits 0, otherwise rejected and exit 1.

╰─ via codex · role auto · turns 1 · took 1m34s · in 162k out 2.2k think 895 cache 122k

What to watch while it runs

The turn is not a black box you wait on. During the run:

You want	Type this, mid-turn
See the model's reasoning, not just a 3-line tail	/think expand
Get the reasoning out of the way again	/think collapse
See every plan step, including the pending tail	/tasks expand
Line up the next question without interrupting	/queue add <text>
Fix a queued prompt before it runs	/queue edit <id> <text>
Swap the model for the rest of the session	/model executor <name>

Afterwards, /session prints the JSONL path. Plan snapshots, tool calls, results and token counts are all in there, in order — which is what makes a run auditable rather than merely impressive.

Reproducing this: a real planner and executor are needed for Case B. --smoke and the mock provider verify wiring offline, but mock does not plan and does not call tools, so it cannot produce the run above.

Workflow Modes

Workflow mode is explicit. Default off sends prompts unchanged.

Mode	Use When	Behavior
off	default	no workflow wrapper
auto	mixed machines	use specialist if a GPT Cyber / CC CVP-style route is configured, otherwise caveman
specialist	authorized cyber/CVP-style provider	plan, use skills and local tools, preserve evidence
caveman	ordinary providers	planner writes a bounded packet; executor starts fresh with a narrow read-only evidence toolset
research	survey work	survey public resources (web, GitHub, arXiv) and produce a sourced report
writeup	reporting	turn existing session evidence into a clean structured summary report
ctf	one concrete challenge	triage, plan, solve, and verify the exact flag on a single target
reverse	goal-driven RE	static + dynamic analysis toward the goal, ending with a verified core PoC
engineering	interface reconstruction	recover a target's protocol/schema into models, client stubs, and tests

/workflow auto
/workflow caveman
/workflow research
/workflow reverse
/workflow engineering
0xaf --workflow specialist -p "triage ./app.apk"
0xaf --workflow research -p "survey obfuscation papers on arXiv"

The "delegated local evidence mode" demo is the caveman workflow. It means the host splits one operator request into two model calls:

1. Planner phase: the planner sees the full authorized RE/CTF task and writes a short plan plus an EXECUTOR_PACKET.
2. Executor phase: the executor starts in a fresh isolated context. It sees only that packet, a dedicated executor system prompt, and a narrowed read-only toolset for local evidence.
3. Evidence collection: the executor can list/read/search files, identify file type, hash, strings, byte ranges, entropy, symbols/imports, mitigations, carved signatures, and APK structure.
4. Merge: 0xAF-Re appends both phases to the same session transcript and returns a combined planner->executor result.

auto is a resolver: it uses specialist when a GPT Cyber / CC CVP-style provider marker is configured; otherwise it selects caveman. True delegated caveman runs when role is auto and no provider is pinned. If you explicitly set /role planner, /role executor, or force one provider, 0xAF-Re respects that choice and only wraps the prompt.

Caveman mode is not translation, ciphering, or prompt laundering. It keeps the ordinary executor focused on workspace-local file facts and refuses unsafe live target, credential, persistence, deployment, or network work.

Context Compaction

Long sessions stay inside the provider budget two ways:

• Mechanical pass (every request): old tool-result bodies are elided and whole oldest exchanges are replaced by a compaction marker.
• /compact [provider]: folds the session into a dense briefing.

Set "compactionStrategy": "snapcompact" in agent.config.json to archive the dropped history as PNG snapshot frames instead of a text marker — the same idea as oh-my-pi's snapcompact. A vision-capable provider (Anthropic, OpenAI Responses, OpenAI-compatible chat) reads the frames back, so the detail is preserved rather than summarized. CLI providers and mock cannot attach images and fall back to the text marker / LLM summary automatically. Archiving is local and deterministic: no model call, no API key, no network.

About provider safety systems: 0xAF-Re does not bypass model policy checks or guarantee that a provider will not classify a turn. It reduces false positives for authorized local RE by changing what each role legitimately needs to see:

• the planner sees the full authorized objective and produces a bounded packet
• the executor sees only workspace paths and evidence-collection steps
• the executor tool list is read-only and local
• the session transcript keeps both phases auditable
• unsafe requests are refused instead of being hidden in alternate wording

Remote mode

Plan in the current window, execute on another box. --remote <name> (or /remote use <name>) puts the session into remote mode: run_command and !shell execute over a background SSH connection, and the model can call remote_exec on any saved host. Output lands in the same transcript as local work, and every remote command still passes the exec-tier approval gate with the host named in the prompt.

Quick start

# 1) save a machine (password prompt is never echoed)
/remote add lab dev@10.0.0.5
/remote add srv root@srv.local --key ~/.ssh/id_ed25519   # or key auth
/remote add box root@10.0.0.9 --insecure                 # lab box, skip known_hosts check

# 2) see what you have and pick the target
/remote list
/remote use lab

# 3) everything now runs on lab from the same window
!uname -a                       # shell escape -> ssh lab
0xaf --remote lab -p "inventory /opt"                    # or start straight into remote mode

# 4) let the model drive it
# (in the REPL, just prompt; run_command auto-redirects, or ask for remote_exec)

The model can also target a specific host regardless of the current one:

remote_exec(host="srv", command="systemctl status myapp")
remote_exec(command="ls /opt")       # host omitted -> current remote host

How it works

• Background connections that stay alive. Each saved host gets one persistent ssh.Client. --remote or /remote use connects immediately, /remote connect <name> connects on demand, and a first command dials lazily. Every connection is kept alive with a 30s keepalive and reused for all commands; all connections close when 0xAF-Re exits. The dashboard status row shows the established sessions: ssh lab ● (connected) or ssh lab ○ (selected, not yet connected), plus +N when more hosts are connected.
• Encrypted at rest. Hosts (including passwords) live in ~/.0xaf-re-agent/remote.json, AES-256-GCM encrypted with a machine-bound key (macOS IOPlatformUUID / /etc/machine-id + home + random salt, 0600 perms). Copying the file to another machine does not reveal credentials; OXAF_REMOTE_KEY (base64 of 32 bytes) overrides the key for portable setups.
• ssh -tt semantics. Remote commands (remote_exec, remote run_command, !shell) allocate a remote PTY by default, so interactive tools, sudo prompts, and anything that needs a terminal work. Set pty: false on a tool call for clean non-interactive output.
• Auth order: ssh-agent → configured private key path → password.
• Trust: strict ~/.ssh/known_hosts by default; /remote add --insecure is an explicit opt-in for lab boxes.
• Approvals: every remote command is exec-tier; the y/a/d/n prompt shows ssh <host> <command>.

Commands

Command	What it does
/remote / /remote list	list saved hosts, mark the current one
/remote add <name> <user>@<host>[:port] [--key <path>] [--insecure]	save a host (password prompt if no key)
/remote rm <name>	forget a host
/remote use <name> / /remote off	switch the execution target (use connects immediately)
/remote connect <name>	establish the background session now
0xaf --remote <name> …	start the session already in remote mode
remote_exec(host?, command)	model-facing tool for any saved host

Troubleshooting

• strict host-key verification needs ~/.ssh/known_hosts — add the host key with ssh-keyscan <host> >> ~/.ssh/known_hosts, or save the host with --insecure for lab boxes.
• no auth method — start ssh-agent (ssh-add ~/.ssh/id_ed25519), pass --key, or re-add the host and enter a password.
• Wrong-machine ciphertext — remote.json is machine-bound; on a new machine re-add hosts or set OXAF_REMOTE_KEY to the same key.
• Verified by tests — an in-process SSH server (x/crypto/ssh) exercises the real wire protocol: password auth, command execution, output, and rejection of bad credentials (internal/remote/ssh_integration_test.go).

Coming next: per-host file tools (list_files / read_file over SSH), SCP pulls, and multi-host fan-out of one plan.

Providers and Models

Planner, executor, and researcher are roles. Providers are replaceable seats.

/planner deepseek
/executor claude-api
/researcher grok
/agent auto
/model deepseek deepseek-reasoner
/model planner gpt-5.3-codex-high

HTTP providers use model overrides in the request body. Built-in CLI providers inject --model; custom CLI configs can use the {model} placeholder.

Role prompts are editable at runtime:

/prompt list
/prompt show planner
/prompt path executor
/prompt edit researcher
/prompt set executor <text>
/prompt reset system
/prompt reload

Editable targets are system, planner, executor, and researcher. /prompt edit seeds the file from the embedded prompt, opens $VISUAL or $EDITOR, and reloads immediately. With a detected project root it writes under prompts/; otherwise it writes under ~/.0xaf-re-agent/prompts/.

Minimal config override:

{
  "plannerProvider": "codex",
  "executorProvider": "claude",
  "providers": {
    "deepseek": {
      "type": "openai-chat",
      "model": "deepseek-chat",
      "baseUrl": "https://api.deepseek.com/v1",
      "apiKeyEnv": ["DEEPSEEK_API_KEY"]
    }
  }
}

Copy config.example.json to agent.config.json for a full local config.

Skills and Knowledge

Built-in skills cover common RE paths: CTF first pass, Android APK + Frida, native pwn/RE, Web/WASM crypto, radare2, Ghidra, JADX, Burp/mitmproxy, angr, Unicorn, unidbg, and local playbooks.

/skills
/skill android-apk-frida inspect this APK
/skill proxy-capture capture api.example.test traffic

Add your own skill:

export OXAF_RE_HOME=/path/to/re-agent
mkdir -p "$OXAF_RE_HOME/skills/my-unpacker"
$EDITOR "$OXAF_RE_HOME/skills/my-unpacker/SKILL.md"

Index local notes:

go run ./cmd/import-knowledge ~/notes/re ~/notes/ctf

Query them:

/know frida ssl pinning
/know raw frida ssl
/know read <entry-id>

Safety

Default policy:

• reads stay inside the workspace
• writes are off
• network commands are off
• credential-shaped paths are blocked
• destructive shell patterns are blocked

Useful flags:

0xaf --approval always-ask
0xaf --write
0xaf --allow-network
0xaf --yolo

Inside the REPL:

/policy
/approval

Troubleshooting

• Scrolling back shows many dashboard frames. The live pane redraws every 90ms (spinner + elapsed), and terminals/tmux keep every frame in the scrollback. This is normal for any animated TUI — nothing is stuck on screen. For a quieter scrollback: /refresh calm (500ms), /refresh off (redraw only on changes), or /flow off (no dashboard at all).
• CLI provider 'codex' failed with exit 1 / claude — the CLI itself is not authenticated. Run codex login / claude auth status outside 0xAF-Re, or route to an API provider with /agent deepseek / --planner deepseek.
• dyld: missing LC_UUID on macOS — your Go toolchain is older than the OS needs; use the prebuilt binaries from GitHub Releases or upgrade Go ≥ 1.22.
• --resume / /resume can't find the session — use the short hash shown in /sessions (prefix works) or the full timestamp id.

Common Commands

Command	Purpose
/help	command deck
/scan <path>	local CTF/file triage
/hex <file> [offset] [len]	hex view of a window; 0x offsets accepted
/decode auto <text>	try common encodings
/mitigations <path>	native binary protections
/r2 <file> [-w]	hand the terminal to an interactive radare2 session
/retool inventory	check radare2/JADX/Ghidra/Burp/mitmproxy/angr/Unicorn/unidbg availability
/retool angr template ./chall	emit an angr symbolic execution harness
/retool frida template android_ssl_pinning	emit common Frida SSL/crypto/root/debug/native templates
/retool mitmproxy template api.example.test	emit a scoped mitmproxy capture addon
/retool burp template mobile	emit a Burp mobile/API capture checklist
/queue list	show queued prompts
/queue edit <id> <text>	edit queued work before it runs
/queue cancel <id>	cancel queued work
/tasks collapse / /tasks expand	fold or expand the live task list
/refresh calm|off|ms	slower / no dashboard animation (quieter scrollback)
/think expand / /think collapse	fold or expand streamed reasoning, mid-turn
/prompt edit <role>	edit system, planner, executor, or researcher prompts
/new	clear the live session and start a fresh one (old transcript stays on disk)
/sessions / /continue / /resume <id>	resume prior work
!<command>	run a workspace shell command under policy

Roadmap

Where 0xAF-Re is heading:

• Remote mode (shipped) — background SSH to saved machines; next: remote file tools, SCP pulls, multi-host fan-out.
• snapcompact hardening — bundle a CJK-capable font, frame-cap UI, and per-provider image billing like oh-my-pi's snapcompact evals.
• Auto-resume prompt — detect an interrupted session at startup and offer to continue it before you type anything.
• Multi-host orchestration — run one plan across several boxes; collect outputs into the same transcript.
• Knowledge sharing — import/export the local index, team-shareable bundles.
• Benchmark harness — replay real sessions to measure provider/workflow quality, so routing choices improve from evidence.
• Plugin/skill marketplace — install community RE skills from a catalog.

More Docs

• Architecture map: exportable Cocoon AI-style overview of the design.
• Architecture deep dive: package map, turn sequence, context budget, approval gate, data formats, invariants, and extension points.
• Architecture diagrams: visual index for the core runtime.
• Module graph
• One turn sequence
• Context budget
• Approval gate
• Live pane
• oh-my-pi architecture note
• 0xAF-Re vs oh-my-pi
• Project page and marketing assets

Scoped for authorized CTF, lab, and local reverse-engineering work: binary triage, static inspection, local dynamic experiments, solve planning, and reproducible notes.