Elevator

How a regulated-licence application gets assembled.

Scroll to follow the journey from strategic intent through evidence-gathering, drafting, and external review. The diagram fills in as the story unfolds.

scroll ↓
approach

Elevator is built for humans and AI to work together — not for one to replace the other.

A regulator-licence application is dense, multi-author, multi-document work. It demands deep domain knowledge from the team building the business, and disciplined structure across hundreds of atomic claims. Few humans can hold all of that in their head; no AI can ship it alone.

The premise is simple: the integrator — the AI — is a peer, not an oracle. It organises what humans say, surfaces gaps, drafts what's ready, and asks where it can't. The team brings domain knowledge. The integrator brings structure, thoroughness, and pattern-recognition.

human

brings the truth

Domain expertise. Business context. Decisions that only humans can make. The final word on every answer.

integrator

brings the structure

Decomposition. Traceability. Cross-checks. Drafts. Audits. Asks when it doesn't know.

The integrator is not an author of truth. It asks. Humans answer. Drafts emerge. Iteration tightens.

01

Why

Every Elevator project starts with a Target — a strategic outcome the team is working toward. "Achieve a Gibraltar PayFac licence by Q3."

Targets are the only primitive that names a business goal. Everything else exists to serve them.

02

Decomposition

The Target tells you why. The regulator's submission template and guidance — ingested as Documents — tell you what shape the answer must take.

The integrator reads them, maps the template's structure to Sections, and atomises the regulator's text into Requirements: verifiable claims that must hold for the application to land. One Requirement can sit in many Sections; the same claim often turns up in different parts of the document.

03

Knowledge in

Alongside the regulator's guidance sit the team's own Documents — policies, prior submissions, the business plan as it stands, KYC procedures, whatever has been uploaded. Plus AI-generated summaries for fast retrieval.

A regulator only accepts evidence that lives in a formal document. The application is built from these and nothing else.

04

Grounding

Evidence is the bridge between source and claim. When a Requirement is supported by something in a Document, an Evidence entry is created — with a quoted fragment, a confidence tier (high / medium / low), and a status.

Two Requirements just turned green. They're closed.

05

The gap

Some Requirements have no support in any Document. Rather than guess, the integrator surfaces a Question — a specific, scoped ask that blocks drafting until answered.

The integrator never authors truth. It asks.

06

The human loop

Users respond. Their words land in a UserInput queue and get stamped onto the relevant Question — verbatim, never re-authored as the integrator's own proposal.

That answers the Question, not the Requirement. A regulator won't accept a chat response as evidence on its own — what it unlocks is drafting. The Requirement was blocked; now it's ready.

07

Composition

Once a Section's Requirements are ready — supported by Documents, or unblocked by user responses that drafting can absorb — a Draft composes them into prose.

This is where ad-hoc answers become formal application content. The Draft, once approved, is the policy or business-plan section the regulator reads. DraftFeedback captures the redlines on the way there.

08

External review & cross-cutting

When the team sends a draft to outside counsel, the comments come back as a ReviewCycle — split into individual ReviewItems for reply and amendment.

Cross-cutting concerns sit alongside: Issues thread observations across multiple primitives; References anchor external context (URLs, tooling) to whatever they bear on.

09

Composition & submission

Every Draft is approved. The compiler stitches them together — section by section, in template order. Some Documents ride along verbatim: audited accounts, articles of incorporation, signed agreements — attached to the package as-is rather than rewritten into prose. The whole build is stamped with a CompilationMeta: timestamp, content hash, changelog since the last build.

The Target's lifecycle transitions from active to completed. The application ships. The integrator stays alive — regulator follow-ups land as new user_inputs, Issues open against the submitted text, the audit trail is intact for whatever comes next.

read next · the technical tour
The Round

From here the tour goes operational: how rounds actually run, how Questions evolve over time, how Evidence is calibrated, how Drafts get composed and revised, and the design discipline that holds it all together. Written for engineers and operators. Start with The Round.