FML captures the coding sessions your team already runs, turns them into reusable context, and injects the useful parts in every agent session across the team.
Every agent starts out the same: read context files, grep around, and try to understand months or years of technical decisions your team has made. You're paying for this exploration in tokens and time, on every run, for every engineer.
Frontier labs post-train one general model for everyone. FML gives your engineering org its own compounding memory: prior sessions, review comments, Git history, incidents, docs, and setup patterns that carry forward between engineers and tools.
FML is the context graph for your team and makes sure no one is starting from scratch again.
Install the FML plugin wherever you're coding and the context graph will be built automatically.
Before an agent writes a line of code, FML hands it the institutional knowledge from across the team: prior engineering sessions on the files, connected PRs, code review issues that were flagged, and Sentry reports related to the feature. Internal evals show runs with FML-injected context finished about 25% faster and cheaper.
How we measure it →Works with
Enter last month's AI coding model bill from your OpenAI or Anthropic dashboard. FML reduces waste by injecting compact prior context before agents start exploring.
Monthly AI coding spend
$50,000
Savings rate
25%
Monthly savings
$12,500
Annual savings
$150,000
FML helps teams better understand AI activity, from individual session breakdowns to model performance on their codebase.
Last 30 days
Your team ran 128 sessions across 9 active repos. Checkout has the richest setup, 7 skills were used in sessions, and estimated spend is $3.8k.
Large-context sessions
6 sessions exceeded 150k tokens before the first useful edit.
Top models · 8.5M tokens
Skills, commands, hooks, MCP
Signals attached to sessions
The more services connected, the better FML can reason about intent, track outcomes from AI code, and inject the right context during coding session.
FML sits locally on the machine and saves the useful parts of every coding session: prompts, session state, files touched, tool calls, and outcomes.
A trace can stay local, be queried over MCP, be injected into the next run, or be exported to a customer-owned pipeline.
Saved on this device
Claude Code, Codex, and Gemini sessions become local trace records.
Each trace keeps
Prompt and session state
Tools, files, diffs, and test output
Outcome, review result, and cost
Then use it to
Query over MCP
Find related sessions and prior attempts without leaving the coding harness.
Inject into the next run
Give Claude or Codex compact context before it starts exploring.
Export the trace
Send records to eval, annotation, audit, or governance pipelines.
Ask what the team shipped, what a session cost, or why a change landed. FML answers from the work record, posts a morning digest, and sends alerts from connected sources like Sentry and Linear.
Install FML wherever your team codes. Claude Code, Codex, and Gemini sessions land in a local trace store, with optional team sync.
Sessions
128
last 30 days
Spend
$3.8k
model usage
Recent sessions
Checkout retry fix
Claude Code · $4.18 · shipped
Auth migration notes
Codex · reused as context
As engineers work, FML shows sessions, spend, stuck runs, reusable workflows, and the context graph forming across the team.
Use MCP, Slack, terminal, or the coding agent to recover prior work and inject context into the next run.
The same captured work record improves the next agent run, the next engineer handoff, and the next finance review.
Shared context
Spend attribution
Onboarding
Start locally. Add Pro when you want the team record: sessions, PRs, costs, and reusable context across every agent run.
Everything in Free, plus:
For orgs that need the full platform at scale.
Everything in Pro, plus:
Everything in Free, plus:
For orgs that need the full platform at scale.
Everything in Pro, plus:
FML Observe captures AI coding sessions: prompts, tool calls, file operations, model responses, token counts, costs, and generated session summaries. Everything starts local in SQLite on the developer's machine. You control what syncs to FML.
FML starts from coding-agent sessions, then connects them to PRs, reviews, issues, incidents, docs, setup patterns, cost, and stuck work. The team can see what agents touched and what context should be reused next.
FML builds compact context packages from the current codebase, changed files, related PRs, prior agent sessions, and team patterns. Instead of making the agent rediscover everything through broad file reads and repeated prompts, FML injects relevant context up front. Early experiments show up to 25% speed and token gains on complex coding tasks.
FML works with Claude Code, Codex CLI, Gemini CLI, and Pi, with access through the CLI, Slack, Telegram, and MCP. GitHub is the first source for repo memory, and you can connect Slack, Linear, Sentry, PostHog, Notion, and Stripe from Settings → Integrations.
A seat is an FML organization member. Billing starts with the members in your FML workspace and updates as invited teammates accept access.
A developer can start locally in a few minutes: run the FML install command, register the coding-tool hooks, and link the org. Teams can then add sync, dashboards, Slack, and shared context rules.
FML starts local-first, and teams control what syncs. Most team views are built from summaries, setup patterns, costs, stuck sessions, and links to PRs or incidents. Raw prompts can be governed by policy instead of treated as an all-or-nothing feed.
Better prompts help one session. FML captures the work, indexes repo history, compares setup patterns, and packages the right context at task time. The next prompt gets better because the codebase has memory.
Yes. FML can find skills, hooks, permission rules, MCP servers, local docs, repeated workflows, cost patterns, and stuck sessions. The useful patterns become reviewable instead of staying trapped on one laptop.
Reach out to us at hi@fml.inc and we'll get back to you.