What fak supports

fak is an agent kernel: one Go binary that sits between an AI agent and the tools it calls. Two facts decide what it supports.

            AI agent (harness / framework)
                        │
                        ▼
        ┌───────────────────────────────────┐
        │     fak — the agent kernel          │
        │  fronts the wires your stack speaks │
        │  (OpenAI · Anthropic · Gemini · MCP │
        │   · xAI); governs, does not generate│
        └───────────────────────────────────┘
                        │
        ┌───────────┬───┴───┬───────────┐
        ▼           ▼       ▼           ▼
  ┌─────────┐ ┌─────────┐ ┌──────┐ ┌──────────────┐
  │ engine  │ │ cloud / │ │ APIs │ │ in-kernel     │
  │ Ollama· │ │ hosted  │ │wires │ │ reference     │
  │ vLLM·   │ │ provider│ │· MCP │ │ engine        │
  │ SGLang· │ │         │ │      │ │ (correctness, │
  │ llm-d·  │ │         │ │      │ │               │
  │llama.cpp│ │         │ │      │ │  not a server)│
  └─────────┘ └─────────┘ └──────┘ └──────────────┘
   The pages below: Models · Features · Clouds · APIs/MCP ·
   Harnesses · Serving engines — each grounded in the repo
   and the sourced compatibility matrix.

Index map: the kernel fronts the wires, then each page lists one supported category.

1. It fronts the wires your stack already speaks — OpenAI Chat Completions, Anthropic Messages, Gemini generateContent, and MCP, plus an xAI upstream. Anything that lets you set a base URL drops the gate in front with no code change. So the supported set of harnesses, clouds, and engines is wide by construction.
2. It governs, it does not generate. For production tokens fak fronts an engine (Ollama, vLLM, SGLang, llm-d, llama.cpp, a cloud API). It also ships an in-kernel reference engine that runs a model itself, as a correctness reference rather than a fast server.

Each page below is the dedicated list for one category. Every row is grounded in the repo or in the sourced compatibility matrix, and status follows the witnessed claims ledger.

The pages

Page	What it lists
Models	Any model you front through the gateway, plus the architectures the in-kernel engine runs and proves bit-exact (Llama, Qwen2/Qwen3, Gemma, GLM-MoE, GPT-OSS, SmolLM2).
Features	Every capability grouped by subsystem with its honest status — shipped, simulated, or stub — mirroring the claims ledger.
Clouds & hosted providers	Anthropic, OpenAI, Gemini, and xAI as native provider wires, plus AWS Bedrock, Google Vertex AI, Azure OpenAI, OpenRouter, Together, Groq, and Fireworks over the OpenAI-compatible wire.
DeepSeek V4	The three DeepSeek V4 routes (hosted OpenAI-compatible, Anthropic-compatible, self-hosted vLLM/SGLang/NIM), the thinking-mode caveats, the self-hosted GPU-node bring-up path, and the deepseek-chat/deepseek-reasoner alias-retirement warning.
APIs, wires & MCP	OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, Gemini, xAI; MCP over stdio and HTTP; the fak-native endpoints; and the honest interop stance on A2A, AG-UI, ACP, ANP.
Agent harnesses & frameworks	Claude Code, Cursor, OpenAI Codex, OpenCode, Aider, Cline, Roo, Goose, Zed, and frameworks like LangChain, LlamaIndex, CrewAI, AutoGen, and the Vercel AI SDK.
Serving engines	The token engines fak fronts — Ollama, vLLM, SGLang, llm-d, llama.cpp, LM Studio — and the in-kernel reference engine.
Backend selection	The operator decision route for remote model servers, the local CPU reference path, external GPU engines, and in-kernel CUDA or Vulkan backends.
Silicon backends	The vendor-neutral backend path for accelerator teams: compute.Backend, Caps, correctness classes, backend conformance vocabulary, and non-reference gates.

Related references (the sourced detail behind these pages)

• Deploy fak on a rented GPU cloud — the opposite shape from Clouds & hosted providers above, and the one readers most often land on by mistake: not fronting someone else’s hosted API, but standing the gateway up on a GPU you rent from CoreWeave / Lambda / RunPod / Crusoe / Vast.ai / Nebius — in-kernel on the card, or proxying a co-located vLLM/SGLang. Every provider row is honestly marked not yet end-to-end witnessed.
• Compatibility matrix — 47 surveyed harnesses, frameworks, backends, and protocols, each with the wire it speaks, whether it takes a custom base URL, and the exact repoint key, with a source link per row.
• Integration index — the “repoint one base URL” recipe and the 60-second offline proof.
• Hardware matrix — every machine fak has been profiled on: 4 platforms, 2 CPU ISAs, 4 GPU backends (Apple Metal, AMD Vulkan, NVIDIA CUDA Ada + Ampere).
• Hardware portability via the compute HAL — how accelerator backends bind into fak by registration rather than by forking the forward pass.
• CLI reference — every fak verb and what it does.
• Claims ledger · Status — what is shipped, simulated, or stub, and what is on the critical path.
• llms.txt — the machine-readable doc map for LLMs and answer engines.