LexisGuide

LexisGuide turns confusing legal and government documents into plain-language explanations, actionable next steps, and verifiable review histories.

Comment

Inspiration

Legal and government documents are often technically valid but practically impossible to understand. A benefits denial, lease, contractor agreement, or administrative notice may contain important deadlines and rights, yet bury them in dense legal language or omit the information a person needs to act.

We were inspired by a simple question?

What if people could understand what a document means, identify what may be missing or unfair, and know what to do next—without needing to be a lawyer just to begin?

That led us to build LexisGuide, an AI-assisted guide for legal documents, government notices, denials, public forms, and shared agreements.

LexisGuide is designed as decision support, not legal advice. It helps people understand documents, prepare better questions, and review changes while keeping the final decision with the people involved.

What it does?

LexisGuide lets users upload or paste a document and receive:

  • Plain-language explanations of difficult clauses
  • Potentially risky, vague, or unusual terms
  • Important dates, deadlines, obligations, and appeal windows
  • Practical next steps
  • Findings linked to the exact source text that triggered them
  • A shared workspace for reviewing documents with another person
  • Version history and a verifiable review trail

The system is useful for tenants, benefits recipients, freelancers, small businesses, legal-aid clinics, and public agencies.

A typical workflow is:

  1. Upload a notice, agreement, PDF, Word document, HTML page, or plain text.
  2. Extract important parties, dates, deadlines, obligations, and legal references.
  3. Analyze the document using AI-assisted review and deterministic checks.
  4. Explain each finding in plain language.
  5. Suggest an ordered list of practical next steps.
  6. Revise the document and compare versions.
  7. Preserve a verifiable history of what changed and why.

How we built it?

The frontend is a React and TypeScript application built with Vite. It provides the landing page, document workspace, review interface, chat assistant, document history, shared collaboration features, and responsive visual design.

The backend is a Python FastAPI service. It handles authenticated API requests, document review workflows, workspace data, conversations, and integrations.

For AI analysis, we use Amazon Bedrock and AgentCore. The assistant uses a routing layer and specialist agents for document review, legal questions, research, drafting, support, inbox tasks, and workspace operations. Specialists can work in parallel, while deterministic fallbacks keep the application useful when a model or external service is unavailable.

We intentionally combine AI with deterministic logic. AI is useful for extracting and explaining information, while rule-based checks provide predictable findings for issues such as:

  • Missing or unclear deadlines
  • Missing appeal instructions
  • Unexplained consequences
  • Conflicting dates or instructions
  • Unclear responsibilities
  • Ambiguous or unusually broad clauses

The application uses AWS Cognito for authentication, API Gateway and Lambda for the API layer, DynamoDB for user and workspace data, and Terraform for infrastructure management. The browser never receives AWS credentials.

We also built a document provenance layer using a DocumentLedger smart contract on Base Sepolia. Rather than storing document contents on-chain, LexisGuide records privacy-preserving fingerprints such as document hashes, change identifiers, review types, and version relationships. This creates an auditable chain without exposing the underlying document text.

What we learned?

We learned that legal-tech AI requires more than generating a convincing answer. A useful system must show:

  • Where a conclusion came from
  • Which version of the document was reviewed
  • What rule or pattern was triggered
  • What the model does not know
  • Which actions are suggestions rather than decisions
  • How a human can review, reject, or override a recommendation

We also learned that product scope matters. Instead of pretending to understand every law in every jurisdiction, we focused on a narrower workflow and designed the architecture to support jurisdiction-specific rule packs in the future.

Building the assistant taught us how to coordinate multiple specialized agents, add deterministic fallbacks, enforce time limits, structure model outputs with shared contracts, and ensure that application actions are controlled by the application rather than blindly executed by the model.

Challenges we faced?

One of our biggest challenges was balancing helpfulness with safety. Legal documents are high-stakes, so the system must not present uncertain AI output as legal advice. We addressed this by grounding findings in the uploaded document, linking explanations to evidence, clearly labeling the product as decision support, and keeping humans in control of every important action.

Another challenge was reliability. Model responses can be incomplete, slow, or inconsistent. We designed a shared review contract, structured response models, deterministic checks, rule-based routing fallbacks, and specialist deadlines so the application can still respond safely when an AI call fails.

Privacy was also a major design concern. Legal documents may contain sensitive personal information. We used authenticated access, per-user data isolation, server-side credentials, inert document extraction, and on-chain fingerprints instead of storing document contents publicly.

Finally, we had to make a complex system understandable. The product needed to feel approachable to someone receiving a confusing letter, while still giving advocates and agencies enough evidence to audit a finding. We focused the interface around three questions:

  1. What does this document say?
  2. What might be missing or risky?
  3. What should I do next?

Built With

Share this project:

Updates

Submission history