Indian court files are still bound with red tape, the literal kind. This body of work pulls on that thread. It studies the Indian justice system at three levels: what makes the system slow, what patterns exist inside particular kinds of litigation, and how AI can reason over law reliably enough to make it accessible to ordinary people.
These projects were not designed as one grand plan from day one. Research rarely works that way. But each project answered a question that made the next one unavoidable, and in hindsight they form a single connected stack.
Not "how big is the backlog", but "what kind of congestion mechanism produces it?"
Most discussion of judicial pendency treats a court as a queue: cases enter, cases wait, cases leave. Useful, but crude. A court is better modelled as a process network in which a case moves through filing, registration, admission, interlocutory proceedings, hearings, and disposal, and different courts fail at completely different stages while showing similar headline pendency.
A graph-theoretic analysis of structural bottlenecks in Indian High Courts, built on the DAKSH High Court Data Portal. Classifies court failure into input bottlenecks (too much incoming litigation), capacity bottlenecks (insufficient judicial resources to process what enters), and output bottlenecks (cases stuck in particular procedural states).
Shows that Indian High Courts fail in structurally different ways at different stages of the case lifecycle rather than sharing one homogeneous backlog problem. The policy implication is sharp: if the bottleneck is at intake, appointing judges alone will not fix it; if it is downstream, more judges simply feed the same blockage.
System-wide statistics say courts are congested. Datasets say what the congestion is made of.
Legal AI cannot become reliable by throwing PDFs into a vector database. Someone has to build the intermediate representation: structured, labelled, machine-readable records of what courts and tribunals actually decided. These datasets are that infrastructure.
Structured outcomes, metadata and a knowledge-graph component for litigation around IPC Section 498A, the Domestic Violence Act and CrPC Section 482 quashing petitions. Rather than starting from the politically radioactive question "is 498A misused?", the dataset asks better ones: which cases reach higher courts, which get quashed, at what level, under what procedure.
One striking finding: 57.6% of quashing petitions succeeded at the Supreme Court against 39.7% at the Karnataka High Court (59.3% for the matched 2018–2024 window, a gap of roughly 19.6 points). That does not prove misuse; selection effects are huge. It does raise a scientifically serious question about why relief probability shifts so much across judicial levels.
Extends the same method beyond courts into administrative justice: Central Information Commission decisions with outcome labels, exemption citations, IRAC-style reasoning components and procedural timelines, combining 1,218 cases from an existing instruction-response corpus with 298 CIC decision PDFs across multiple document-format generations. This is where the work moves closest to the citizen, who mostly wants to know: what happened, why, which exemption, and what might happen in a similar case.
The connective tissue of the whole programme. IRAC (Issue, Rule, Analysis, Conclusion) is usually taught as a law-school writing mnemonic. inIRAC reinterprets it as a machine-readable ontology: an Issue is governed by a Rule, a Rule is supported by a Statute and interpreted by Precedent, Analysis applies them, and a Conclusion follows. Once a judgment is represented this way, legal reasoning becomes traversable rather than 30 pages of undifferentiated text.
Semantic similarity is not legal authority. A fluent answer is not a legally valid one.
Conventional legal RAG embeds a question, finds the top-k similar chunks, and lets an LLM write an answer. The problem is that similarity is not validity: a retrieved judgment may be semantically close yet overturned, procedurally irrelevant, distinguishable, from the wrong court, or simply not supportive of the proposition claimed.
QUESTION ↓ identify ISSUE ↓ retrieve structured legal graph ↓ LLM proposes reasoning ↓ VERIFIER AGENT — does a valid supporting path exist? / \ YES NO ↓ ↓ accept revise / reject / abstain
The system retrieves an IRAC knowledge graph rather than text chunks, lets the model propose reasoning, and then requires a Verifier Agent to find an explicit supporting path in the graph before any answer is accepted. The paper frames the verifier as a falsifiability oracle and evaluates graph-native measures: citation grounding accuracy, path validity, hallucinated precedent rate, and conflict detection. Later citation-hallucination research has already begun citing this work.
The durable idea is not the database. It is the separation of generation from verification: an AI system's legal claims should be structurally inspectable, and rejectable when the evidence is absent.
The public-facing argument behind the paper, written for a wider audience: semantic similarity is not legal authority, retrieval is not reasoning, a citation is not support, and a fluent answer is not a legally valid one. If the paper is the architecture, this is the philosophy.
Falkor-IRAC asks whether we can trust the machine's reasoning. NyayaSaar asks whether a person can understand the result.
A parameter-efficient fine-tune that translates dense Indian legal reasoning into plain language while preserving legal meaning, targeting the specific obstacles that keep citizens out: archaic terminology, procedural complexity, dense sentences and formal phrasing. It is not an isolated LoRA experiment; it is the human-interface layer of the whole architecture.
The prototype ancestor. A perfectly conventional PDFs-to-embeddings-to-RAG system, kept public because it documents the evolution: generation one retrieved legal text; recognising its limits led to structured datasets, then graph-native reasoning, then verification. The early chatbot is the fossil record of that progression.
A citizen asks: "Can my 498A case be quashed?" IMLJD finds comparable litigation patterns. Falkor-IRAC constructs verified legal reasoning. NyayaSaar translates it into plain English, along with what the system cannot determine. That is considerably more than a legal chatbot.
| Work | Research question | Level |
|---|---|---|
| STRIDE / DAKSH analysis | Why are Indian courts slow, and where are the bottlenecks? | Judicial system |
| SSRN bottleneck paper | Can court failure be classified structurally rather than by pendency alone? | Empirical legal studies |
| IMLJD | What patterns exist in matrimonial, 498A, DV and quashing litigation? | Case-law analytics |
| 498A analysis | How do outcomes differ across courts and procedural contexts? | Domain empirical law |
| RTI-Bench | Can administrative RTI decisions be structured and analysed computationally? | Administrative justice |
| inIRAC | Can Indian judgments be represented as explicit reasoning structures? | Knowledge representation |
| Falkor-IRAC | Can legal AI be forced to verify its reasoning against a graph? | Legal AI |
| Verifier Agent | Can unsupported legal claims be rejected rather than merely generated? | AI reliability |
| NyayaSaar-LoRA | Can legal reasoning be translated into understandable language efficiently? | Access to justice |
| Legal chatbot | Can citizens interact conversationally with legal information? | User interface |
| Medium: Why Vector RAG Fails in Law | Why is conventional RAG insufficient for legal reasoning? | Public framing |
Court delay is not one number. A judgment is not one embedding. A dispute is not a similarity score. Every project replaces a flat representation with structured relationships.
Knowing Court A is slower than Court B is not enough; the question is where in the lifecycle it fails. Knowing an LLM answered correctly is not enough; the question is what chain of authority supports it.
Ordinary evaluation asks whether an answer looks right. This work asks whether we can prove where it came from, and reject it when the evidence is absent. Hence verifier agents, citation paths and conflict detection.
Lawyers, courts and repeat institutional litigants know far more than the ordinary litigant. Each project attacks a different form of that gap: why the system is slow, what actually happens in cases, what reasoning is supportable, and whether a person can understand it.
Most legal AI asks one question: what does the law say? Combining these layers points to a second, simultaneous question: what is actually happening to the case institutionally? A litigant can have excellent substantive law on their side and still spend twelve years trapped in procedure.
Joining STRIDE's procedural graph with the doctrinal graphs of inIRAC and Falkor-IRAC would model both at once: where a case is stuck, and what law governs it. A case digital twin, for a justice system that badly needs one.