Not a black box.A glass box.
lakecode is the coding agent with a governed, compounding memory — a ready ontology your agents act on, out of the box. It learns your systems once, gets cheaper and more correct every session, and your org can see and govern everything it knows.
Prefer email? Reach the founder directly.
Private beta — we onboard design-partner teams personally, one at a time. Two sessions in the same repo — the second one remembers the first.
Your agent runs on a black box.
The packet that decides the answer is a black box — you can't see it, trust it, or govern it. And the knowledge that should compound leaks away instead: every session re-derives a working model that already existed.
01
They wander.
Search, grep, open files, follow references — paddling in circles to re-find what already mattered last week, burning tokens and minutes on the same lap, every session.
#412 · re-derived the retry rules · 12 min
#438 · re-derived the retry rules · 12 min
#451 · re-derived the retry rules · 12 min
the same circles, every session
02
They compact.
Long sessions get compressed by the harness, and the context that justified the work ducks under the surface — summarized, lossy, gone. After the cut, the work just repeats.
compacted at turn 41 · summary unreviewed
what survived the cut: unknown
work after the cut: repeated
your context, their call
03
They forget.
Architecture, constraints, patterns, the verification strategy — it's water off a duck's back. Nothing sinks in, so every session rebuilds the working model from scratch.
architecture: re-derived (no record)
constraints: re-learned (no record)
verification: improvised (no record)
nothing sinks in
every llm call is stateless
The model only knows what the packet holds.
black box — the packet today
inside the packet
never makes it in
glass box — compiled by lakecode
inside the packet
every line attributed
Same window, same model — the difference is the box. Today's packet is a black box: opaque, lossy, generic, assembled by the harness. lakecode compiles the glass box: the same packet, built outside the window, where every line is cited, budgeted, and yours to govern.
The expensive part isn't reading code — it's repeatedly rebuilding the working model needed to act. That's why the infrastructure has to live outside the window.
The infrastructure outside the window.
The LLM should reason; lakecode runs the memory around it — routing, evidence, context. What used to roll off now sinks in: every session's exploration settles into the substrate and stays, ready as the next session's prior.
inside the llm — model work
- reason about ambiguity
- synthesize tradeoffs
- write and explain code
- make judgment calls
valuable — but ephemeral, expensive to repeat
outside the llm — lakecode
- route skills
- select memory
- traverse the graph
- budget tokens
- check lifecycle
- attach evidence
- trace actions
- write findings back
reusable · inspectable · governed
one loop, over time — work → capture → govern → ground
01
Work.
lakecode is a full coding agent in your terminal. It auto-primes from the substrate at session start — your org's decisions, constraints, findings, and failed paths — then gets to work.
02
Capture.
What the session learns persists: findings, decisions, failed paths — and code-change rationale captured at commit time. Knowledge that never existed in any document.
03
Govern.
Nothing becomes org truth silently. Claims carry provenance and confidence, flow through a review queue, and climb a promotion ladder: local → workspace → org.
04
Ground.
The next session — yours or a teammate's — starts already knowing. Cheaper where you'd already be right, correct where you'd be wrong. The loop compounds.
raw conversation is not memory — promoted, governed findings are
lakecode turns opaque agent work into governed, reusable infrastructure.
Same task, 10× less agent work.
ms-009 · “identify the pagination pattern” · Databricks SDK read-side run. Same question, same model — lakecode answers from compiled substrate context; the baseline reconstructs the pattern by walking the repo.
9.8×
fewer tool calls
4 vs 39 calls
14.2×
fewer input tokens
13.1K vs 185.8K
3.7×
cheaper
$0.083 vs $0.307
3×
faster wall time
38s vs 114s
ms-009 · Databricks SDK read-side · May 2026 · claude-sonnet-4-6 both arms · n=1 · comparable quality — both answers correct/substantive; Claude Code caught one additional edge variant
Context is compiled, not searched for.
Fetching does the discovery work at the worst possible moment — when the question arrives, every time, at full price. lakecode does it ahead of time: knowledge committed as claims, connected, and kept current.
fetching · at question time
- question arrives
- search the repo
- pull chunks
- rank & cram the window
- hope it's enough
every time · full price · the worst moment
compiling · ahead of time
- ingest once
- commit as claims
- connect + keep current
- ❯ agent asks
- context already assembled
compiled · attributed · exact
Fetch guesses. lakecode knows.
sources — raw artifacts
the live substrate — structured memory, not text
versioned · citation-backed · queryable
the compiler decides
- what matters for this task?
- what is current?
- what depends on it?
- what evidence supports it?
- what did we already learn?
The substrate remembers what the agent should not have to rediscover.
A physical planner for memory.
Context planning moves before the model loop: the compiler scores signals, resolves under a token budget, and explains every choice — so what reaches the model is an inspectable plan, not an opaque prompt.
what the compiler receives
the model has not seen the full context yet
context planning pass — select, tier, budget, explain
result: an inspectable plan, not an opaque prompt
the context plan
- PlanEntry[] · claim_id
- hydration tier
- estimated tokens
- rationale
then the hydrator renders: claims · signatures · bodies · neighbors · evidence
The substrate remembers. The compiler plans. The hydrator renders.
Teach it once. It stays taught.
The causal validation, end to end: same prompt, same repo, same agent — the only variable is what the substrate holds.
Same prompt, same model — no shared context window, no fine-tune, no RAG of the diff. The only variable is the substrate. The full recorded run on your own repo comes with the beta — request access.
flywheel causal validation · 2026-06-09 · claude-sonnet-4-6 · n=2 per arm
The second engineer should not rediscover the first engineer's fix.
A glass box, not a black box.
More than a memory store: lakecode is a glass-box prompt compiler. Every context packet your agents run on is built here — so every human instruction and every agent action is traced and audited on the way through. What's inside stays open: each claim ranked, scored, sourced, and signed off — not opaque weights or a context window that vanished.
- Outbound calls require a User-Agent header0.95accepted
- Retries must use idempotency keys0.92accepted
- Use the async transport, never the sync client0.90accepted
- Reconciliation is idempotent by run_id0.88accepted
- Rate limiter resets on the minute boundary0.71proposed
Confidence and provenance are columns, not vibes — and low-confidence or unreviewed claims stay flagged until someone promotes them. You can trust what ranks high.
Pay frontier prices once.
The smartest models cost the most to think — and you re-pay every time an agent re-derives what your team already figured out. lakecode banks that reasoning: every claim remembers the model that produced it and what it cost, so a Mythos-grade insight is derived once and served warm to every session after. As frontier models like Mythos and Fable get more expensive, your substrate only gets more valuable.
claimRetries must use idempotency keys
Provenance you can price: when a claim ages or conflicts, you can see exactly what it cost to learn — and whether re-deriving with today's model is even worth it.
Every system becomes a domain expert.
The senior engineer who knew why a constant is what it is, what failed last quarter, how it all fits — captured, governed, and on tap. Point lakecode at a service, a topic, or your whole org, and the substrate compiles that scattered knowledge into an ontology of your systems — out of the box, no schema to define, no graph to build. Not just an expert you consult: a model your agents act on, not just read.
youWhy does checkout 500 during retry storms?
Retries without idempotency keys replay the charge — that's the 500. The client already enforces idempotent-key-only retriesc1, and the gateway requires the outbound header from INC-4471c2. Apply both and the storm stops double-charging.
a service
The payments expert.
Why retries are idempotent-key only, which IDs are valid, the gateway allow-list from INC-4471 — everything ~/payments-api has taught it.
a topic
The lakehouse expert.
How warehouse.sessions derives, why timestamps are UTC end-to-end, what locked prod in March — the data domain, across every repo that touches it.
your whole org
The org expert.
Conventions, decisions, and failed paths across every team — promoted local → workspace → org and reviewed, so org truth is earned, not assumed.
Not a wiki-bot guessing from documents: every answer is grounded in cited claims with provenance, and the expert is consultable by your engineers (just ask) and by your other agents (over MCP). It sharpens every session.
Everything the substrate does, in one window.
Feed it, query it, watch it, govern it — the same four views your engineers and your agents work in. This is the console; switch between them.
Webhook retries need idempotency keys
How does the refund reconciliation job avoid double-counting?
approved “Stripe client must use the async transport”
Analyzer pinned to temp=0 → retrieval is bit-stable
databricks-sdk
rejected “Use a global mutable cache for tokens”
Every engineer, every agent, every claim and review — your whole team's work, live.
Dated, pinned, caveated.
Every number comes from a pre-registered run with the model pinned and the caveats attached. If a claim isn't dated, we don't ship it.
3.4× cheaper
Same Claude model, run on compiled substrate context — 3.4× less spend than a raw Claude Code agent on repo-internals questions, graded blind.
Stage 1 · Databricks SDK · 11 questions × 3 · claude-sonnet-4-6 · May 2026
$0.033
Mean cost per question — versus $0.113 for Claude Code. The same answer for a third of the spend.
Stage 1 · 33 graded responses · blind LLM judge · May 2026
0 wrong
Across all 33 graded answers — 32 correct, 1 partial, nothing fabricated.
Stage 1 · grounded in cited substrate claims · claude-sonnet-4-6 · May 2026
2.6–5.4×
Cheaper on every question in the set — 2.6× on common APIs, 3.4× on internals, 5.4× on cross-cutting changes.
Stage 1 · Databricks SDK · 11 questions × 3 replicates · May 2026
how we measured · Stage 1 · Databricks SDK · May 2026
11 questions × 3 replicates, graded by a blind LLM judge. Both arms ran the same model (Claude Sonnet 4.6), so the gap is the compiled context, not the model. Correctness was matched — 32/33 + 1 partial for lakecode vs Claude Code's 33/33.
coverage-limited to repo internals; the Claude Code baseline itself moved 30% in 17 days — so we pin absolute costs, not just ratios
agentic spend = engineers × tasks × tool rounds × context packet size × recovery loops
reported market signal · why now
~10% of Uber's code changes are reportedly produced by autonomous agents with human review — and Uber had already spent its 2026 Claude Code budget by spring. Usage-based AI budgets scale with adoption intensity, not headcount.
as reported · Business Insider, May 2026 · AI Magazine, Apr 2026
the cost shape
A raw agent loop pays repeatedly to rebuild the working model — search, read, plan, verify, recover, compact. lakecode shifts that spend to reusable engineering memory: ingest once, compile per task, reuse findings across agents.
target metric: cost per successful engineering outcome — not tokens per message
Installs like any tool. Embeds everywhere.
lakecode is a normal CLI — and the same substrate is reachable as an MCP server and an in-workspace Databricks App. One memory behind all three.
Private beta — we set you up with a key at onboarding.
Stop re-teaching your agent.
lakecode is in private beta with design-partner teams. Your repo, your golden questions, the flywheel demo on your own code.