Compliance Bot, AI-accelerated drafting and review of regulatory documents

Project Overview

Compliance Bot is an AI assistant that drafts and reviews regulatory documents for teams in finance, healthcare, and legal. It produces the structural backbone of a document, flags compliance-relevant clauses in third-party files, and hands every output to a human reviewer for sign-off. The goal was simple: cut the manual time spent on repetitive paperwork without lowering the bar for accuracy.

Client Background

The client is a confidential LegalTech operator working with regulated industries. Their customers run compliance programs where every audit cycle and every policy update triggers a wave of drafting and review work. The client wanted an AI layer that fit inside that workflow, not a separate tool that replaced it.

The Problem

Regulated teams spend a disproportionate share of their week on documents that look similar across audits but cannot be templated naively. A single missed clause in a vendor contract or a misstated control in a policy can trigger findings, fines, or remediation work that dwarfs the cost of the drafting itself. Because of that, no team is willing to skip a human review, even when 80 percent of the work is mechanical. The result is a backlog: senior reviewers spend their time on first drafts that an assistant could prepare, and third-party document reviews stack up behind policy work.

Challenges

• Documents are long. Many run past the context window of general purpose LLMs, so we needed a parsing and chunking layer rather than raw prompts.
• Accuracy is non-negotiable. The system had to make it easy for humans to verify and edit, not hard to override.
• Three domains, three vocabularies. Finance, healthcare, and legal each have their own clause patterns and reference frameworks.
• Audit trails matter. Every generated draft and every flagged clause needs to be traceable back to its source.
• Reviewers are skeptical of AI by default. The interface had to earn trust rather than ask for it.

Our Approach

We started by sitting with the drafting and review work itself: what reviewers actually do, where they slow down, and which steps they would never delegate. From that we drew a line between mechanical work, structure, boilerplate, clause spotting, and judgement work, interpretation, risk weighting, sign-off. The AI took the first; humans kept the second. We then designed the system around three constraints: handle long documents reliably, route requests through domain-specific knowledge, and keep a clean audit trail from input to output.

What We Built

User Experience

Compliance users start either from a blank draft with a domain template, or by uploading a third-party document for review. The interface keeps the AI output and the source side by side, so reviewers can verify each suggestion against the underlying text without switching windows.

Automation

The drafting agent generates the structural backbone of a regulatory document: sections, headings, and standard clauses for the chosen domain. The review agent parses uploaded documents and flags clauses that touch the relevant compliance regime. Both feed into the same review surface.

Integrations

The system uses a document parsing layer to handle long files, an LLM provider for generation, and a per-domain knowledge base for finance, healthcare, and legal content. Outputs are written back to the application store with a link to the prompt and source used.

Security

Every draft and every flagged clause is logged with its source, model call, and reviewer actions. Human approval is required before any document is exported.

Technical Architecture

The system is built as a thin web application in front of an agent orchestrator. The orchestrator routes each request through a domain-aware prompt builder, calls the LLM provider, and pulls supporting context from the relevant knowledge base. Long documents are parsed and chunked before they reach the model, so context limits are handled outside the prompt layer.

Key Decisions

• Human in the loop, always. We chose to design the product around reviewer trust instead of full automation. We gave up the headline of an autonomous system in exchange for adoption by teams that would not accept one.
• Per-domain knowledge bases instead of one shared corpus. We chose to split finance, healthcare, and legal content into separate stores. We gave up some implementation simplicity to avoid cross-domain bleed in prompts.
• Dedicated parsing layer for long documents. We chose to parse and chunk outside the LLM rather than relying on long-context models alone. We gave up some latency to keep behaviour predictable on contract-length inputs.
• Audit-first logging. We chose to log prompts, sources, and reviewer actions from day one. We gave up some build speed to keep the system defensible for compliance use.

Results

Compliance teams produce more documents at the same headcount, because the mechanical part of drafting is no longer the bottleneck. Reviewers catch more issues in third-party documents, because the system surfaces the clauses worth reading first. The workflow is faster end to end, the manual load is lower, and reviewers keep the final word on every output.

Project Highlights

• AI-assisted drafting that produces the structural backbone of regulatory documents.
• Intelligent review that parses third-party documents and flags compliance-relevant clauses.
• NLP pipeline that handles contract-length inputs without falling over on context limits.
• Domain coverage across finance, healthcare, and legal with separate knowledge bases.
• Audit trail tying every draft and every flag back to its source and reviewer action.

Screens and User Flows

A typical session starts with either a new draft or an uploaded document. The agent does the structural work, the reviewer edits and approves, and the output is logged before export.

Future Growth Opportunities

• Add more regulatory domains on top of the existing knowledge base pattern, for example data privacy or energy compliance.
• Plug the system into document management and e-signature tools so approved drafts move on without manual export.
• Layer in evaluation tooling that scores model output against reviewer edits over time, so accuracy can be tracked rather than assumed.
• Offer a redlining mode for vendor contracts that suggests edits instead of only flagging clauses.
• Expose a read-only audit view for external auditors, using the existing log structure.