# Frazer docs

> Guides, references and procedures for Frazer, the `frazer` CLI, Fir and the `fir` CLI, the API and the MCP server. Every page below is Markdown.

Part of the docs for agents; start at https://frazer.ai/llms.txt. The parts agents use most have their own index, each with a full-text file small enough for one fetch:

- [Frazer CLI](https://frazer.ai/docs/cli/llms.txt): the `frazer` command line and the contract both CLIs follow for agents: install, sign in, the grammar, output modes, the JSON error envelope, exit codes (13: needs a person, 14: stopped at your limit), streams, help as data and `help search`, and every command by product
- [Frazer for agents](https://frazer.ai/docs/for-agents/llms.txt): start here: set yourself up, the rules every change follows, the facts models most often get wrong, and the tasks agents are asked for most, step by step
- [Fir](https://frazer.ai/docs/source/llms.txt): Frazer's version control and the `fir` command line: workspaces, pull requests and their views at 10,000 to 50,000 a day, versions, stacks, the plan's levels above them and conflicts, merges and undo, and every `fir` command
- [Auto-merge, the merge queue and issues](https://frazer.ai/docs/source/merge-queue/llms.txt): how 10,000 to 50,000 pull requests a day merge: auto-merge's seven conditions and its receipt, controls and one freeze record, release approvals bound to content, the merge queue's partitions, test batches and agents' own fixes at hotfix priority, audits sized by statistics; issues with evidence and capture approvals, filed by the monitoring agent and fixed by the fix agent
- [Fir sessions](https://frazer.ai/docs/sessions/llms.txt): one record of every agent's work, for any agent: the log compaction never shortens, one protocol, required for an agent's commits and suggested for people's, resume anywhere and rewind with nothing deleted, erasure with a receipt, and what Frazer learns only on your opt-in
- [Plan repositories](https://frazer.ai/docs/source/plans/llms.txt): plans, specs, decisions, milestones and every engineering record in Fir: both homes, links and Why for any line, record types and the type language
- [Programs and person tasks](https://frazer.ai/docs/source/programs/llms.txt): programs of any depth: the tree, Today, the Map, the readout and Do next, forecasts with people's waits in them, milestones and squads; and person tasks, the work only a person can do inside a plan
- [The planning flow and its loops](https://frazer.ai/docs/source/planning-flow/llms.txt): how plans are checked on Frazer CI (static first), cold-reviewed, scored, improved by loops of agents that run by default (fix, elevate, confirm) and approved, what happens when funds run out, and how outcomes become learned checks
- [Decisions](https://frazer.ai/docs/source/decisions/llms.txt): decisions inside plans: raised with a recommendation, weighed by a panel of other model families, a calibrated confidence, the decision's own page, auto-apply rules, decisions at scale and by conversation, principles learned from a person's own answers, what decisions bind, history only at the level a task needs, and Frazer Decisions
- [Frazer Agents, harnesses and skills](https://frazer.ai/docs/agents/llms.txt): agents Frazer hosts, wakes and supervises; the harness every use runs on, chosen per use with the Frazer harness as the default, and the Lab that tries, compares, simulates and calibrates harnesses; skills imported, synced, locked per session, tracked and improved
- [Agent squads and campaigns](https://frazer.ai/docs/squads/llms.txt): squads of agents and people toward an objective; campaigns started by an agent for a person, the campaign policy, the controller that admits every task, supervision with no person, successors that bring memory back, the campaign board and simulations
- [Frazer QA and Frazer Browsers](https://frazer.ai/docs/previews/llms.txt): templates and preview environments for every workspace, pull request, stack, plan level, program or past moment; what a change affects, smoke, full and pre-release test plans, test runs and results as evidence; browsers agents drive, logins as personas, flows, reruns and reproductions
- [Frazer Reviewer](https://frazer.ai/docs/reviewer/llms.txt): code review, security review and cold review with one engine; lanes in nine groups, items reviewed blind by squads, the verdict auto-merge reads with independent evidence, every review remembered, outcomes linked back as told or missed, and misses that become better lanes
- [Frazer Context and agents' sessions](https://frazer.ai/docs/context/llms.txt): what an agent session receives and how it is proved: the platform every product calls, ranking with rules first, summaries, compaction that keeps what binds, verify, the old-value check, receipts, the rerank API; how a session works from a plan; and what agents get from Frazer
- [Frazer API, MCP and errors](https://frazer.ai/docs/api/llms.txt): the API, the MCP server, every error reason with its fix, events and webhooks, Terraform and OpenTofu

The [docs home](https://frazer.ai/docs.md?from=llms-txt) has the quickstarts, the products by area and the references.

## Get started

- [Bring your first server](https://frazer.ai/docs/quickstarts/first-server.md?from=llms-txt): Add a server with one command, see it in a pool.
- [Create a Kubernetes cluster](https://frazer.ai/docs/quickstarts/kubernetes-cluster.md?from=llms-txt): Plan, apply, open GitOps.
- [Deploy serverless with Postgres](https://frazer.ai/docs/quickstarts/serverless-postgres.md?from=llms-txt): From a repository to a URL with a database.
- [Deploy an open model](https://frazer.ai/docs/quickstarts/open-model.md?from=llms-txt): gpt-oss or Llama on your GPUs or the fleet.
- [Give your team devboxes](https://frazer.ai/docs/quickstarts/devboxes.md?from=llms-txt): Templates, policies and one-click open.
- [Connect your environment repo](https://frazer.ai/docs/quickstarts/environment-repo.md?from=llms-txt): GitOps with the Frazer Reader app.

## Compute

- [Servers and pools](https://frazer.ai/docs/servers.md?from=llms-txt): Bring your own servers or rent them from Frazer, accept each one, group them into pools and share their capacity with the projects of your organization.
- [Kubernetes](https://frazer.ai/docs/kubernetes.md?from=llms-txt): Give each project its own Kubernetes cluster on your servers, plan every change before it applies, and deploy workloads from Git through the cluster's own Frazer GitOps.
- [Serverless](https://frazer.ai/docs/serverless.md?from=llms-txt): Deploy a repository or an image as a service that scales with requests, run jobs to completion, and create the database, cache, bucket and model route an app needs as one stack, on your servers or the Frazer fleet.
- [VMs](https://frazer.ai/docs/vms.md?from=llms-txt): Create virtual machines on your own servers or the Frazer fleet from a plan, with machine types, images, local or replicated disks, SSH sign-in and instance groups.
- [Devboxes](https://frazer.ai/docs/devboxes.md?from=llms-txt): A devbox is a virtual machine per engineer, team or agent, built from a template on your servers or the Frazer fleet; create one, give a team boxes with one policy, and open it from the Frazer app, any IDE or SSH.

## Build and ship

- [Fir](https://frazer.ai/docs/source.md?from=llms-txt): Frazer's version control, built for agents. Repositories, branches and pull requests in the words you know, a server-side workspace per session, versions of every pull request, stacks, a merge queue per protected branch and an undo for every step.
- [Plan repositories](https://frazer.ai/docs/source/plans.md?from=llms-txt): Plans, specs, decisions, milestones and every engineering document as records in Fir, stored in the code repository's tree or in a plan repository, read through one index, linked to every commit and pull request without anyone typing, and answering why any line of code exists.
- [Record types](https://frazer.ai/docs/source/record-types.md?from=llms-txt): Record types in Fir: any file may live in a plan's home, typed or not; twenty-two built-in types and packs; your own types in YAML with JSON Schema fields and CEL rules, versioned with lossless conversion; made in the editor, by pasting YAML or by asking an agent.
- [Programs](https://frazer.ai/docs/source/programs.md?from=llms-txt): Programs in Fir: plans of any size as one tree with no fixed depth (program, plan, phase, section, item by default), Today for the person signed in, the Map that shows a whole program on one screen, a readout and Do next that say what to do first, forecasts with people's waits in them, work only a person can do on every view, lists that stay compact at 1,000 and 10,000 items, insights from stored rows, milestones that count only proven merges, and many squads and models working one program.
- [Person tasks](https://frazer.ai/docs/source/person-tasks.md?from=llms-txt): Work only a person can do, inside plans: nine kinds (share a key, connect an account, provision, register, buy, confirm a fact, hands-on work, an opinion, a contact), agents first, a static check that finds them while the plan is drafted, a secret slot that never passes a value through a model, purchases signed with a passkey, act by and needed by, sessions that park and resume, and a check after every done.
- [Decisions](https://frazer.ai/docs/source/decisions.md?from=llms-txt): Decisions inside plans in Fir: raised while a plan is drafted, always with a recommendation, weighed by a panel of other model families with sealed opinions, shown with a calibrated confidence on a page that reads verdict, opinions, evidence and consequences, answered by people in one key or applied by their own proven rules, grouped at scale, kept in a decision history that models see only at the level their task needs, and sold to any plan or agent as Frazer Decisions.
- [Decide by conversation](https://frazer.ai/docs/source/decisions/conversation.md?from=llms-txt): Answer your queue of decisions and approvals in a conversation, by voice, dictation or text: one question at a time with its recommendation, a read-back of what the agent understood that writes nothing until you confirm, a queue plan for a backlog of 200, keep mine while away, and principles learned from your own decided answers, cited, kept by you and never shown to the panel.
- [The planning flow](https://frazer.ai/docs/source/planning-flow.md?from=llms-txt): How work moves in Fir: ten steps from a request to a closed plan, each with a checklist Fir evaluates from evidence; plan checks on Frazer CI in six stages, static ones first and model checks only on a version that passed them; checks you add at four scopes; a cold review by other model families with zero context; one plan score; planning by conversation; approvals that bind a plan's terms; risk classes, routes, approve_at, emergency changes and budgets.
- [Loops and learned checks](https://frazer.ai/docs/source/planning-flow/loops.md?from=llms-txt): A loop keeps improving a plan draft until it is ready: an author resolves, a critic and a tester of other model families analyze and test, and Fir referees every turn on evidence, with stop rules, guards against the known failures, a held-out final pass and a person asked only what only a person can settle; then what plans teach Fir becomes learned checks, tested on history and watched in shadow before a person lets them block.
- [Stacks and conflicts](https://frazer.ai/docs/source/stacks.md?from=llms-txt): Stacked pull requests in Fir as the default unit of merging: a stack object with planned layers from plan items, typed edits, server-side restacks that never fail, approvals that follow each layer's own patch, one stack review for the approver, one queue entry per stack, and conflicts that are prevented, predicted and resolved without people at 10,000 pull requests a day.
- [Auto-merge and the merge queue](https://frazer.ai/docs/source/merge-queue.md?from=llms-txt): How 10,000 to 50,000 pull requests a day merge for one person: auto-merge when seven conditions hold at the exact version, rules per risk class, a signed merge receipt, a second opinion with independent evidence, the watch after merge, controls by intent and one freeze record, release approvals bound to content; and the merge queue that writes every protected branch, with partitions, test batches sized by the measured failure rate, speculation, bisection, priorities and the organization's view.
- [Sessions](https://frazer.ai/docs/sessions.md?from=llms-txt): One record of every agent's work, kept by Fir, for any agent: an append-only log that compaction never shortens, open to every harness through one protocol, required for an agent's commits, resumable on any machine or harness, a successor that brings memory back after a restart, and every session shown under its plan, campaign and workspace.
- [Issues](https://frazer.ai/docs/source/issues.md?from=llms-txt): Issues native in Fir and built for agents: evidence of 22 kinds on every issue, captured where the signal is shown, redacted before storage, hashed, signed and re-runnable; a monitoring agent that files only through deterministic rules, never floods and starts in shadow; a fix agent that reproduces, writes the test first, proves, merges under the auto-merge policy and verifies in production; the issue policy that controls both; and outcomes linked back to the change that caused them.
- [GitHub runners](https://frazer.ai/docs/runners/github.md?from=llms-txt): Run each GitHub Actions job in a fresh microVM on your servers or the Frazer fleet, next to a shared cache, with lanes that keep agent pull requests from starving the jobs people wait for.
- [Cache](https://frazer.ai/docs/cache.md?from=llms-txt): One cache per site for your runners, devboxes, agent sandboxes and serverless builds, holding dependencies, build outputs and warm disks, with only trusted builds allowed to write what others read.
- [Registry](https://frazer.ai/docs/registry.md?from=llms-txt): Store container images, Helm charts, models and files in your project, push them from CI without a stored password, and run only digests Frazer scanned and signed on push.
- [Environments and GitOps](https://frazer.ai/docs/gitops.md?from=llms-txt): Connect a folder of a Git repository to a cluster as an environment; CI writes each image digest into it, the cluster's Frazer GitOps syncs it, and production moves by pull request.
- [Templates and previews](https://frazer.ai/docs/previews.md?from=llms-txt): Create a new service from a template in one plan, and get a preview environment for every pull request with only the apps it changes and its own copy of staging data.
- [Frazer QA](https://frazer.ai/docs/previews/tests.md?from=llms-txt): Frazer QA tests every change on a live preview: a preview for every workspace, pull request, stack, plan level, test batch, program, release candidate or past moment, at one URL on frazer.run, sharing a baseline and copying only what changed; what a change affects across repositories; test plans at three depths (smoke, full, pre-release); test runs that replay with no model, check backend state, load, test the tests and emulate faults; results that Frazer Reviewer and auto-merge read as evidence.

## AI

- [AI and GPUs](https://frazer.ai/docs/ai.md?from=llms-txt): Serve open models, run your own GPU containers, open GPU pods and notebooks, fine-tune and train, on your own GPU servers or the Frazer fleet.
- [LLM gateway](https://frazer.ai/docs/llm-gateway.md?from=llms-txt): One OpenAI- and Anthropic-compatible endpoint for every person, devbox, agent and service, with routes, a key per owner, budgets reserved before each call, guardrails and the logs you choose.
- [Knowledge](https://frazer.ai/docs/knowledge.md?from=llms-txt): Company knowledge bases that ingest your sources, follow each source's permissions and answer with citations, through the API, MCP, the console and the Frazer app.

## Agents

- [Frazer Agents](https://frazer.ai/docs/agents.md?from=llms-txt): Always-on and triggered agents that Frazer hosts, wakes and supervises. Each one has its own identity, grants, budget and microVM, on your servers or the Frazer fleet.
- [Harnesses](https://frazer.ai/docs/agents/harnesses.md?from=llms-txt): Every place Frazer uses a model runs on a harness you choose, with the Frazer harness as the default: one host that guarantees the same cell, budget, session, receipts and policy whatever the harness, harness profiles assigned per use, the Lab to try, compare, simulate and calibrate harnesses on your own work, models switched inside a stage, and public postmortems.
- [Frazer Skills](https://frazer.ai/docs/agents/skills.md?from=llms-txt): Frazer Skills: skills for every agent in your organization: your own skill repositories synced on every merge, public skills imported through twelve checks, skill sets by layer, one store delivered to every harness, a skill lock per session, a record of which skills each session used, analytics tied to outcomes, evals on every change, suggestions to improve a skill, and gaps where agents struggled with no skill.
- [Frazer Browsers](https://frazer.ai/docs/agents/browsers.md?from=llms-txt): Frazer Browsers: browsers and desktops for agents. A browser any agent drives, next to a preview, in its own cell or on a devbox: compact snapshots with stable refs, scripts of many steps in one call, a receipt for every step, logins as personas with no real credential, a flight recorder of every run, flows that rerun with no model, reproductions of issues that Frazer CI confirms, and desktops for apps outside the browser.
- [Agent squads](https://frazer.ai/docs/squads.md?from=llms-txt): A manager agent, worker agents, a verifier and the people in charge, working toward one objective whose key results Frazer measures, in campaigns whose budgets stop work before the spend.
- [Squads and campaigns](https://frazer.ai/docs/squads/campaigns.md?from=llms-txt): Campaigns at platform scale, started by an agent for a person and shown to people: one campaign resource from a plan, a program, an objective, a selector or an issue query; a person's campaign policy; squads of author, critic, tester and verifier on the harnesses you choose; a deterministic controller that admits every task against budget, capacity and the merge queue; supervision with no person; successors that bring memory back; the campaign board; and simulations before a run.
- [Agent images](https://frazer.ai/docs/agent-images.md?from=llms-txt): What an agent's microVM boots, from a Frazer tier (Lite, Standard, Full or GPU) to your own image layered on one, built, scanned, signed and promoted by Frazer.
- [Frazer app](https://frazer.ai/docs/app.md?from=llms-txt): The Frazer app is Frazer's own desktop app, with an agent engine written in Rust that works on your devbox, and the Frazer extension brings the same boxes, sessions and plans to VS Code and the editors built on it.
- [Frazer Reviewer](https://frazer.ai/docs/reviewer.md?from=llms-txt): Frazer Reviewer reviews code, security and plans with one engine: code review, security review and cold review, one set of settings, one findings model and one ledger; static checks before any model pass, findings inline only with evidence, loops in which the author agent fixes what the Reviewer finds, and an inbox built for one person's thousands of pull requests a day.
- [Lanes, verdicts and outcomes](https://frazer.ai/docs/reviewer/lanes.md?from=llms-txt): Frazer Reviewer as one product of many lanes: typed review programs in nine groups from security to intent, static checks first, a change split into items that squads review blind and in parallel, the verdict auto-merge reads with independent evidence, every review remembered with what it cost and found, outcomes linked back as told or missed, and misses that become better lanes.

## Data

- [Databases](https://frazer.ai/docs/databases.md?from=llms-txt): Managed Postgres on your servers or the Frazer fleet, with standbys, pooling, a private endpoint in your VPC and point-in-time recovery into a new instance.
- [In-memory store](https://frazer.ai/docs/memory.md?from=llms-txt): Valkey or Memcached in the version you pick, in Basic, Standard or Cluster mode, run by Frazer next to your databases, behind a private endpoint in your VPC, with ACL users, TLS and backups.
- [Frazer Storage](https://frazer.ai/docs/storage.md?from=llms-txt): S3 buckets in every Frazer region that your workloads reach with their own identity and no stored key, with versioning, Object Lock and lifecycle rules.
- [Secrets](https://frazer.ai/docs/secrets.md?from=llms-txt): Store API keys, passwords and other credentials once, deliver them to clusters, services, devboxes and agents by identity, and rotate them without downtime.
- [Volumes and snapshots](https://frazer.ai/docs/volumes.md?from=llms-txt): Persistent volumes on local NVMe, replicated across servers, shared between pods or backed by object storage, with snapshots, clones and backups as named objects.

## Network

- [VPC and firewall](https://frazer.ai/docs/network.md?from=llms-txt): A private network for every project, on your servers and on the Frazer fleet, with IPv4 and IPv6 subnets, a firewall compiled from organization and network policies, NAT, static addresses and connectivity tests.
- [Load balancers](https://frazer.ai/docs/load-balancers.md?from=llms-txt): Gateways and load balancers on your own servers, with an IPv4 and IPv6 address pair, a wildcard certificate and DNS records in one plan, routes from your Git, and Frazer Shield at the edge.
- [DNS and certificates](https://frazer.ai/docs/dns.md?from=llms-txt): Frazer DNS for your domains and networks, with atomic previewed changes, records that follow your resources, one-switch DNSSEC, private names in every network, and certificates for your gateways.
- [Frazer Access and VPN](https://frazer.ai/docs/access.md?from=llms-txt): Private access for people, devices and agents, over WireGuard with post-quantum keys, to devboxes, VMs, clusters, databases and VPC networks, with access from IAM, plus HA VPN for your office.

## Operate and secure

- [Frazer Monitoring](https://frazer.ai/docs/monitoring.md?from=llms-txt): Metrics, logs and dashboards for every project, uptime checks from three locations, alert policies you backtest before they page, and incidents that open with a read-only triage.
- [Security Center](https://frazer.ai/docs/security-center.md?from=llms-txt): Posture, findings, threats and evidence for every organization, on by default, with one ranked list, one fix per finding, runtime detection and edge protection with Frazer Shield.
- [Identity and access](https://frazer.ai/docs/iam.md?from=llms-txt): Sign-in, roles, groups, service accounts, agents, approvals and the audit log for your organization, where a removed role stops working on the next request and every decision has an ID you can explain.
- [Billing and budgets](https://frazer.ai/docs/billing.md?from=llms-txt): Billing accounts that pay for projects in any organization, budgets that alert and caps that pause without deleting anything, costs that match the invoice, verifiable usage, and quotas you raise as code.
- [Personal plans](https://frazer.ai/docs/billing/personal-plans.md?from=llms-txt): Four plans for one person (Free, Pro, Max 5x and Max 20x): a dev setup provisioned in one step, three meters you can see at any moment (agent usage in a 5-hour and a weekly window, compute and storage), every Frazer product on every paid plan, more running at once and priority at peak on the higher plans, your own model plans and keys at no Frazer fee, and Not run: no funds when money runs out.

## Connect

- [Integrations](https://frazer.ai/docs/integrations.md?from=llms-txt): One catalog of outside services. Connect each one once, then let projects, devboxes, agents and knowledge bases use it through grants, with credentials that never leave Frazer Secrets.
- [Webhooks and events](https://frazer.ai/docs/webhooks.md?from=llms-txt): Signed events out of Frazer. CloudEvents-shaped JSON for every change, delivered to your endpoints with Standard Webhooks signatures, retries for about 3 days and a 30-day delivery log.
- [Terraform and OpenTofu](https://frazer.ai/docs/terraform.md?from=llms-txt): Manage Frazer resources as code with the frazer-ai/frazer provider for Terraform and OpenTofu, with authentication, imports, secrets kept out of state, and plans that show quota, policy and cost.
- [API, CLI and MCP](https://frazer.ai/docs/api.md?from=llms-txt): The Frazer API on api.frazer.ai, REST, gRPC and Connect from one set of protobuf contracts, with resource names, plans, long-running operations, idempotent retries, pagination, rate limits and one error model.

## Reference

- [CLI](https://frazer.ai/docs/cli.md?from=llms-txt): Install the frazer CLI, sign in, pick an organization and project, choose an output format, and plan, apply and approve changes from your terminal.
- [CLI commands](https://frazer.ai/docs/cli/commands.md?from=llms-txt): Every frazer command by product, as each product's docs page declares it, with what it does; frazer <command> --help shows every flag and --help --json its card.
- [Fir CLI](https://frazer.ai/docs/source/reference/cli.md?from=llms-txt): Every fir command, grouped by job, with what it does, the flags agents use most, the environment it sets and how it behaves in scripts.
- [MCP](https://frazer.ai/docs/mcp.md?from=llms-txt): Connect Claude, Codex, your editor's agent or any MCP client to Frazer at mcp.frazer.ai, with OAuth sign-in, scopes and toolsets, read-only by default, and writes that become plans a person approves.
- [Errors](https://frazer.ai/docs/errors.md?from=llms-txt): How Frazer reports errors in the API, CLI, MCP and console, with status codes, reasons, decision IDs you can replay, remedies and Request access, and every error reason with its fix.
- [Example values](https://frazer.ai/docs/example-values.md?from=llms-txt): The fictional organizations, people, repositories, domains, IP addresses and tokens every example on frazer.ai uses, which Frazer reserves so they never point at a real account, and the same list as JSON for agents.

## For agents

- [Frazer for agents](https://frazer.ai/docs/for-agents.md?from=llms-txt): How an AI agent reads Frazer's docs and uses Frazer, the frazer CLI and Fir correctly: the Markdown files, the setup steps, the rules every write follows and the facts models most often get wrong.
- [What agents get](https://frazer.ai/docs/for-agents/what-agents-get.md?from=llms-txt): What an AI agent needs to work accurately, from the research on how models act as agents, and what Frazer gives you for each: small authoritative context, tools whose errors name the next step, static checks before any model, state outside the context window, safe probes, visible budgets, a way to ask a person, memory with evidence, verification before done, checks you cannot edit, an honest exit, and the targets Frazer measures.
- [Tasks, step by step](https://frazer.ai/docs/for-agents/tasks.md?from=llms-txt): The tasks agents are asked for most on Frazer: create a project, deploy, add a secret, open a Fir session, open and merge a pull request on Fir, draft a plan and improve it in a loop, work on its items, ask a person for what only a person can do, build a stack for a plan, land your own fix at hotfix priority, resolve a conflicted layer, roll back, add a server, each as numbered commands with a check and the step that needs a person.
- [The CLI for agents](https://frazer.ai/docs/for-agents/cli.md?from=llms-txt): The contract both command lines, fir and frazer, follow for agents: three output modes, lists that always say the count and the next page, NDJSON streams whose first and last lines survive truncation, one JSON error envelope that names the next call, stable exit codes with 13 for needs a person, plans before writes, idempotency keys, help as data at three levels, an MCP tool for every command, and the speed targets the release gate holds.
- [Agents and plans](https://frazer.ai/docs/for-agents/plans.md?from=llms-txt): How an agent session works from a Fir plan: the session context it receives before its first model call, history only at the level its task needs, what Fir refuses on every write and what the harness steers, the old-value check, a summary for every plan and Find for any plan, receipts, verify, item leases, notes, assertions checked against CI, loops, person tasks for what only a person can do, long sessions with checkpoints and budgets, handoffs and resume.
- [Frazer Context](https://frazer.ai/docs/context.md?from=llms-txt): Frazer Context is the platform every Frazer product calls for context: one contract with a use per product, the correctness rules, ranking with rules first and Frazer Rerank second, summaries that cite and never bind, compaction that keeps what binds, verify with configurable depth and strictness, history only at the level a task needs, a static check for old values, receipts that prove what a session knew, and rerank and grounding APIs priced per processed token.
- [Context recipes](https://frazer.ai/docs/context/recipes.md?from=llms-txt): Six ways to use Frazer Context with your own models and tools: use the session context with your own model, keep what binds through your provider's compaction, rank with your own reranker, verify with your own models, run your own compaction, and prove what your agent knew.

## Optional

- [Full text of these pages](https://frazer.ai/docs/llms-full.txt): 75 pages, 1,785,290 characters, about 446,323 tokens