cmd/

Command a2ademo is a no-key, no-model proof of fak's in-kernel agent-to-agent message channel (internal/a2achan): one capability-floored, Ref-backed mailbox delivering an addressed value from one agent to another — adjudicated by the SAME default-deny floor that gates a tool call.

Command agentbenchdemo is the performance micro-benchmark of fak's agentic spine: how much does the kernel's per-tool-call adjudication actually COST? It folds a fixed plan of tool calls through the REAL kernel (the same internal/agentdemo path cmd/timewolfdemo and `fak preflight` use — adjudicator.Default.SetPolicy + a live kernel.Fold per call), times the loop, and reports the per-call adjudication cost — the "self-tax" the safety floor adds to an agent's critical path.

Command agentdojoredteam runs the dynamic AgentDojo-style red-team battery (internal/agentdojo) against the stacked defense and prints the PER-ATTACK verdict stream, then folds every outcome into a frozen harvest LabelRow corpus.

Command agenticbench emits the #868 parent rollup over committed agentic benchmark artifacts.

Command attnsnrsi closes the attention-S/N RSI loop in SHADOW (#867).

Command batchbench measures the AGGREGATE decode throughput of the multi-user batched decode (internal/model.BatchSession) as a function of batch size B — the "continuous batching" / multi-user serving regime MODEL-BASELINE-RESULTS.md scoped out as "vLLM's claim, not fak's".

Command browseractionbench runs a browser/computer-use action-mediation smoke through fak adjudication.

Command cachedemo renders the multi-turn shared-cache-savings demo: it reads the durable, WITNESSED gateway-usage and cache-savings ledgers and tells the per-turn story of how a single fak-guarded coding session earns cache value across turns — the provider prompt cache reading a stable prefix back, AND fak's own authored slice (per-fire compaction trim + tool prune) holding the re-sent window inside budget.

Command causalbench is the end-to-end demonstrator for fak's CAUSAL invalidation-on-external-write: a tool RESULT cached under an external world-state witness (a git commit / blob hash / etag) is evicted byte-exact — and only it — the moment a later external write REFUTES that witness, while every sibling cached under an unrefuted witness stays warm.

Command cfgprobe prints the MoE/dense FFN config axes a GGUF resolves to, so a dimension bug (e.g.

Command codesearch is a standalone front door to the epic #3434 code-intelligence engine (internal/codesearch): trigram regex/literal search, AST shape queries, call-graph traversal, and RRF-fused feature retrieval over a Go tree.

Command conceptbench is the runnable wrapper for the FAK-concept fidelity benchmark (epic #2721, issue #2740): it runs a set of models against a set of fak-concept tasks (stamp/lane/refusal/verdict/handoff/witness) and emits a fak.conceptbench.report.v1 carrying a per-(model x concept) pass@1 leaderboard behind the #868 result-claim honesty gate.

Command ctxbench runs the fak security gates over a corpus of tool calls and tool results.

Command ctxdemo is the live, on-box demo of fak's value in the MULTI-AGENT, MULTI-TURN, LONG-CONTEXT regime — the one where the context CHANGES every turn as tool calls land heterogeneous, variable-sized results.

Command ctxplanbench measures the ctxplan planned VIEW over REAL Claude Code session transcripts — the empirical counterpart to internal/ctxplan/scaling.go's synthetic Params model (issue #559).

Command ctxplandemo is the runnable demonstrator for the context PLANNER: it treats the current turn as an O(1) materialized VIEW over a lossless history store, and shows the three things that make that more than a slogan —

Command cxlpooldemo is a no-model, no-GPU proof of the value a SWITCH-POOLED, multi-host shared memory tier (a CXL.mem / CXL-switch pool) adds to fak's hardware-aware cache once a KV cache is shared across a FLEET of tenants — the multi-tenant counterpart of cmd/hwcachedemo's single-stream demote-not-evict proof.

Command deletioncert is the end-to-end demonstrator for fak's provable-deletion receipt.

Command demorace is the live, on-box demo of fak's value point: REUSE.

Command diagtok is a throwaway diagnostic: it loads a GGUF via the same path simpledemo uses, then (1) round-trips a known string through the embedded tokenizer and (2) greedily decodes a ChatML prompt while printing each raw token id next to its decode.

guard.go — front each dispatch worker with the kernel (`fak guard`), a Go port of the dogfood-guard family in tools/dispatch_worker.py.

Command dojorsi is the dojo-RSI loop's WORKTREE ARM — Phase 2 of docs/fak/dojo-rsi-loop.md (issue #1024).

Command dropindemo is the splashy, on-box demo of fak's DISTRIBUTION story — the "drop-in" entry point.

cron.go projects the in-kernel loop schedule DOWN to a real OS scheduler unit (#765, part of the `fak cron` sub-epic #749).

Command fak-deepswe-runner emits deterministic DeepSWE adapter fixtures for SWE-bench runner-contract tests.

Command fakc is the one-word Codex launcher for fak.

Command fakchat runs an end-to-end chat completion with fak's OWN in-kernel engine — no llama-server, no external proxy.

Command fanbench runs the ONE-MASTER-GOAL → N-SUBAGENT fan-out sweep — the orchestrator-worker topology (one lead decomposes a goal, spawns N sub-agents, folds their results) swept from N=1 to N=1000+, the regime no public benchmark maps (see experiments/fanout/RESEARCH-BRIEF-fanout-2026-06-17.md).

Command fanrun runs the MEASURED one-master-goal → N-subagent fan-out — N actual agent.RunArm sessions, each a real loop through a real kernel with the vDSO fast path on and real tool dispatch, all decomposing ONE shared research goal, WALL-CLOCKED — swept from N=1 to N=1024.

Command fleetbench runs the 2-D turn-tax sweep — turns-per-agent (T) × fleet size (A) — over the REAL kernel and writes the surface as JSON + CSV for curve fitting.

Command fleetctl is the public, transport-agnostic control surface for a fleet of boxes — GPU servers, worker nodes — an operator drives over the private Slack control-bridge.

Command fleetserve measures the CROSS-AGENT SHARED-PREFIX fleet workload — the regime where fak's kernel-owned KV cache structurally beats a per-slot serving engine (llama.cpp) by more than 2×, not by a faster kernel but by NOT REDOING WORK.

Command gemma4diag loads a gemma4 GGUF ONCE and sweeps the uncertain forward axes (softmax scale 1.0 vs 1/sqrt(d), rope_freqs on/off, decoder-norm plain vs (1+w)), printing the top-k next-token predictions for a fixed prompt under each.

Command ggufprobe dumps a GGUF file's architecture using fak's own internal/ggufload parser — no llama.cpp.

Command glmcfgdiag is a cheap, no-reload GLM-5.2 config witness: it opens a GGUF shard's metadata, runs ggufload's real Config() derivation, and prints the MLA per-head dims (QKNopeHeadDim / VHeadDim) plus the latent ranks.

Command glmdsatput measures fak's NATIVE GLM-5.2 (glm_moe_dsa) decode throughput on a real compute backend (e.g.

Command gpucheck is the real-model correctness witness for the GPU backend: it loads a HuggingFace safetensors checkpoint (e.g.

Command guarddemo is the live, on-box demo of fak's SAFETY FLOOR — the moat — shown as a TRUE side-by-side: the SAME adversarial tool-call trace replayed down two columns at once, WITHOUT fak (left) and WITH fak (right), so the divergence lands in one glance.

Command hwcachedemo is a no-model, no-GPU proof that fak's cache is hardware-aware: it shows the residency-tier ladder with each tier's physical character, which tiers can be shared ZERO-COPY, and — the headline — how the placement policy DEMOTES a hot KV prefix to CXL far memory under pressure instead of EVICTING it and paying a full re-prefill later.

Command kpiprobe prints the RSI loop's demo KPI — the deterministic LRU hit-rate (internal/rsiloop.HitRate) over a fixed reference trace — as a single `KPI=<float>` line the loop's worktree Measurer parses.

Command lensviz is a visual next-token debugger for fak's own in-kernel engine.

loadgen drives an OpenAI-compatible /v1/chat/completions endpoint at a sweep of concurrency levels and reports throughput.

Command longctxbench renders the EXACT, contention-free work floor for the ULTRA-LONG-CONTEXT regime (per-agent context > 100k tokens) — the proof that the fused agent kernel's reread-elimination win holds (and grows) where it matters most, computed as closed-form arithmetic from the session shape and the model geometry.

Command loophealth is the checking layer for fleet's RSI self-improve loop (#382).

Command memqdemo is a no-model, deterministic walkthrough of the memq memory- operation algebra: the substrate that lets an agent author its OWN memory strategy (render / clean / compact / dream / a novel one) instead of the kernel hardcoding a single compaction path.

Command modelbench measures the in-kernel pure-Go forward pass latency so the fusion lane has a HONEST throughput baseline to set against the next-best ways to run the same model (HF transformers; see bench_hf.py for the witness side).

Command modelprof is the in-kernel forward pass inspecting ITSELF: it runs the modular bottleneck profiler (internal/model/profile.go) over a real decode and a real prefill, plus an uninstrumented Session.Step decode measurement.

Command negframescan is a throwaway harness (NOT shipped) that exercises internal/negframe against real repo prose while cmd/fak is wedged by unrelated in-progress breakage elsewhere in the tree.

Command o1proof1b witnesses the ctxplan->kvmmu O(1) residency bridge (CLAIMS.md:141, issue #550) at a scale close to a real ~1.5B-parameter model, entirely on this machine: no network, no GPU, no HuggingFace export.

Command paritybench assembles the CROSS-MODEL parity artifact: it ingests the live fak-agent A/B reports for a ladder of LOCAL models (produced by tools/run_local_model.sh via the OpenAI-compatible shim) plus the committed FRONTIER reference cards (hosted Claude Haiku/Sonnet, measured + graded on the same frozen task), scores every card on the three never-blended axes (capability / safety / cost), and emits the parity table.

Command pipelinegen runs fak's NATIVE engine generating tokens across pipeline-parallel stages — the runnable form of the cross-device transport contract (internal/model/pipeline.go).

Command poisonedmcpdemo is the runnable A/B for issue #573: it proves fak walls a tool-poisoning MCP server off the model by STRUCTURE, with no model/key/network.

bench.go is the measured-numbers half of polymodelbench — the runnable artifact for issue #535 ("bench(polymodel): measured numbers for the poly-model lane").

Command prefixlint is the §A3 prefix-stability devtool (GLM52-HOSTED-CACHE- COHERENCE): it reads a recorded conversation and reports the provider-cache consequence — how many prompt tokens are cacheable across the session, how many are re-billed, the specific turn where the prefix broke, and the recoverable uplift from fixing volatile-ahead-of-stable ordering.

Command q4kdiag runs the P1 Q4_K correctness diagnostic for a GGUF model.

Command q8bench is an INDEPENDENT verifier for the int8-quantized in-kernel forward path (internal/model: Model.Quantize + Session.Quant).

Command q8kernel is a self-contained kernel microbenchmark that isolates ONE question from all model/WSL/load overhead: in pure Go on this box, which GEMV kernel is fastest for the memory-bound batch-1 decode regime —

Command qwen35check loads a Qwen3.5 / Qwen3-Next hybrid HF snapshot with fak's own in-kernel forward pass and greedy-decodes a few tokens from a given prompt (token ids), printing the generated ids.

Command radixbench benchmarks fak's KV-cache prefix reuse against SGLang's RadixAttention (arXiv:2312.07104 / NeurIPS 2024) on the metric SGLang's own paper headlines: CACHE HIT RATE — the fraction of prompt tokens served from cache instead of recomputed.

Command repoguard refuses a DESTRUCTIVE or out-of-tree write before it escapes the repo — the Go port of tools/repo_guard.py, run as a single compiled binary so the Claude Code PreToolUse hook fires WITHOUT spawning a Python interpreter on every tool call (DIRECTION.md: the request path stays interpreter-free).

Command rsicycle drives ONE recursive-self-improvement keep-or-revert decision through fak's own non-forgeable keep-bit (internal/shipgate.Evaluate).

Command rsiloop is fak's TRUE recursive-self-improvement loop — the closed-loop companion to cmd/rsicycle's one-shot.

Command sessionbench measures the NET VALUE-ADD of the fused agent kernel on a realistic long, multi-agent session — the regime the whole fusion exists for, and the one a per-call / per-turn naive setup pays for dearly.

Command simpledemo is the friendliest way to chat with a local AI model.

Command terminalbench runs a Terminal-Bench-shaped command-boundary smoke through fak adjudication.

Command timewolfdemo is the fun, lowest-common-denominator AGENTIC demo: a one-tool agent asked "what time is it, Mr.

Command tokendemo is the self-contained demo of two CLEAR WINS the kernel's tool-call understanding delivers — counted call by call, each grounded in a LIVE kernel verdict (the kernel decides; this demo only counts).

Command toktdiag reports whether fak can extract an embedded GGUF tokenizer.

Command toolsandboxbench runs a tau3/ToolSandbox-shaped policy-state adapter smoke through fak adjudication.

Command topobench runs the FLEET-TOPOLOGY genome search (issue #541) — the orthogonal STRUCTURE-search axis to the policy-genome search (#503).

Command tpcheck runs fak's NATIVE-engine TENSOR-parallel decomposition end to end over SIMULATED ranks (single box, in-memory, no GPU/NCCL/checkpoint) — the runnable form of the intra-layer sharding contract (internal/model/tensor_parallel.go).

Command trychatdemo is the "try it" agentic chat: type a message and a tiny tool-using agent answers — but every tool call it makes is adjudicated by the REAL fak kernel first (the same internal/agentdemo path cmd/timewolfdemo and `fak preflight` use).

Command turntaxdemo is the live, on-box demo of how fak SAVES MODEL TURNS.

Command unseedemo is the live, on-box "Un-See It" demo (a.k.a.

Command wdcheck is a THROWAWAY verifier for the info_watchdog.go pure mappers, run only because cmd/fak currently cannot build (unrelated in-flight `wip land` work).

Command webbench-convert converts WebVoyager tasks into fak's webbench format.

Command webbench-run is a reproducible end-to-end webbench runner.

Command webbench-token-measure measures actual token usage from model API runs.

Command wfmembench is the workflow-memory benchmark for issue #434.