fak

What fak does

fak is a Go command line tool that wraps an existing agent harness so you can keep using the same Codex login and models you already have, but with a configuration chosen for the task at hand. The project states a native inference goal of beating llama.cpp in quality-constrained envelopes, and it treats llama.cpp as a benchmark, diagnosis, and interoperability reference rather than as a silent fallback. Instead of pinning one fixed pile of prompts, tools, permissions, and model settings, fak places one boundary in front of your agents and manages their context, models, tools, and a record of what happened. You install it with a curl script on macOS and Linux, or with go install on any host running Go 1.26 or later. After install you can run `fak agent profiles` to see the shipped configuration levels without needing credentials or making a model call. The README shows two concrete shapes of the same command. For a small coding change you run `fak manage --output-profile caveman:medium --work-profile ponytail:high -- codex` with a request to remove duplicate cache without adding a dependency. For a risky investigation you run the same harness with lighter simplicity pressure and room for a fuller explanation. The wrapper is thin. It does not replace your agent loop. It configures it, and the boundary keeps a consistent record of actions, tool calls, and model choices across runs so each run stays comparable to the last. The install paths mean a team can adopt fak without leaving their existing Codex account, which lowers the barrier for trying it on a real task rather than a toy example.

Profiles you control per run

fak exposes two axes you tune for each run. Ponytail controls how strongly the agent resists avoidable code and machinery. Caveman controls how compactly it reports back. For a small coding change you can ask Ponytail to push toward the smallest correct implementation and Caveman to keep the answer compact. For a risky investigation you use the same Codex harness with lighter simplicity pressure and room for a fuller explanation. The profiles never remove explicit requirements, safety checks, tests, diagnostics, or evidence. They change pressure and length, not the facts of the task. Running `fak manage -- codex` uses the balanced ponytail:medium plus caveman:medium defaults, and you can change either axis per run. Use `standard` or `full` to turn that axis off. The command `fak guard` remains a compatible name for `fak manage`. This design means one harness serves many jobs. A quick fix and a deep trace share the same boundary, the same tools, and the same history, but they differ in how tightly the agent trims its work and its words. The result is a single place to reason about what an agent did, no matter how large or small the request, with the profiles recorded as part of that history for later review. Because the profiles are recorded, a later reviewer can see which pressure and length settings produced a given run, which helps when comparing agent output across different attempts.

Building your own harness

When per-run configuration is not enough, fak can generate a small harness whose identity, instructions, and tools you own. You run `fak harness init` with a directory and a module path, then `go run ./cmd/microharnessdemo --selfcheck` to verify it. The generated product uses fak's managed boundary without forcing you to assemble an agent loop from scratch. The harness guide explains the rest when you are ready to customize it. This is the path for teams that want a reusable agent with a fixed set of tools and a fixed voice, rather than a one-off command. The README also points to detailed pages for choosing Ponytail and Caveman levels, inspecting or changing console settings, connecting another agent or model, understanding what fak manages, and improving or comparing local inference. There are pages on the fak-native inference doctrine and performance routes, plus claims, benchmark authority, and security notes. Builders can use the Go API, the harness contract, and the contributing guide. Together these pages let a reader move from a single command to a maintained internal agent without leaving the documentation set, which keeps the barrier to adoption low. The harness init path is aimed at teams that want a maintained internal agent rather than a throwaway command, since the generated code keeps the same managed boundary for every call.

How fak fits your setup

fak is built to sit next to tools you already run. The README lists integrations with Codex and Claude Code, and a page for all integrations, so the boundary can manage more than one agent or model. The project ships a CLI first, with console settings you inspect or change through documented commands. Because the wrapper keeps the same Codex login and models, adopting fak does not mean migrating your account or retraining a model. You add a thin configuration layer and keep your existing workflow. The interactive preview and the front-page archive give a reader a feel for the product before installing. The documentation index collects every page in one place. For someone evaluating agent tooling, the practical question is whether a fixed prompt pile is doing too much. fak answers that with per-task configuration and a shared record, written in Go and released under the Apache-2.0 license, with the boundary as the one stable part of every run you make. The boundary is what lets a small edit and a careful investigation use the same harness without confusion. The CLI first design also keeps fak approachable for scripting, because the same commands a person types can be run from a shell inside an automation step without extra wrappers.

Editorial conclusion

fak is written in Go, distributed under the Apache-2.0 license, and its repository was last updated on 2026-08-24.