fak documentation

Primary audience: people entering the documentation who need to choose a current route by job. fak is an agent runtime: the operator-controlled boundary for cache and context, model routing, tool authority, memory, observability, and native inference. Its technical architecture is the Fused Agent Kernel—an agent kernel shipped as one Go binary. Each operating mode exposes a documented subset of that boundary; use the claims ledger rather than the category label to decide what is shipped.

FAK coordinates the whole agent path, not isolated components. Start with the canonical architecture map for the five-layer observation → constrained-plan → typed-effect contract, then use the glossary to keep coordination, orchestration, scheduling, routing, and serving distinct.

Default next action: run the deterministic offline proof in the reproducibility packet with fak agent --offline. It needs no API key, model, or GPU and ends with checkable task-completion and blocked-operation results.

Choose your route

You are… Start here Use this route to…
Evaluating fak Reproducibility packet Identify the product, run the offline proof, then inspect its evidence.
Learning the whole system 8-module flagship course Follow one request across native inference, the agent harness, policy, context, memory, observability, and proof; use the 99-course learning path for prerequisite ordering and deeper study.
Building or integrating an agent or client Agent runtime Understand the category and ownership boundary, choose an interface, and follow the proposal-to-continuation flow.
Improving or comparing local inference Fak-native inference doctrine Keep native product work inside fak, classify explicit llama.cpp uses, and apply the matched-envelope rule.
Deploying or operating Deployment guide Choose an operating envelope, then configure and observe the service.
Contributing Contributor guide and developer tooling Find the owning document first, then build, test, change, and prove the repository under its current contracts.
Researching design or history Notes archive Find rationale and dated evidence, then check current code and tests before relying on it.

For a human role map, use START-HERE.md. Agents that need a compact authority map should use llms.txt. The exhaustive audience, task, and lifecycle catalog is INDEX.md.

Authority and lifecycle

This page is the current, public documentation landing page for the current generation. Runtime behavior is authoritative in code and tests; operational pages link to their owning commands and proofs. Pages marked experimental, simulated, stubbed, superseded, or historical describe a narrower lifecycle and do not override current authorities. Dated material under notes/ provides provenance rather than the default product contract.

This landing page supports route selection for the offline proof, managed runtime, integrations, HTTP service, policy floor, deployment, and contribution workflow. It does not establish availability for accelerator hardware or private control channels; those environment-specific routes state their own prerequisites and support boundary. Begin with the offline proof unless your task requires one of those envelopes.

Choose the smallest efficiency layer

What fak does

The everyday wins first — the reasons most people put fak in front of an agent:

And the tool-call control floor, for teams that need one (more in Tool-call controls):

See each win in one example

Each idea shrinks to a single worked example. The numbers trace to the benchmark authority; the live versions run on the demos page. Or watch the worked examples as a ~25-second reveal.

What fak is not

fak serve in proxy/gateway mode is not a claim that fak authored the upstream token engine. An explicitly selected vLLM, SGLang, llama.cpp, or hosted-provider route remains external inference while fak owns the agent boundary: which effects are allowed, which results may enter memory, when reuse is legal, what gets audited, and what survives a session boundary.

That gateway boundary does not turn the native engine into a permanent reference-only path. For local inference, fak-native is the product and performance path, intended to beat llama.cpp in matched, quality-constrained envelopes while retaining ownership of kernels, memory, scheduling, cache, adaptation, and operations. Current broad serving-speed claims still need a benchmark-authority row; the doctrine is the direction, not a substitute for evidence.

Tool-call controls

If a hard capability floor is why you’re here — not just a nice-to-have — this is the load-bearing idea.

Treat the model like an untrusted program, and the tool call like a syscall: the model proposes, the kernel disposes. Most agent security tries to recognize bad text. Recognizers help; they are not the floor. Prompt injection is a text game, and attackers get turns too. fak moves the load-bearing decision to the capability floor: a dangerous tool outside the allow-list cannot be called, no matter what the model was told.

Two independent gates matter:

The capability floor is the guarantee. Irreversible effects are unwired by default; untrusted bytes have to pass a gate before they become model context. Read Policy in the kernel, POLICY.md, and the security model.

Try it in 2 minutes (no key, no model, no GPU)

Get the binary — no clone, no Go toolchain. The installer detects your OS/arch, downloads the prebuilt static binary for the latest release, verifies its checksum, and drops fak on your PATH:

curl -fsSL https://raw.githubusercontent.com/anthony-chaudhary/fak/main/install.sh | sh
fak version          # prints the installed version, e.g. 0.34.0

Now prove the floor from the bare binary — these need no clone and no examples/ dir:

fak preflight --tool refund_payment --args "{}"   # -> DENY  (DEFAULT_DENY): unknown tool, fail-closed
fak preflight --tool search_kb      --args "{}"   # -> ALLOW: a read-shaped name is not blanket-blocked
fak agent --offline                               # runs one task twice — tools wired directly vs. behind fak — and prints the before/after

The dangerous action is refused by structure, before any model interpretation matters. Then wrap the agent you already run — one command, no rewrite, no key to start:

fak manage claude           # short: fak m claude; or: fak manage --provider openai -- opencode

Have the source already? From a clone you can skip the install and run the same proof against a named example floor, where the deny is by argument value: go run ./cmd/fak preflight --policy examples/customer-support-readonly-policy.json --tool refund_payment --args "{}". Full paths in INSTALL.md (one-line installer · manual download · Docker · build-from-source · Windows).

Learn more

Additional documentation routes

License: Apache-2.0 · Report a vulnerability · Keywords: fak agent runtime, Fused Agent Kernel, fak agent kernel, fak manage, fak serve, fak-certified, agent kernel, AI agent runtime boundary, long-session prompt cache, model routing for agents, MCP tool-call boundary, local GGUF, KV cache, addressable KV cache, self-hosted LLM, LLM agent fleet, agentic AI, Go.

Claude usage guides

Scoreboard debt discovery index

These links expose captured evidence and maintained scorecard/research clusters to the documentation crawler without changing their content or scorecard coverage.

Scoreboard debt discovery index

These links expose captured evidence and maintained scorecard/research clusters to the documentation crawler without changing their content or scorecard coverage.