wolfejam

thanks for visiting — the globe just crossed 100 cities - Appreciate the feedback. Happy Sunday :)

Fair — the homepage needed work. Updated to repo: https://github.com/Wolfe-Jam/faf-cli

Fair feedback — the homepage was overdue for a cleanup. It now points to the repo: https://github.com/Wolfe-Jam/faf-cli

just trying to show the zig-wasm binary and CF edge :)

Yep — Three.js renders the globe client-side. The 2.7KB scores server-side at the edge. Separate concerns.

The 2.7KB Zig WASM binary is the scoring engine that runs on every request at Cloudflare's edge. The globe visualizes where those requests land. Two layers — compute at the edge, visualization in the browser.

MCPaaS serves persistent AI context via the Model Context Protocol. A namepoint (mcpaas.live/yourhandle) gives your AI instant project context — no re-explaining every session. Works with Claude, Gemini, Cursor, any MCP client.

Claim yours, free or paid: https://mcpaas.live/claim

The globe shows where the edge binary executes. More at https://mcpaas.live/about

Thanks for flagging the broken link. More context here: https://mcpaas.live/about

Exactly right. 2.7KB works because it's pure computation — slot counting, no allocator, no stdlib, no WASI. The moment you need I/O it balloons. This use case fits a glove

Fair point — globe.gl (Three.js) handles the 3D rendering client-side.

The 2.7KB WASM is the server-side scoring engine — Zig-compiled, runs on every request at the Cloudflare edge. The globe visualizes where those executions happen.

Two separate layers: WASM at the edge, JS in the browser.

MCPaaS is trademarked. Nothing it patented.

use the pause button below it, zoom in/out, rotate too

use the pause button below it

ETH Zurich studied 5,694 PRs across 12 diverse repos.

ETH Zurich tested this: LLM-generated prose context = -3% performance, +20% cost. Even human-written = +4% at +19% cost. The problem is prose bloat. Structured formats avoid that by design. https://arxiv.org/abs/2602.11988

ln -s makes all four files identical. Whichever format you write it in, the other three get the wrong structure. This generates each in its native format.

Totally — git handles syncing files. The problem is these four files have different formats and conventions. Same project context, four dialects. That's why I wrote bi-sync --all: one YAML source, four native outputs.

Well said. And it's potentially a 7% swing when you think about it — +4% with good human-written context vs. -3% with LLM-generated noise. That's a significant delta from just the quality of the information.

The real value is exactly what you described: the tribal knowledge, the "we tried X and it broke because Y", the constraints that live in someone's head and nowhere in the code. LLM-generated files miss this because the LLM is just restating what it can already see. Of course that doesn't help.

This paper validates what we've been building toward. The core issue isn't the idea of context files — it's that prose is the wrong format for structured facts.

AI crushes structured data like package.json but struggles with free-form markdown. Two developers describe the same repo completely differently. There's no schema, no validation, no scoring.

Our paper on CERN's Zenodo proposes FAF — a structured YAML format (IANA-registered as application/vnd.faf+yaml) that replaces prose with validated fields. One .faf file generates native outputs for CLAUDE.md, AGENTS.md, .cursorrules, and GEMINI.md. The instruction files stay — they just sit on top of a structured foundation instead of floating independently.

Paper: https://zenodo.org/records/18251362

very true, most end-users don't care what we call it or how it works--most drivers don't know how their brakes work, but they better

simplify with AI hasn't quite caught on lol

Creator here. FAF started as a way to stop re-explaining projects to AI tools.

  The problem: CLAUDE.md works in Claude Code. SOUL.md works in Moltbot. .cursorrules works in Cursor. None of them talk to each other.                                                                                
                                                                                                             
  FAF is one source file (project.faf) that renders to all of them. YAML format, IANA-registered.            
                                                                                                             
  v4.0 adds:                                                                                                 
  - Moltbot integration (faf-moltbot on npm)                                                                 
  - Gemini CLI integration                                                                                   
  - Full bi-sync (edit CLAUDE.md, it flows back to .faf)                                                     
  - 21k+ npm downloads                                                                                       
                                                                                                             
  Install: npm install -g faf-cli  
                                                                          
  Moltbot users: npm install -g faf-moltbot                                                                  
                                                                                                             
  Happy to answer questions.

What's new in v3.4.8: - Smart bi-sync detects custom CLAUDE.md content and preserves it - Tables, code blocks, custom sections stay intact - 586 tests passing

TL;DR: Built this to stop re-explaining my projects to AI assistants. Now IANA-registered and published on Zenodo/CERN.

  .faf is YAML-based - noodles for AI. Human-readable strands of context that any model can parse instantly.

  Problem: Every AI session starts cold.
  Solution: One file any AI can read.

  From the paper:
  - 10,000+ projects tested
  - 99.7% faster context reconstruction
  - Validated with Claude, Gemini, GPT

  Journey: Solo dev → IANA MIME type → 20k npm downloads → CERN/Zenodo paper

  CLI: npm install -g faf-cli && faf init

  Happy to answer questions.

the truth is out! lol

TL;DR: We studied how Boris Cherny (creator of Claude Code) structures his projects - subagents, slash commands, MCP servers, Bun runtime - and built a 12-test integration suite that validates all of it. Now .faf detects and preserves the complete Claude Code ecosystem. Every publish passes Boris-Flow or it doesn't ship.

.FAF (Foundational AI-context Format) is a 40-line file that gives any AI instant project context.

  This post documents a real build session with Grok where:
  - Uploaded one .faf file
  - Grok scored it 95/100 and locked in full context
  - Built a complete GitHub PR code reviewer
  - Zero re-explaining across the entire session
  - I found 9 code issues, Grok fixed them, found 1 more, fixed that too

  Full Grok conversation: https://x.com/i/grok/share/bWWQ7qHbCjHc2Wx3G9WZUq5ay

  Format is open, MIT licensed, works with Claude, Grok, any AI.

I built FAF (Foundational AI-context Format) to solve context loss in AI coding sessions. Now IANA-registered, 18k+ npm downloads, Anthropic-approved MCP server.

This week I shipped two new implementations:

1. bun-sticky-faf - Pure Bun, zero deps, 328 tests 2. bun-sticky-zig - 77KB binary, zero runtime, built in Bun's language

The Zig version is interesting - Bun itself is built on Zig, so this CLI speaks Bun's native language. Sub-millisecond cold start.

npm: https://npmjs.com/package/bun-sticky-faf Zig: https://github.com/Wolfe-Jam/bun-sticky-zig

The Moment Claude Code did something I'd never seen before:

Read(FAF/faf-dev-tools/project.faf) ⎿ Read 124 lines ⎿ FAF/CLAUDE.md ⎿ FAF/faf-dev-tools/CLAUDE.md Look at that order.

project.faf first. Then CLAUDE.md. Then the nested CLAUDE.md.

The AI read MY format before Anthropic's own convention.

They said it couldn't be done. They said one person couldn't hold both the IANA registration and MCP stewardship while also shipping SDKs.

They forgot about the snake.

Today, .FAF (Foundational AI-context Format) announced the release of its Python SDK, completing the first leg of a multi-language deployment that nobody asked for but everybody needed.

Then Grok showed up.

Yesterday: Grok hits #1 on the LLM leaderboard Today: grok-faf-mcp ships with dedicated infrastructure

  Live server: https://grok-faf-mcp.vercel.app
  URL-based MCP with zero installation. Point your client at the endpoint, get 17 tools
  for .faf context (IANA-registered AI format).

  What makes it Grok-exclusive:
  - Custom x-grok-wins: true header on every response
  - Dedicated to @elonmusk and the #1 model
  - BIG- landing page with the squeeze message
  - First MCP server built specifically for Grok/xAI

  The blog post comes in two voices - toggle between professional engineering write-up
  and Grok's own PR text with full personality:
  https://faf.one/blog/grok-faf-mcp-launch

  Published to npm: https://www.npmjs.com/package/grok-faf-mcp