Fortress AI

The Problem

Legal document review is one of the most expensive and bottlenecked workflows in any organization. Contracts, compliance filings, and audit trails run into hundreds of pages. A single legal professional can spend days manually cross-referencing clauses, obligations, and risk flags across a document corpus, work that is repetitive, error-prone, and does not scale.

Existing AI legal tools are single-pass summarizers. They read a document and return a flat summary. They cannot reason across multiple documents simultaneously, maintain context between analysis stages, or run parallel specialized agents that each focus on a distinct legal dimension, liability, compliance, IP, or jurisdiction and then synthesize their findings.

The deeper problem was infrastructure: running capable open-weight models locally for sensitive legal work required GPU clusters that most tools were not designed to target. There was no production-ready multi-agent legal audit system built specifically to take advantage of AMD MI300X server-grade hardware.

The Architecture

Fortress AI is built as a LangGraph multi-agent graph where each node is a specialized legal reasoning agent. Documents are ingested through a FastAPI backend, chunked, and embedded into a Qdrant vector database for semantic retrieval. When an audit is triggered, the orchestrator dispatches parallel agents, each targeting a specific legal dimension, that retrieve relevant chunks, run inference via vLLM serving Qwen on ROCm-accelerated MI300X hardware, and return structured findings.

Structured findings from each agent are persisted to PostgreSQL via Prisma and surfaced through the Next.js "Command Center" UI. The frontend renders per-agent verdict cards, clause-level risk flags, and a final synthesized audit report that aggregates all agent outputs into a single actionable document.

• FastAPI backend handles document ingestion, chunking, embedding, and agent dispatch.
• LangGraph defines the agent orchestration graph — parallel fan-out, structured reduce, conditional routing.
• vLLM serves Qwen over ROCm on AMD MI300X clusters for local, secure, high-throughput inference.
• Qdrant stores document embeddings and handles dense vector retrieval per agent query.
• PostgreSQL via Prisma persists audit sessions, agent findings, and user history.
• Next.js Command Center provides the interactive audit UI, verdict cards, and export.
• Docker containerizes the full stack for reproducible deployment on AMD server hardware.

Known Limitations

Fortress AI was built under a hackathon deadline. Several architectural gaps are worth being direct about.

• Embedding and retrieval is not incremental. Re-ingesting a document that was already processed re-embeds the entire file rather than diffing changed chunks. At scale, this adds unnecessary compute cost on repeated uploads of updated contracts.
• Agent context windows are not shared. Each LangGraph agent starts with its own retrieved chunks and does not have access to findings from sibling agents mid-run. Cross-agent reasoning only happens in the final synthesis step, which limits the depth of inter-dimension analysis.
• There is no streaming output from agents to the UI. The Command Center waits for all agents to complete before rendering results, so large document sets produce a long blank waiting period with no incremental feedback.
• The vLLM server is stateless between requests, there is no KV-cache reuse across audit runs on the same document set, which means repeated queries over the same corpus re-run full prefill passes.

What's Next

The known limitations map directly onto the v2 roadmap.

Incremental embedding would replace full re-ingestion on document updates. A content-hash diff layer would identify changed chunks and only re-embed those, cutting re-processing cost significantly for large contract libraries that receive frequent amendments.

Shared agent memory would let sibling agents read each other's partial findings mid-run through a shared working memory node in the LangGraph graph. This would enable cross-dimension reasoning — a liability agent flagging a clause that the compliance agent has already marked — before the synthesis step.

Server-sent events from FastAPI through to the Next.js frontend would replace the current all-or-nothing result delivery. Agents would stream individual findings as they complete, giving users real-time progress visibility on long audit runs.

Persistent KV-cache prefixes on the vLLM server for frequently audited document sets would eliminate redundant prefill passes, reducing time-to-first-token on repeated queries over the same corpus.