fak

fak — the Fused Agent Kernel

fak turns a tool-using agent into a managed agent.

The agent keeps its interface and model, while a fak kernel manages its model traffic, context lifetime, cache reuse, capabilities, and recovery.

Try the kernel without a key, model, or GPU

Audience: first-time evaluators checking whether fak can manage a tool-using agent.

For the shortest public proof, run one deterministic end-to-end check:

fak agent --offline

The proof passes when the comparison ends with task completed (booked) YES / YES, poisoned result blocked YES, and destructive op prevented YES. This offline mode uses a deterministic mock planner, so it verifies the managed-agent path and policy boundary without claiming live-model quality or latency.

Next action: run fak agent --offline and check those three output rows. For the expanded policy, routing, and benchmark sequence, use the reproduction packet.

One managed agent, two ways to run the kernel

A managed agent pairs Claude Code, Codex, opencode, or your own client—and its chosen model—with fak. The client keeps the task loop and user experience; fak owns the operational boundary around it: what context is retained, what work is reused, which tools may run, what results may return, and how the session recovers.

The roles stay separate: the agent or client owns the task loop and user experience; the fak kernel is the management plane; the model provider or server generates tokens. Change any one without replacing the others.

Where the kernel runs	Start here	Use it when…
Beside one agent	fak guard	You want a local launcher and supervisor for an existing agent. guard starts a private kernel gateway, points the child agent at it, and manages that session.
As an endpoint	fak serve	One or many OpenAI, Anthropic, or MCP clients need a durable kernel service. It can front an existing model server or load GGUF itself.
Entirely offline	Run the one-minute proof	You want to evaluate the managed-agent path without an API key, model download, or GPU.

Default: start with fak guard for one existing agent; choose fak serve when the kernel must be a shared or durable endpoint.

Both commands run the same kernel. guard is the convenient client-side lifecycle wrapper; serve is the standalone/server-side deployment. The model remains a replaceable backend—cloud API, local model server, or in-kernel GGUF.

flowchart LR
    A[Agent or client] --> G{How is it managed?}
    G -->|one local session| Guard[fak guard]
    G -->|shared or durable endpoint| Serve[fak serve]
    Guard --> K[the same fak kernel]
    Serve --> K
    K --> M[context + cache + recovery]
    K --> P[capabilities + result admission]
    K --> B[cloud API, model server, or GGUF]

For architecture, current evidence, and development workflow, start at START-HERE.md.

What the managed agent gains