import { Innovation } from '@sandbox-union/core';if (complex) return simplify(solution);const future = await buildWhatIsNext();export default function Excellence() { return <Results />; }return <FutureProof />;const platform = new EnterpriseScale({ reliable: true });while (running) { optimize(); }await integration.connect(systems.legacy, systems.cloud);interface Success { quality: boolean; speed: 'fast'; }data.map(insight => transform(insight));git push origin feature/next-big-thingconst architecture = designFirst ? 'robust' : 'brittle';deploy({ target: 'production', strategy: 'rolling' });await integration.connect(systems.legacy, systems.cloud);while (running) { optimize(); }data.map(insight => transform(insight));git push origin feature/next-big-thingconst platform = new EnterpriseScale({ reliable: true });const architecture = designFirst ? 'robust' : 'brittle';return <FutureProof />;export default function Excellence() { return <Results />; }const future = await buildWhatIsNext();if (complex) return simplify(solution);import { Innovation } from '@sandbox-union/core';interface Success { quality: boolean; speed: 'fast'; }deploy({ target: 'production', strategy: 'rolling' });data.map(insight => transform(insight));export default function Excellence() { return <Results />; }import { Innovation } from '@sandbox-union/core';const architecture = designFirst ? 'robust' : 'brittle';const platform = new EnterpriseScale({ reliable: true });deploy({ target: 'production', strategy: 'rolling' });if (complex) return simplify(solution);const future = await buildWhatIsNext();await integration.connect(systems.legacy, systems.cloud);interface Success { quality: boolean; speed: 'fast'; }while (running) { optimize(); }git push origin feature/next-big-thingreturn <FutureProof />;const platform = new EnterpriseScale({ reliable: true });import { Innovation } from '@sandbox-union/core';const future = await buildWhatIsNext();interface Success { quality: boolean; speed: 'fast'; }export default function Excellence() { return <Results />; }while (running) { optimize(); }return <FutureProof />;deploy({ target: 'production', strategy: 'rolling' });git push origin feature/next-big-thingdata.map(insight => transform(insight));const architecture = designFirst ? 'robust' : 'brittle';await integration.connect(systems.legacy, systems.cloud);if (complex) return simplify(solution);

git push origin feature/next-big-thingreturn <FutureProof />;const architecture = designFirst ? 'robust' : 'brittle';data.map(insight => transform(insight));if (complex) return simplify(solution);interface Success { quality: boolean; speed: 'fast'; }import { Innovation } from '@sandbox-union/core';const platform = new EnterpriseScale({ reliable: true });export default function Excellence() { return <Results />; }deploy({ target: 'production', strategy: 'rolling' });await integration.connect(systems.legacy, systems.cloud);const future = await buildWhatIsNext();while (running) { optimize(); }import { Innovation } from '@sandbox-union/core';data.map(insight => transform(insight));deploy({ target: 'production', strategy: 'rolling' });const architecture = designFirst ? 'robust' : 'brittle';return <FutureProof />;await integration.connect(systems.legacy, systems.cloud);while (running) { optimize(); }const future = await buildWhatIsNext();export default function Excellence() { return <Results />; }const platform = new EnterpriseScale({ reliable: true });git push origin feature/next-big-thingif (complex) return simplify(solution);interface Success { quality: boolean; speed: 'fast'; }return <FutureProof />;const architecture = designFirst ? 'robust' : 'brittle';const future = await buildWhatIsNext();deploy({ target: 'production', strategy: 'rolling' });data.map(insight => transform(insight));git push origin feature/next-big-thingexport default function Excellence() { return <Results />; }while (running) { optimize(); }interface Success { quality: boolean; speed: 'fast'; }if (complex) return simplify(solution);import { Innovation } from '@sandbox-union/core';await integration.connect(systems.legacy, systems.cloud);const platform = new EnterpriseScale({ reliable: true });return <FutureProof />;const future = await buildWhatIsNext();import { Innovation } from '@sandbox-union/core';git push origin feature/next-big-thingawait integration.connect(systems.legacy, systems.cloud);deploy({ target: 'production', strategy: 'rolling' });data.map(insight => transform(insight));export default function Excellence() { return <Results />; }const architecture = designFirst ? 'robust' : 'brittle';const platform = new EnterpriseScale({ reliable: true });interface Success { quality: boolean; speed: 'fast'; }if (complex) return simplify(solution);while (running) { optimize(); }

export default function Excellence() { return <Results />; }deploy({ target: 'production', strategy: 'rolling' });await integration.connect(systems.legacy, systems.cloud);while (running) { optimize(); }data.map(insight => transform(insight));git push origin feature/next-big-thingconst architecture = designFirst ? 'robust' : 'brittle';import { Innovation } from '@sandbox-union/core';const future = await buildWhatIsNext();interface Success { quality: boolean; speed: 'fast'; }return <FutureProof />;if (complex) return simplify(solution);const platform = new EnterpriseScale({ reliable: true });import { Innovation } from '@sandbox-union/core';git push origin feature/next-big-thingexport default function Excellence() { return <Results />; }const future = await buildWhatIsNext();return <FutureProof />;if (complex) return simplify(solution);data.map(insight => transform(insight));const architecture = designFirst ? 'robust' : 'brittle';deploy({ target: 'production', strategy: 'rolling' });const platform = new EnterpriseScale({ reliable: true });interface Success { quality: boolean; speed: 'fast'; }await integration.connect(systems.legacy, systems.cloud);while (running) { optimize(); }import { Innovation } from '@sandbox-union/core';git push origin feature/next-big-thingexport default function Excellence() { return <Results />; }const future = await buildWhatIsNext();if (complex) return simplify(solution);return <FutureProof />;await integration.connect(systems.legacy, systems.cloud);const architecture = designFirst ? 'robust' : 'brittle';data.map(insight => transform(insight));while (running) { optimize(); }interface Success { quality: boolean; speed: 'fast'; }const platform = new EnterpriseScale({ reliable: true });deploy({ target: 'production', strategy: 'rolling' });return <FutureProof />;const architecture = designFirst ? 'robust' : 'brittle';await integration.connect(systems.legacy, systems.cloud);deploy({ target: 'production', strategy: 'rolling' });export default function Excellence() { return <Results />; }import { Innovation } from '@sandbox-union/core';if (complex) return simplify(solution);while (running) { optimize(); }const future = await buildWhatIsNext();git push origin feature/next-big-thinginterface Success { quality: boolean; speed: 'fast'; }data.map(insight => transform(insight));const platform = new EnterpriseScale({ reliable: true });

Back to Work

Autonomous Legal Triage for Plaintiff Firms

The Challenge

Unstructured intake data: Narrative answers, partial forms, and inconsistent case descriptions that don’t fit neatly into dropdowns or fields.
Inconsistent triage: Different staff members interpret the same lead differently, leading to missed high-value cases and uneven client experiences.
Attorney bottlenecks: Lawyers are forced to read through entire conversations or PDFs before making a simple go/no-go decision.
Need for explainability: Any scoring must be transparent enough that an attorney can understand why a lead was prioritized.

Our Solution

Case Compass built an autonomous legal triage layer on top of Google Gemini that sits between raw intake and attorney review.

At a high level, the system:

Reads the story, not just the fields The AI ingests the full intake narrative and related context, rather than relying solely on a handful of required fields. It understands what actually happened, who was involved, and how serious the claimed harm may be.
Generates a multi-dimensional lead score Each lead is evaluated across several dimensions that matter to plaintiff firms—such as potential case strength, urgency, and economic upside—and rolled into a single, easy-to-understand score.
Classifies and tags the case The system associates each lead with likely case categories (e.g., MVA, premises, med mal, product liability) and tags it accordingly, so firms can route matters to the right team without manual sorting.
Surfaces key facts and flags Alongside the score, the platform highlights important facts, potential red flags, and what’s missing. Attorneys see, in plain language, why a lead looks promising or risky.
Suggests targeted follow-up When the AI detects gaps in the story—missing documents, unclear liability, or incomplete treatment—it suggests focused follow-up items so staff know exactly what to ask next.

All of this appears directly inside the Case Compass lead profile as an “AI Lead Scoring” panel, so attorneys and intake teams can trigger analysis, review results, and re-run scoring as new information arrives—without ever leaving their existing workflow.

Why Gemini

The SandBox Union team selected Google Gemini for Case Compass as the foundation for this triage engine because it balances three critical needs for legal teams:

Deep language understanding: Gemini is well-suited to parsing long, messy narratives and legal-ish language that shows up in real intake conversations.
Structured, reliable outputs: The model supports generating highly structured responses, which Case Compass uses to power consistent scoring and tagging rather than one-off “AI summaries.”
Enterprise-grade posture: With Gemini’s enterprise terms and billing model, firms can run AI triage on sensitive intake data under clear, business-ready data use commitments (see Gemini API Terms).

The Outcome

With Autonomous Legal Triage in production, firms on Case Compass can:

Prioritize in seconds: High-value, time-sensitive leads are surfaced automatically instead of being buried behind low-quality submissions.
Reduce attorney review time: Lawyers see a concise score, key facts, and issues instead of a wall of unstructured text.
Standardize intake decisions: Every lead is evaluated through the same objective lens, reducing inconsistency and bias across staff.
Unlock hidden value: Historical leads can be re-run through the triage engine to identify overlooked opportunities in old intake data.

The result is a practical, deployable AI capability: not a chatbot, but a quiet triage engine that continuously converts raw intake into a ranked, explainable pipeline of cases ready for attorney judgment—exactly where plaintiff firms gain real leverage.

Project delivered successfully

Technology Stack

Gemini

RAG

Angular

MariaDB

nodeJS

ExpressJS

AWS

Ready to build something similar?

Our team specializes in complex enterprise solutions just like this one.

Start Your Project