Deliberate

Deliberate lets lawyers run the trial before the real trial begins, using thousands of AI juror courtroom simulations to expose weak arguments, likely holdouts, and verdict risk in minutes.

Comment

Inspiration

Trial preparation has a brutal asymmetry. Lawyers spend months preparing for a room they cannot see. One phrase in an opening, one mishandled exhibit, one juror who refuses to move, any of these can decide millions of dollars, or someone's freedom. Teams usually discover those weaknesses on the day they stop being fixable.

Mock trials exist for exactly this reason, but they are expensive, slow, and almost impossible to iterate on. You cannot run ten versions of the same opening. You cannot swap exhibit order and re-run the room. You cannot ask, "What kind of juror does this argument lose?" every time strategy shifts.

We built Deliberate to close that gap. Trial prep should feel less like guessing, and more like simulation. Rehearse the case, watch the room react, fix the argument while there is still time.

What it does

Deliberate runs the trial before the trial.

A litigator opens a matter, reviews the case file and evidence, seats a 12-person mock panel drawn from a larger library of AI juror personas, and watches deliberation unfold. As jurors argue, vote, and shift, the product surfaces which arguments are persuading, where holdouts are forming, which exhibits are moving the room, and how verdict risk is changing round by round.

The platform covers the full litigator workflow:

  • Case dashboard: active matters, verdict splits, risk signals, and activity across the firm
  • Live trial room: real-time deliberation, juror reasoning chains, evidence influence weighting, and ballot movement across rounds
  • Persona analytics: influence networks showing who is moving whom, and panel-composition diagnostics
  • Argument heatmap: which lines of argument earn ground, which lose it, and against which juror profiles
  • Case library: a workspace for managing matters over time, not a single-use demo

The thesis is simple: before a lawyer walks into court, Deliberate shows which version of the case is most likely to survive a jury.

How we built it

The live deliberation engine in the trial room is powered by the Claude API. Each seated juror is a separately-instantiated agent with a structured persona: demographics, priors, decision-making style, and cognitive load tolerance. Each juror also has access to the case facts.

Deliberation proceeds in rounds: jurors read the current state of the room, respond in character, and re-ballot. Vote shifts, influence edges, and evidence-weight changes are computed from the trace of those exchanges, not pre-scripted.

The surrounding product, including the dashboard, case library, persona analytics, and argument heatmap, is built as a working front-end on structured case data, designed so a litigator can navigate the full workflow end-to-end rather than evaluating a single screen in isolation. We scaffolded the supporting views with realistic seed data, so judges and future pilot users experience the product as it would behave with a populated firm, not an empty shell.

We structured the build around the exact journey a user encounters:

  1. First impression: a landing page that reads as a serious legal AI product, not a hackathon page.
  2. Intake: a request-access flow that mirrors how law firms actually onboard.
  3. Core product: a dashboard for managing matters across a team.
  4. Live simulation: the deliberation room, where the Claude-driven jurors do the actual work.
  5. Strategy layer: analytics that turn deliberation into something a partner can act on.

MeDo accelerated the front-end iteration loop, which mattered because Deliberate has to look and feel like infrastructure a trial team would trust with a real case, not a demo.

Challenges we ran into

The hardest problem was making the product feel both futuristic and legally believable. It is easy to ship an AI demo that promises "predict the verdict." It is much harder to build one that respects how trial work actually happens: lawyers reason about evidence, venue, persuasion, uncertainty, and holdouts, and they distrust anything that papers over that complexity.

A few specific things we had to get right:

  • Legal precision: Civil cases do not speak in criminal-trial language. We audited the product for terms like guilty / not guilty / reasonable doubt, and replaced them with plaintiff / defense / preponderance / burden of proof where appropriate.
  • Juror semantics: Deliberate does not have "12 personas." It seats a 12-person panel drawn from a much larger library, the same way a real venue produces a panel from a venire. Getting this language clean across the UI mattered for credibility.
  • Persona stability: Claude-driven jurors can drift if prompted loosely. We constrained personas, so a "skeptical retired engineer" stays skeptical and engineering-minded across rounds, even under social pressure from the panel, because that is exactly the behavior trial consultants care about.
  • Design posture: Legal software defaults to either dated, or generic-SaaS. We pushed for a calmer, more operational aesthetic, closer to a Bloomberg terminal than a consumer app, because that is what the workflow demands.

Accomplishments we're proud of

Deliberate behaves like a product, not a mockup. The dashboard, trial room, persona analytics, argument page, and case library all work together as one system. A judge can move through the product the way a litigator would, and the screens hold up under that scrutiny.

The live trial room is the piece we are most proud of. Watching Claude-driven jurors actually argue with each other, one juror picking up on another's reasoning, a holdout emerging, the foreperson reframing the question, is the moment the product stops feeling like an idea, and starts feeling like infrastructure.

We are also proud of the concept itself. AI applied to chatbots is crowded. AI applied to simulated deliberation as a rehearsal layer for litigation is unclaimed, important, and immediately understandable: run the trial before the trial.

What we learned

The strongest AI products are not chatbots. They are systems that turn messy expert work into structured feedback loops, and the interface carries as much of the value as the model.

For trial teams, the answer "the AI predicts you win" is worthless. The valuable output is: here is which argument lost ground in round three, here is the juror profile it lost ground with, here is the exhibit that pulled two votes back. That kind of feedback only works if the product shows reasoning, movement, uncertainty, and evidence, which forced us to design Deliberate around traceability from the start.

We also learned how much narrative discipline a hackathon build demands. Judges need to understand the problem in seconds, and still find depth on closer inspection. Deliberate got stronger every time we treated the screens as one story: upload the case, simulate the room, find the weakness, improve the strategy.

What's next for Deliberate

The roadmap is straightforward, and the demo points directly at it:

  • Document ingestion: pleadings, exhibits, depositions, and trial transcripts feeding the case file automatically, with key-fact extraction.
  • Venue-aware panel generation: juror personas seeded from real demographic and attitudinal data for a specific jurisdiction, not generic profiles.
  • Strategy variants: running the same case with N argument orderings or theme variants in parallel, then ranking them by verdict risk.
  • Exportable strategy memos: partner-ready outputs that summarize what moved the room, what didn't, and what to change before voir dire.
  • Collaboration: multi-user workspaces so trial teams can share simulations, annotate moments, and build on each other's runs.
  • Education mode: a judge-friendly, classroom-friendly version for law schools, clinics, and trial advocacy programs.

Long term, Deliberate becomes the simulation layer for litigation, the place trial teams rehearse, measure, and improve before the stakes are real.

Built With

Share this project:

Updates