Keep your coding agent sharp on real codebases.
92.8% of tasks resolved, against 80.8% for the same model.
LemonCrow gives your existing agent a local code graph, exact-range tools, bounded output, and durable memory. It replaces grep dumps and repeated file reads with the smallest useful working set, so long sessions spend more context solving.
Works with
* Cursor: saves in API mode, doesn't save in auto mode. Built-ins can't be replaced, so LemonCrow is additive there.
One command · local-first · free to use
$ curl -fsSL https://install.lemoncrow.com | bash- Find first: ranked symbols and relationships
- Read narrowly: exact ranges instead of file dumps
- Bound output: keep logs and tool results proportional
- Stay sharp: less stale material in the working set
- Carry state: useful memory survives the current session
LemonCrow Runtime product summary
LemonCrow is an open-core, local-first context and execution runtime for coding agents. It gives existing hosts including Claude Code, Codex, and opencode a ranked code graph, exact-range reads, bounded tool output, persistent memory, compaction support, and auditable session traces. LemonCrow is not an AI model, model provider, IDE, or hosted coding agent.
Every LemonCrow persona follows a code-hygiene ladder — reuse existing code,
prefer the standard library and native platform features, and write the
minimum that works — without trading away validation, error handling,
security, or accessibility. Deliberate shortcuts are tagged with an
lc-debt: marker and harvested into a ledger with
lc debt.
On the published SWE-bench Verified evaluation, LemonCrow used the same model while resolving 92.8% of runs versus 80.8% for baseline, a 12.0 percentage-point improvement, with 37.7% fewer turns and 23.7% less wall-clock time. Cost was 29.5% lower in that run. On Terminal-Bench 2.1, with both arms run at 89 tasks x 5 reps, LemonCrow tied baseline at 78.9% resolved while sending 98.6% fewer fresh input tokens and costing 16.0% less once cache-write pricing is normalized to a matched tier. These are benchmark results, not guarantees for every repository or task.
Context sharpness
Context gets noisy before it gets full.
More context is not automatically better context. Every search result, file read, tool schema, and discarded approach shares the same working window. Anthropic documents the same context-rot problem even with million-token sessions.
Search noise
The investigation becomes baggage.
Broad grep results, full-file reads, and long logs remain in the conversation after the useful line has been found.
Working-state drift
Yesterday's path competes with today's task.
Discarded approaches and stale observations keep consuming attention while current constraints become harder to retrieve.
Lossy handoffs
A summary keeps what it predicts you need.
Compaction and new sessions can drop an earlier decision unless the runtime records and restores it deliberately.
LemonCrow treats the context window as a working set: ranked code first, exact ranges on demand, bounded tool output, duplicate suppression, and persistent memory for facts that must survive the current conversation.
How it works
Install → map → stay sharp.
Step 01
Install
One command adds the MCP server, agents, skills, and hooks to every host you use.
$ curl -fsSL https://install.lemoncrow.com | bash
Step 02
It auto-indexesAUTO
Tree-sitter parses your repo into a symbol table ranked by call-graph centrality, then keeps itself fresh — only re-parsing files that changed. No step in your loop.
✓ indexed · 24 languages · incremental
Step 03
Stay sharpBOUNDED
The agent gets ranked symbols, exact ranges, bounded output, and reusable state instead of carrying the whole exploration transcript.
code_search("chargeCard")
→ source · 3 callers · 2 calleesThe first useful result
The answer arrives with its neighborhood.
Ask for chargeCard(). LemonCrow returns the definition that matters, the callers leading into it, the callees it depends on, and only the source ranges needed next.
The agent can act from the first result instead of building context from a trail of grep output.
code_search("chargeCard")ranked #1Why a runtime
The runtime controls what enters the conversation—and what must happen before it ends.
A search MCP is one optional tool. LemonCrow installs tools, agents, skills, and hooks as one working surface: find precise code, bound noisy output, carry useful state, and catch missing verification before the agent declares done. It is tuned end to end across input context and output — state-of-the-art retrieval, bounding, and compaction that out-measure grep-class code-index and output-compression tooling on the matched benchmarks.
Map
Find the right code first.
A local symbol and call graph ranks definitions, callers, callees, usages, and exact source ranges before the agent starts opening files.
Bound
Keep tool output proportional.
Outlines, range reads, capped command output, and recoverable spill files keep one noisy result from taking over the conversation.
Carry
Preserve what the task still needs.
Deduplication, compaction manifests, handover packets, and persistent memory keep useful state available without carrying the raw transcript forever.
Verify
Catch unfinished work before the agent stops.
After a verifiable edit, stop hooks check whether a successful behavioral test ran after the last change. If not, the agent gets one bounded nudge before it declares done.
code_searchGrep, Globranked symbols + exact rangesreadReadoutline or requested lineseditEdit, Writegrounded batch changesbashBashbounded output + recoverable spillweb_fetchWebFetchclean Markdown, not raw HTMLverify hookunchecked stoptest or verification nudgeFull runtime internals: architecture documentation.
Code hygiene
The best code is the code you never wrote—so every persona climbs a ladder first.
Before writing anything, the agent stops at the first rung that holds. The ladder runs after it understands the problem, not instead of it, and it never trades away validation, error handling, security, or accessibility. Lazy about the solution, never about reading the code first.
Never lazy about
- Trust-boundary validation
- Data-loss handling
- Security
- Accessibility
A small diff in the wrong place isn't lazy — it's a second bug. The rung is chosen after the real flow is traced end to end.
Debt stays visible
A deliberate corner with a known ceiling (global lock, O(n²) scan, naive heuristic) gets an lc-debt: marker. Harvest the ledger any time:
$ lc debt
→ file:line + note per deferred simplificationThe packaged code-audit workflow adds an over-engineering lens that returns a delete-list — code to remove, not rewrite.
Matched proof
Cleaner context should finish more work—not just process fewer tokens.
The flagship evaluation held the model, tasks, containers, turn limits, and verification harness constant. Only the LemonCrow runtime changed.
tasks resolved
80.8% baseline
resolution rate
same model and tasks
fewer turns
6,962 → 4,336
faster
14.3h → 10.9h
Cost was 29.5% lower in the same SWE-bench Verified run. It is a measured consequence of the tighter loop, not the primary promise. Results vary by repository and task.
Scale
It holds up on the repositories agents actually work in—faster to index, and more accurate than grep.
A cold full rebuild of the Linux kernel core—1.24M symbols across 4.5M lines—indexes in about three minutes, then answers ranked queries in sub-140ms at the 95th percentile. Retrieval quality is measured on ~7,200 query/answer pairs across 14 repos.
symbols indexed
Linux kernel core — ~3 min cold build (lexical)
p95 query latency
ranked search across 14 repos
retrieval MRR
vs 0.376 ripgrep — ~1.9× more accurate
zoekt reindex
same 1.24M-symbol repo, full rebuild
Per-repo indexing throughput and the full 13-tool retrieval comparison: BENCHMARKS.md →
LemonCrow session replay · read-only
See the wandering before you install.
Replay a recorded agent session without re-running a model. Trace repeated searches, oversized reads, and avoidable calls, then see how a tighter working set changes the path.
Run it locally
$ lemoncrow session replayNo model re-run · read-only · past sessions stay local
Local-first
Improve the agent without shipping your repo to another index.
LemonCrow adds a local code-intelligence and context runtime. Anonymous usage telemetry is on by default—counts, not source or prompts—and the one command below turns it off.
On-device
The code graph stays local.
Parsing and indexing run on your hardware. The symbol index is stored on disk, so using LemonCrow does not require uploading your repository to a hosted index.
Your provider
No new destination for prompts.
Model calls still go to the provider and account your coding agent already uses. LemonCrow sits on the local tool path between that agent and your repository.
Inspectable
Check the boundary yourself.
Published source and integrations are Apache-2.0; the Pro engine is a proprietary compiled component. Benchmark inputs, outputs, and reproduction commands are public.
From developer to team
Do not build another knowledge warehouse. Make existing knowledge executable.
Jira, Confluence, GitHub, and your repository remain sources of truth. LemonCrow's direction is the last mile: select what this change needs, keep it alive during the run, and return verified learnings for review.
Your codebase's code universe — 28,462 symbols · 38,811 nodes · 23,894 calls. Live, local, on this repo.
One developer, every host
Claude Code, Codex, and opencode use the same local code graph, bounded tools, and durable repository memory.
Source-linked engineering memory
Decisions, ADRs, tickets, and session learnings stay tied to the code, commit, and evidence that make them valid—with staleness and provenance visible.
A shared, governed working set
Every agent starts with the same reviewed rules and relevant project history, with role-based access, audit, and outcome evaluation.
Exploring · beyond code
Five greps to guess the right flags — or one plain statement. From a real session.
Before — the grep loop
After — one code_search
Collapses 5 calls (5 greps) into one, reaching the next real step 4 turns sooner — the agent just names what it wants.
Raw captures from the session: the grep loop · the one code_search call
The same gap exists in every AI-native product: search databases execute queries brilliantly, but someone still hand-builds the query construction, filters, and ranking around them. We're exploring a compiler for that layer — with pilot teams.
One command · your existing agent
Try it where your agent starts to wander.
Keep the model, editor, and workflow you already chose. Add the local runtime, then judge it on a repository that makes the default tools work for context.
Rolling it out to a team? contact@lemoncrow.com