what we're building
●shipping today◐early access○dashed means dashedModels come and go; your team's reasoning compounds — so we're building the layer that keeps it usable. Here is all of it, graded honestly: what's serving in production today, what's in flight right now, and what's still dashed on the horizon. The card tells you which — solid means shipping, dashed means dashed.
where your work lives
The why is scattered across the tools your team already uses. lema ingests it where it lives — GitHub today — so the record builds itself instead of asking anyone to copy-paste. Other sources come one at a time, and this page will say so only when they ship.
agent infrastructure
●verify · description check live◐sessions · hooks built, wiring nextGate what agents ship in CI. Keep what they learned between sessions. Both query the same record of what was decided — and what was ruled out.
A GitHub Action on every pull request. Compares the description to the actual diff — stated-and-found, stated-but-not-found, in-the-diff-not-described. Neutral check run; inline annotations on the lines that matter.
Description check: 1 of 2 stated changes found · 1 not described
internal/api/signup.goclient.go. Intentional?lema verify v1 · 4 / 50 free checks this month · checked PR description + issue #142
Save as .github/workflows/description-check.yml— authenticates via GitHub OIDC, no lema signup.
name: description check
on:
pull_request:
permissions:
contents: read
pull-requests: write
id-token: write
checks: write
jobs:
verify:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
ref: ${{ github.event.pull_request.head.sha }}
- uses: lemahq/lema-verify@v1
with:
api-url: https://api.lema.sh
github-token: ${{ github.token }}Hooks capture execution state before the context window compresses, inject a checkpoint when a session resumes, and push decisions back to the graph — so agents don’t re-litigate settled why or lose the live thread.
UserPromptSubmit · PostToolUse → local JSONL sidecar
Rules-first: goal, active files, next action, decision refs
~600 tok execution state — not a transcript replay
also on the graph
The cited why layer and infra drift surfaces that ship alongside the agent infrastructure above.
“Add a global event bus for cross-feature state?”
Rejected in the 2024 architecture review — a global bus made data flow untraceable and coupled features meant to ship independently.1
Do it instead with scoped per-feature stores → docs/state-management
the full build, graded
Every surface above and every plan below, sorted by how far it has actually shipped — solid, in motion, or dashed.
use it now
Ask why React, Kubernetes, Rust, Vue, Go, Ethereum's EIPs, or elizaOS chose what they chose — and what they ruled out. You get the answer with citations, or an honest “no recorded ruling.” No model guesswork, no account.
try a query →The mixer puts both halves of an answer in one place: the why — the cited rationale and what was ruled out — and the how, or a pointer to the project's own docs for doing it. Ask it in the web chat or over MCP — tuned to never bluff, silent unless it's sure.
see it fire →A GitHub Action on every pull request, comparing the description to the actual diff: stated-and-found, stated-but-not-found, and in-the-diff-not-described. A neutral check with inline annotations, fail-open by design — it never blocks a merge because of us.
add it to a repo →Runs next to your agent: decisions arrive as ≤240-char pointers — never documents dumped into context — and a PreToolUse hook catches a settled call before the edit lands. On npm and the MCP registry.
on github →Sign in, connect a repo, mint a key — and your own decision graphserves every agent session over hosted MCP: the same cited answers, the same honest abstentions, on your team's reasoning instead of open source. Free to start; Pro lifts the caps.
set it up →Connect a repo and read your declared Terraform as a map — every resource deep-links to the SHA-pinned line that defined it and the decision that put it there, and says so plainly when none was ever recorded.
in the app →merging as it hardens
Sign in and lema opens on a briefing, not an empty box: what this project already decided, what it ruled out, and where it still needs your judgment — handed to your agent before it touches the code. A thin record degrades to an honest “not enough on record yet,” never a bluff.
early access →Strata reconciles what's actually running in your cloud against what Terraform declares, and flags the four ways they part: in-sync, managed-but-modified, ghost, and unmanaged shadow infra. The map stops being a snapshot and starts watching.
watch it build →Fusion ships precision-first — it would rather stay silent than guess — so today it answers less often than it could. We're widening recall at the retrieval layer, finding rulings that exist but get missed, without ever touching the no-bluff guarantee.
follow the work →dashed means dashed
The most load-bearing decisions for what you're touching, handed to the session at start — the CLAUDE.md that writes itself, kept current by the graph instead of drifting in a prompt file. A local session-start reader exists in lema-mcp as an opt-in; the always-current, working-set-scoped hosted pack is what still closes the loop.
Today the why and the how live across a handful of MCP verbs. They collapse into a single call that returns both — the simplest possible “is this a good idea, and how?” for any agent that asks.
One problem sits under every surface here: teaching lema exactly when a question matches a recorded ruling — the precision gate behind Fusion, drift, and every verdict we draft. We measure it in the open, and until it's perfect the product does the honest thing: it abstains instead of bluffing.That silence isn't a gap we're papering over — it's the whole point. Dashed means dashed; silence means we don't know yet.
don't lose the why
Run a real “why” query on React, Kubernetes, Rust, Vue, or Go right now — no account, no import. Or run it local in ten minutes. Both doors lead to the same graph.