Structuring how plan reviews get decided

Plan review fails between disciplines.

Permitting isn’t slow because people are slow. It’s slow because the decisions aren’t structured.

Submissions get accepted with hidden gaps. Building, Zoning, Fire, Civil, and MEP review in silos and never see each other’s comments. Two reviewers contradict each other and nobody reconciles it. And when an approval is finally granted, there’s no defensible record of why— which is exactly what a regulated process can’t afford.

The recurring failure modes:

• Submissions routed into review while still incomplete

• Discipline reviews happening in isolation, with no shared state

• Contradictory comments that no one is accountable for resolving

• Approvals with no traceable record of the decisions behind them

One question, asked at every step.

Most permitting tools are built around documents — storing them, moving them, marking them up. PlanFlow is built around decisions. At every step it answers a single question:

That reframing is the whole product. PlanFlow isn’t a content tool, a code-compliance interpreter, a CRM, or a document store. It’s the system that turns submissions into defensible approvals, with every blocker, decision, and override traceable.

AI sharpens the judgment. It doesn’t make the call.

The intake question is narrow on purpose: “Is this submission complete enough to route into review?” — not “Does this project comply with every building code?”Completeness is checkable. Code interpretation is human judgment, and PlanFlow doesn’t pretend otherwise.

So the AI is scoped to what it can do reliably:

• Classify uploaded documents and match them to checklist items

• Detect missing required documents and conditional requirements

• Draft deficiency notices and suggest reviewer routing

• Explain, in plain language, why each item was flagged

And explicitly kept away from what it shouldn’t:

• It does not approve permits or make legal determinations

• It does not interpret complex building code

• It does not send anything without human approval

• It does not replace reviewer judgment

Agents analyze. A human decides.

A submission comes in. A small set of bounded agents each do one job, their findings are combined into a single view, and the Permit Tech makes the call. No agent acts on its own.

One agent proposes, another checks, and the system combines the result into something a person can act on in seconds: what’s required, what’s present, what’s missing, and the reason behind every flag — with the AI’s confidence shown, not hidden.

Hard gates, with overrides that leave a record.

Three gates run the process: completeness must pass before review, every required discipline must sign off, and final approval requires all of those sign-offs. By default the gates are hard. Only a Coordinator can override one, and only with a full justification.

Every override has to produce all of the following before it’s allowed:

• A structured reason code from a configured list

• A free-text rationale

• Linked evidence — documents, reviews, or comments

• A new decision record, plus an immutable audit-log entry

• An override-visible flag, so it surfaces in every relevant view

Five roles, one decision model.

Discipline (Building, Zoning, Fire, MEP, Civil) is a reviewer assignment, not a separate role. Authority to override lives in exactly one place, on purpose.

Every decision is defensible.

Underneath the workflow is an append-only, immutable audit log and a decision record for every gate, sign-off, and override. Nothing important happens without leaving a row behind it. A policy change, an override, a completeness call — each writes its own entry.

For a government process, that’s the difference between “we approved it” and “here is exactly why we approved it, who decided, and what they were looking at.” The defensible record isn’t a feature bolted on at the end. It’s the spine the whole system is built around.

Built to be real. Honest about what’s next.

The system runs on a deliberately boring, defensible stack:

• Next.js app, Postgres (Neon) for data, Drizzle migrations

• Private S3 bucket for uploaded permit documents

• AWS Bedrock running Anthropic Claude for the agents

• Swappable to Aurora when a regulated buyer requires it

PlanFlow is in active development. V1 proves the spine end to end — intake, the agent pipeline, the completeness gate, the decision panel, and the audit trail — on a seeded residential-new-construction checklist. Reviewer routing, notice delivery, and multi-jurisdiction checklists are scoped and staged, not yet wired. That sequencing is the point: prove the decision system holds before scaling the surface area around it.