fak — useful local agents, accelerated automatically

Fak is building the open runtime that makes useful local agents practical on your own machine.

Start locally, give an agent real work, and keep useful context across turns. Our first breakthrough milestone combines native inference, speculative decoding, and agentic caching into an experience whose qualified acceleration is automatic. The capability floor bounds what tools the agent may execute.

Status: this is the product milestone we are working toward. Today, automatic setup and cache reuse have specific model/backend limits; speculative decoding and physical GPU Direct paths are not universally enabled or qualified. See the local-agent milestone for the current wiring, the meaning of automatic, and the evidence required to earn the claim.

Try fak

Install with curl -fsSL https://raw.githubusercontent.com/anthony-chaudhary/fak/main/install.sh | sh (or go install github.com/anthony-chaudhary/fak/cmd/fak@latest).

Try the local workflow on a supported Apple Silicon configuration:

1. Start local inference (fak up): Probes unified memory with macfit to choose a model/context budget with headroom. Starts the local OpenAI-compatible endpoint on :8080 and opens an interactive chat REPL. Use fak up --mock to inspect the workflow without a model or GPU; mock output is not inference performance evidence.

   fak up
   # -> [READY] fak up running on http://127.0.0.1:8080
   

   Inspect the selected model/backend and memory budget before interpreting results. Apple Metal selection is automatic when the device and build support it.

2. Run agent work (fak opencode): In another terminal (or backgrounding fak up --headless), launch OpenCode:

   fak opencode
   

   Give OpenCode a parallel multi-agent prompt:

   "Using parallel subagents, audit the packages under internal/ and report their status"
   

   Compatible agents can reuse shared instructions and repository context. Inspect actual cache reuse and task outcomes; a fresh prefix still requires prefill, and reuse depends on model state, backend support, and cache identity.

3. Inspect the subagent benchmark:

   fak bench subagent --concurrency=4
   

   This does not replace a real coding-task acceptance witness. Check the benchmark's engine, execution regime, and receipt before treating its output as hardware evidence; simulated output does not qualify a physical device.

[!TIP] New to subagents? Follow the Subagents Guide to launch fak up and run parallel cohorts with shared-prefix cache reuse.

Governance for external agents (fak guard)

Already running Claude Code or Codex? Wrap the agent you already run with one command to add a default-deny capability floor. fak forwards Codex subscription credentials with no API key required and blocks tools outside the allowed policy without breaking the task:

fak guard -- codex

In-kernel policy adjudication checks every tool call in under a microsecond before execution. See the interactive showcase for a guided tour, or run fak agent --offline (# -> task completed) to inspect policy decisions with zero setup.

Latest hardware results — 2026-09-08

The front page shows one row per supported hardware family. Latest means the newest committed performance receipt for that platform, not the newest code change. A row can be historical or held when no newer quality-complete measurement exists. The table reports measured throughput with claim boundaries beside each result and links to its receipt.

Read the status column before comparing rates: results compare matched envelopes against explicit baseline runtimes on identical hardware.

Use the benchmark index for hardware history and model-specific results. Use BENCHMARK-AUTHORITY.md for claim boundaries and canonical receipts. For Mac local model setup and head-to-head Apple Silicon Metal measurements, see the Mac local models guide and the three-way Mac benchmark. For agent UI workflows, see the Mac agent UI guide.

Why run coding agents on fak

• Reuse the work behind each turn: Compatible prefix/KV caching avoids rebuilding shared instructions and context. The product target is automatic reuse across turns and compatible agents, with correct invalidation and isolation.
• Accelerate generation automatically: Native kernels, memory sizing, quantization, and speculative decoding are parts of one local workflow. The milestone requires qualified defaults; current MTP decoding requires explicit selection. See the implementation snapshot.
• Real-time multi-agent visibility: Inspect live cross-agent reuse rates, per-subagent token breakdowns, and savings sparklines directly in your terminal overlay (fak info / fak guard) to see and verify the speedup as subagents execute concurrently.
• Keep reusable state close to compute: Device-resident caching and direct GPU storage paths aim to reduce paging and copy overhead on supported hardware. GPU residency and physical NVMe-to-GPU DMA are different claims. The current claim ledger and milestone explain the wiring and qualification limits; a default-valued flag alone proves neither.
• Run on your own hardware: Native backends target Apple Silicon, AMD, and NVIDIA with different support envelopes. New native-performance work prefers Qwen3.8. Choose a supported model/backend and measure the actual local workflow.
• Default-deny capability floor: Protect your workspace from unintended commands, path escapes, or tool poisoning. Every tool call is verified against a capability floor before execution. Drop-in wrappers protect existing agents like Claude Code, Codex, OpenCode, and Cursor with zero rewrites.

Native inference provides direct execution on local silicon, with external engines supported as an explicit reference; see the native inference goal for details.

Default priorities & operating modes

fak is organized around a focused four-tier default priority hierarchy:

1. fak all in one (serving and harness + memory — the "one touch" thing): The primary focus is the automatic local-agent milestone: model serving, agent execution, capability-floor governance, and reusable context through one approachable runtime. Qualification requires a real task and independent acceptance evidence on a supported machine.
2. fak serving only: High-performance model inference runtime (fak serve), disaggregated gateway, KV-cache context acceleration, and native model execution.
3. fak harness only: Standalone agent governance (fak guard) with a default-deny capability floor and tool adjudication over external models.
4. other things: Standalone utilities, peripheral tools, benchmarks, and off-spine extensions.

Install and configure

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/anthony-chaudhary/fak/main/install.sh | sh

# Any host with Go 1.26+
go install github.com/anthony-chaudhary/fak/cmd/fak@latest

# Inspect the shipped profiles
fak agent profiles

Tune agent execution with built-in work and output profiles that cut token waste and resist unnecessary dependencies:

fak guard --output-profile caveman:medium --work-profile ponytail:high -- codex \
  "Remove the duplicate cache without adding a dependency."

Balanced defaults are ponytail:medium for work discipline and caveman:medium for concise responses. See work profiles, response profiles, or the harness guide to build a named agent on the runtime.

Going deeper

Apache-2.0 licensed.