TL;DR: Every FAF app now scores with one engine. The same project.faf gets the same number in the terminal, in Claude, in Cursor and VS Code, in Gemini and Grok, in Python, and at the edge. We call it the Always33 Suite. This post opens a series, one release at a time.

In Plain English

Old state. FAF grew one tool at a time. Each tool learned to score a project on its own, and they did not always agree. In the worst case noted, the same file could read 64 in one place and 100 in another.

Fix. One engine underneath all of them. It scores every file against the same 33 slots. Slots that are not applicable to a project are marked slotignored, and do not score.

New state. One number, wherever you ask. Every FAF tool gives the same file the same score, and the tests check it on every release.

It starts at the root

Open any repo with FAF in it. Sort the root by name. project.faf lands between package.json and README.md.

package.json project.faf README.md

That is exactly its job. package.json says what the code is built with, for machines. README.md tells the story, for people. project.faf says what the project is, for any AI. It sits between the manifest and the prose, and the alphabet put it there.

project.faf is to context what package.json is to dependencies.

Timing matters. You can't easily change your code trees once they've grown. If AI starts coding from guesses, the guesses become branches, and the branches become the project. Put the facts in first, and everything grows from them.

FAF seeds your project

It defines the roots before AI codes a single line,
so AI codes from rooted facts and definitions.

The FAF Map, bottom up

Everything FAF does fits on one map, and you read it from the bottom. The ground is the FAF Family: three IANA-registered formats. .faf knows the project, .fafm remembers, .fafa acts. Above the ground, the map grows: into code trees, into memory, and into the agentic layer, where one agent clues in another: use FAF like this, for that.

The context layer

.faf, .fafm and .fafa are not three more file extensions. Together they form the project context layer: one structured, portable description of a project, sitting between the software and the AI that has to understand it. The code underneath can be any language, any stack. The layer keeps the same shape, so any AI can read it.

  1. Format
  2. Shared language
  3. Layer
  4. Interoperability
A format's power isn't only what it stores. It's what it lets other systems agree on.

JSON, HTTP, Markdown and Git earned their place that way. FAF is that agreement for AI context. Always33 makes the agreement hold: the same file scores the same on every platform.

The FAF Map, read bottom up: the FAF Family formats as the ground, the Always33 Suite serving them on every platform, then code trees, memory and the agentic layer.

The Always33 Suite is the band right above the ground. It doesn't add a new format. It makes the ground measure the same on every platform, so everything above it can trust what it stands on.

A congregation

Not a stack of separate tools. Every platform gathers around the same score.

The Always33 Suite: the FAF smiley at the centre, connected to Claude, Cursor, VS Code, Gemini, SpaceXAI, Python, Cloudflare and the terminal. One .faf. One score. Everywhere.
ProductWhere it servesVersion
faf-kernelthe engine under all of them (Rust)v1.1
faf-clithe terminalv8
claude-faf-mcpClaudev7
faf-mcpCursor, VS Code, Windsurfv4
gemini-faf-mcpGeminiv3
grok-faf-mcpGrokv2
faf-python-sdkPythonv2
mcpaas.livethe edge, hostedv1.8

Why always 33

Every .faf is scored against the same 33 slots: the project, the human context, the stack, and 12 enterprise slots. A project marks the slots it doesn't use as slotignored, and they drop out of the count. The score is what the file actually says.

  • 21 slots filled, no markers: 64% (21 of 33).
  • The same 21, plus the 12 enterprise markers: 100% (21 of 21).

The 12 enterprise slots stay visible even when they're marked. Most projects mark them unused today. What they're for is coming in fafb (faf-binary): teams can use all 33 slots for monorepos and large, complex codebases.

One command writes the markers and re-scores:

npx faf-cli auto

The version numbers tell the story

Nobody planned these numbers. Each one counts how many times that product changed in a big way. Read them in order and you get the build history: the CLI first at v8, then Claude at v7, the IDEs at v4, Gemini at v3, Grok and Python at v2, the edge at v1.8.

The youngest piece is faf-kernel, at v1.1. It is also the engine every other product now stands on. Always33 is the moment the stack that grew over time came to rest on one foundation.

FAF don't lie, in practice

One engine is only a promise until something checks it. Before the Python SDK shipped, its score was compared with the engine on 845 test files, then on 80 real projects, and matched on every one. An independent review before the PyPI release still found three unusual YAML cases where it didn't. They were fixed before anyone installed it.

That is the point of the congregation. When the number matters, it has to be the same number.

The series

One post per release, in the order it was built:

Built with .faf ☑️ one engine, one number.