Use Cases — Microservices
Cross-service context, compiled ahead of time, for every repo, through one connection.
“What changed wasn’t the model. It was the context.”
The challenge
Microservices break the one thing an agent depends on: seeing the code.
A coding agent is only as good as what’s in its field of view. In an enterprise software estate with hundreds of repos, the code that explains a change lives in services the agent never sees.
01
Co-locality
Agents reason only about code they can see. Nobody has 100+ repos cloned at once, so when the order service calls payment, the logic that matters was never in context.
02
Implicit dependencies
The links between services live in config strings, shared tables, and queues, not in code. The dependencies that matter are invisible to an agent reasoning over one repo.
03
Context that doesn’t scale
Per-repo docs go stale. Internal context tools become their own product to maintain. Neither keeps pace with how fast the system changes.
“The map of how our services fit together used to live in people’s heads. Now it lives where the agents can reach it.”
Why the usual fixes fall short
Driver compiles complete context ahead of time. Other approaches fall short.
Per-repo docs
Accurate the day they’re written, drifting by the next merge. Across hundreds of services the staleness compounds faster than any team can keep up with.
Homegrown tools
The instinct is to build internal context plumbing. A team at ShipBob started building one, then realized within weeks it would become a year-long product of its own, and stopped.
RAG / embeddings
Retrieval samples chunks by similarity. It returns the top-K chunks that look relevant while discarding the call graph, the shared schema, the producer/consumer link, the structure that actually defines the system.
How Driver solves it
Compile every codebase. Query them through one connection.
Driver compiles exhaustive, symbol-level context for every codebase ahead of time, then synthesizes across services at the moment a task needs it. The agent reasons over the system, not a single repo.
Without Driver
Reasons only about the repo in view. Everything else is a guess.
With Driver
One connection resolves to compiled context across every service.
One connection, all codebases
A single MCP integration. No co-locality requirement, nothing to clone or pre-index. The agent reaches every service through the same connection.
Cross-codebase context synthesis
Describe the task. Driver’s gather_task_context reads pre-computed context across the relevant services and returns one dense, high-signal answer — the capability that matters most when the work spans repos.
Always current
Incremental re-analysis runs on every push. Context stays accurate as the codebase moves, and nobody on the team is assigned to maintain it.
# gather_task_context( "why do bookings complete without a payment record?" ) → context across 5 services
On access: cross-repo context spans only the codebases a user is already authorized for. Access is enforced at the codebase level, so synthesis reads within those bounds, never around them. Deployment isolation (single-tenant SaaS or custom VPC) keeps IP contained.
Trust Center →In practice
Three places it changes the day-to-day.
Cross-service debugging
A bug that spans five services
Bookings completing without a payment record. The defect threaded through four or five services and had been missed several times. With cross-service context, it was traced and resolved in minutes.
Automated cross-repo tasking
One Jira story, split by repo
A 200+ microservices team built a skill that breaks a Jira story into per-repo subtasks using parallel calls to Driver’s gather_task_context. The “you’ve got to know which repos to touch” constraint simply disappears.
Onboarding
A service you’ve never opened
After a reorg, engineers get an architecture overview and cross-service context for a service they’ve never touched, instead of losing weeks rebuilding the map a departed expert carried in their head.
In an unfamiliar domain, context-gathering dropped from 30–40 minutes to about 10.
Case study
Measured in production, across 450+ repositories and 20M+ lines of code.
ShipBob — microservices architecture
450+ repos · 20M+ LOC
Before Driver, a domain expert changing teams meant 6–8 weeks of lost cross-service knowledge. Now that context is compiled and queryable on day one.
Read the full case study →Under the hood
Real infrastructure, not retrieval.
A symbol-complete compiler frontend reads each codebase exhaustively.
01
Compile
A symbol-complete compiler frontend builds exhaustive, structural understanding of every codebase.
02
Document
Deep Context Documents (architecture, onboarding, changelog), plus navigation primitives: code map, file/folder docs, raw source, history.
03
Synthesize
Driver’s gather_task_context runs as a headless sub-agent in a sandbox, using those same primitives across services.
04
Update
Incremental re-analysis automatically keeps the compiled context current as code changes.
Time to value
One connection. The tools you already use.
Driver connects through a single MCP integration and shows up inside the agents your team already works in — no migration, no new surface to learn.