architecting lexana at my nani's house: 4-agent swarms, 60% semantic cache hits, and sub-200ms p95 latency

in the summer of 2025, i spent nearly two months at my nani's place in Prayagraj.

there was no broadband connection. there was no ergonomic desk or dual-monitor setup. the power cut out twice a day, and the only reliable internet was a 4g mobile with hotspot turned on, kept on the second-floor window.

that was where i wrote the backend for Lexana.

when you are writing a multi-agent legal platform on a throttled mobile connection where every API call costs money you don't have, you learn very quickly that architectural discipline isn't an aesthetic choice. it's the difference between shipping something that works and running out of money before your first user runs a query.

the constraint: Indian law is massive, slow, and expensive#

the Indian legal corpus is enormous. millions of judgments, overlapping state and central statutes, inconsistent citation formats, and scanned PDF petitions running 80 to 200 pages.

if you throw a naive RAG pipeline at Indian case law using GPT-4, three things happen immediately:

1. your latency explodes. retrieving 50 chunks, re-ranking them, and stuffing 30k tokens into a reasoning model takes 12 to 18 seconds. no practicing advocate or law clerk is going to wait 15 seconds per question.
2. your API bills kill you. running multi-turn legal research across hundreds of active cases will burn thousands of dollars in token costs within days.
3. the model hallucinates citations. Indian case law relies on exact citations (AIR, SCC, SCR). a generic model will confidently cite a non-existent 2018 Supreme Court bench.

to solve this, Lexana had to be built around three non-negotiables: asynchronous concurrency, multi-tier semantic caching, and a distributed 4-agent swarm.

the 4-agent swarm architecture#

instead of one monolithic agent with twenty tools, Lexana divides cognitive responsibility across four specialized micro-services communicating over an asynchronous coroutine mesh:

1. QueryClassificationService: Every incoming query hits Gemini 2.0 Flash Lite first. within 40ms, it classifies intent, complexity, statutory jurisdiction, and extracts search entities. if the query is a simple procedural lookup, it routes directly to deterministic vector search without waking up expensive reasoning models.
2. SearchAgent: Orchestrates parallelized retrieval across Indian Kanoon APIs, vector databases (ChromaDB), and live statutory web sources via Exa. it implements MapReduce-style aggregation with cosine deduplication (similarity threshold > 0.85) to strip redundant headnotes before passing context downstream.
3. ReviewAgent: Built specifically for long-form document analysis. it chunks 100-page petitions, runs parallel issue classification (F1 = 0.94), evaluates evidentiary strength against statutory precedents, and generates structured risk scores.
4. VibeDraftingAgent: A real-time collaborative document editor. instead of generating static blocks of text, it uses an Operational Transformation (OT) engine compatible with conflict-free replicated data types (CRDTs). lawyers can edit clauses in real time while the AI suggests revisions as non-blocking diffs.

the L1/L2 caching hierarchy: shaving 60% off LLM spend#

the biggest win in Lexana's economics came from our two-tier caching architecture:

• L1 In-Memory Cache (Redis LRU): exact hash matches on normalized query tokens with a 300-second TTL for hot conversational sessions.
• L2 Semantic Cache: for queries that aren't identical string matches but ask the same legal question (e.g., "quashing of FIR under Section 482 CrPC for matrimonial dispute" vs. "can 482 CrPC be invoked to quash 498A FIR after settlement"), we compute query embeddings $\mathbf{q}$ and compare them against an indexed set of prior verified synthesized queries $\{\mathbf{k}_i\}$:

$\text{sim}(\mathbf{q}, \mathbf{k}_i) = \frac{\mathbf{q} \cdot \mathbf{k}_i}{\|\mathbf{q}\|_2 \cdot \|\mathbf{k}_i\|_2} \ge \tau = 0.92$

if the cosine similarity threshold exceeds $0.92$, we return the validated cached synthesis with instant metadata hydration.

fault tolerance and WebSocket multiplexing#

when legal teams collaborate on an urgent bail application or injunction petition at midnight, dropped connections are fatal.

we built the backend in async FastAPI with strict concurrency guards:

• Async batching with bounded semaphores: preventing external rate-limit locks when 50 search coroutines execute concurrently.
• Hystrix-style circuit breakers: with exponential backoff (1s base, 2x multiplier) across all third-party legal API endpoints.
• WebSocket multiplexing: SockJS fallback with 30-second heartbeat pings, preserving state even over shaky tier-3 broadband or mobile connections.
• Git-inspired DAG version history: every suggested draft change lives on a version graph with automated 3-way merge resolution, so an AI suggestion never overwrites an attorney's manual edit.

building without permission#

people often think you need a massive team, a venture round, and an office in Bangalore to build production-grade AI infrastructure.

the reality is that constraints force good engineering. sitting in a warm room in Prayagraj with a fan whirring overhead, every millisecond of latency and every redundant dollar spent on token calls felt real. Lexana was pitched to angels, backed, and is now operating across borders in Nepal.

you don't need ideal conditions to ship serious systems. you just need to care enough about the architecture to make every line of code earn its place.