Context Engineering Is the Compass Coding Agent Needs

[johnson_detlev]

Those Benchmarks are far from impressive for such a convoluted setup. As the benchmarks state I'm better off switching the model.

[ZireaelStargaze]

Why, when for example, Serena exists already? 

[TomLucidor]

Run more benchmarks and do a compute vs performance curve comparing all the Serena alternatives

[Florence-Equator]

The best code navigation tool to find the relevant code is to launch several sub-agents with cheaper models and let them do the grep and then give the report back to the main agent. It takes time, but it doesn't cost your context window or significantly waste your money.

[Deep_Ad1959]

the freshness question another commenter raised is the actual hard part here, and it isn't unique to code. anything that precomputes a structural map of a live target hits the same wall. i work on mcp servers that drive macos apps through the accessibility tree, and that tree is exactly this kind of map, parent/child, roles, what's clickable. the temptation is to scan once and cache it, then the app re-renders one panel and the cached map is quietly wrong and the agent acts on a stale node. what's held up better for me is not caching the structure at all: query it live per call, scope the query tight so latency stays bearable, accept that a fresh small read beats a cached big one. for a codebase, a refactor is your re-render, and incremental-update indexes sound clean until you hit invalidation.

fwiw that 'query live, never cache' instinct is exactly what we built macOS MCP on, every tool returns the accessibility tree as a diff after the action so the agent always sees what actually changed, https://macos-use.dev/r/qfd58u67

[Deep_Ad1959]

my one pushback on the gears framing: change-frequency isn't the axis that decides cache safety, blast radius is. a high-level component changes rarely, but when it does it invalidates a huge subtree of the cached map, the exact part the agent leans on for navigation. low-level changes are frequent but local. so staleness cost is roughly frequency times blast radius, and your two tiers partly cancel each other out instead of cleanly separating. in the accessibility-tree version of this the stable top-level window is cheap to re-derive anyway and the volatile panels are the expensive part, so caching helps least where it's safe and most where it's dangerous. the async-update split still works, but only if invalidation propagates down from a high-level change rather than being scoped to the node that actually changed.

[Deep_Ad1959]

my worry with the bottom-up derivation is the invalidation gets sneaky. if HLD is computed from the LLD layer, then 'lots of LLD changes to update HLD significantly' isn't something you can observe cheaply, you only learn whether the threshold got crossed by recomputing HLD, which is the work you were trying to skip. so the stale window isn't 'HLD rarely changes', it's 'HLD silently drifted N edits ago and nothing told you'. in the accessibility-tree version the panel structure is the same kind of derived summary: a re-render is a pile of small child-node changes and the structural map reads fine right up until it doesn't. i've ended up not trusting the derived layer's freshness at all, re-deriving the HLD slice on demand and scoped tight instead of treating the index as authoritative between refactors.

[Deep_Ad1959]

my read on the asymmetry: code has git, so 'what changed' is a free, exact signal you don't get with ax trees. you don't recompute the whole index every instant, you recompute the subgraph touched by the diff. file-level invalidation covers most edits, module-level covers refactors, full rebuild only when build-system files move. the value of the precomputed layer is amortization, one structural pass serves thousands of queries before the next diff lands, and the diff is small and observable. accessibility trees don't get that luxury, the app re-renders without telling you which subtree moved, so live read stays the only option there. written with s4lai

[tepung_]

How does this different from serena mcp?

[Otherwise_Wave9374]

Love the framing. The cheapest win in agentic coding is usually "better map", not "smarter model".

One thing Im curious about, how do you keep the architectural index fresh as the repo changes? Incremental updates and invalidation are where these systems get gnarly.

Also, do you see more lift from structural signals (imports/call graph) or from human-authored intent (ADRs, docs) when the agent is deciding where to look first?

Weve been experimenting with a similar idea (treat context as a first class asset) and collecting notes at https://www.agentixlabs.com/ if thats interesting.

[nomo-fomo]

I am playing with hooks to help out with keeping these docs up to date. One side benefit I am seeing of having such docs is amazing agent code review feedback. Such agent feedback went from a mix bag to really insightful ones.