A named owner for the content.
One person who can say what belongs in a library and what does not, and who can approve a library for mirroring. Not a committee, and not "IT will decide".
Every phase ends in a decision somebody is named for, and one of the available decisions is always to stop.
These are the phases, in the order they run, with the question each one has to answer before the next begins. The figures beside them come from one real build. They are what happened once, not a commitment about what will happen for you.
The first phase is the strategic assessment, which is bounded work you keep whether or not you proceed. Everything after it is scoped from what that phase found, rather than from a template written before we met you.
A source inventory: which libraries exist, who owns them, what is in them. A risk classification over that content. The workflows worth connecting first, chosen because they are frequent and document-bound rather than because they are impressive. A responsibility map, and the measures you will judge this by.
The output is a written control design: the roles, the three allow-lists each one gets, and the data-boundary statement you will be asked to sign.
The server, the identity estate and the feeding layer are deployed into a cloud account you hold the root credentials for and are billed for directly. If you already run the platform, this lands beside it and shares only the sign-in estate.
A read-only grant against one named library, the mirror worker, the parser, the embeddings and the index. Before a single document is indexed, you get a written one-time indexing cost proposal: what the corpus is, what parsing and embedding it will cost once, and what it will cost to keep current.
Unsupported formats are reported as a list, so you know what did not make it and can decide whether it matters.
Federation to your corporate sign-in, roles written into the token at mint, and the three allow-lists from phase one loaded as real policy. We then run the adversarial probe: a role that should not see a thing, trying to see it.
Roles are pre-assigned before anyone walks in. Each person adds the connector, signs in with the corporate account they already use, and asks their first real question against their own records. We teach two habits: ask in plain language, and treat a number with no citation as a bug worth reporting.
Everything so far is the generic kernel. A pack encodes your process on top of it: a readiness checklist, stage tracking with entry criteria, an ask list, a standard workbook, a roll-up. Each is scoped and billed as forward-deployed engineering, one at a time, against a workflow you can already see running.
These are not paperwork. A project that begins without them stalls in the first fortnight, and the stall always looks like a technology problem when it is an ownership problem. The full table, with what goes wrong in each case, is on the gateway overview.
One person who can say what belongs in a library and what does not, and who can approve a library for mirroring. Not a committee, and not "IT will decide".
The mirror preserves your tree exactly and classification leans partly on your folder conventions. If the tree is chaos, fixing it is the first deliverable rather than a thing we work around.
Who reaches which tools, which records, which classes of data. There is no default role by design, so anyone not named simply gets nothing when they connect.
"We usually check the figures against last year" is not a rule. "Publication is blocked unless invoice totals reconcile exactly to the control total" is. Deterministic tools need the second kind.
We deploy, operate and extend. These are the things only somebody inside your organization can do, and they are on the plan from the first week rather than discovered in the fourth.
| Phase | org.tech | Your administrators | Your people |
|---|---|---|---|
| Discovery and control design | Runs it, writes the control design and the boundary statement | Names owners, roles and the first workflows | Half an hour each, describing the work as it is |
| Deployment | Deploys every component from a pinned version | Opens the account, points a name at the endpoint | ✕Nothing |
| Connector and indexing | Quotes the one-time cost in writing, then indexes | Grants the read-only permission, approves the cost | ✕Nothing |
| Identity and policy | Implements the allow-lists, runs the probe | Registers the federation, witnesses the probe | ✕Nothing |
| Connect workshop | Runs the day, teaches the two habits | Confirms the attendee list and their roles | ✓Connect, then one real task each |
| After go-live | Managed operations, from day one | Raises access changes, owns the exceptions | ✓Use it, and report uncited numbers |
The rows marked as nothing are deliberate. If your people have to do work during deployment, the deployment is wrong.
Open formats, an open protocol, and the right to remove us. That is the ownership promise, and the second half of it is worth writing into the contract.
This is the sentence most customer-owned deployments are sold without. The recurring work is real and it begins the day your people connect, not some months later when something breaks. Managed operations is on from day one and is not an optional extra.
You run a known version, changed deliberately, not whatever was deployed last. Keeping it current, and deciding when to move, is work somebody has to own.
Runs that do not complete cleanly, formats that stopped parsing, a library somebody renamed. Somebody has to look, and it is us.
A new starter, a leaver, a role that needs narrowing. An operator task today, turned around directly rather than through a queue.
Assistant vendors change their connector surfaces. Keeping up with that is ongoing work, and it is the main reason this is a service rather than a handover.
In the one build so far, a working authenticated connector existed a little over three weeks after signature, and the whole team was connected in a single workshop day. That is one deployment. We quote from your source inventory rather than from that anecdote, and we publish no time-to-deploy figure, because none has been measured.
The engagement is scoped in the strategic assessment. The running cost has been tens of dollars a month on the client's own cloud bill, with nothing per seat, plus the one-time indexing cost quoted in writing before anything is indexed. Cloud, document platform seats, domains and assistant subscriptions are paid by you directly to each vendor. See pricing for the published ladder.
Yes, and you should. One library, one set of roles, one workflow that is frequent and document-bound. The whole design is one library at a time, so a first team is the natural unit rather than a pilot carve-out we have to unpick later.
No. They are siblings, not a ladder, and neither is an on-ramp to the other. Where both run in the same account, they share exactly one thing: the sign-in estate, so one identity decides what a person sees in both. If you are weighing them, platform or gateway is the page to read.
You keep the account, the data and the deliverables, and you lose us. Running it afterwards needs a competent cloud engineer, which is why runbooks and infrastructure-as-code are deliverables rather than internal documents. See ownership and exit, and put the export and deletion clause in the contract while you are still signing it.
Phase one is the assessment: a source inventory, a risk classification, named roles and a control design you keep whether or not you proceed.