Reference

Fifteen questions, answered as platform engineering.

These are the questions that come back from every enterprise AI rollout. They are usually asked about a specific product — which menu, which button, which vendor — and answered the same way, which is why the answers expire within a release cycle. Every one of them is really a question about architecture: what enters the context, what the model is allowed to touch, who decides the next step, and what happens when nobody is watching.

Answered here for the people who have to build or govern the thing: platform engineers, heads of infrastructure, CTOs, and the teams now writing their own harness around a model because every serious organisation is ending up there.

Data safety and what may be sent

The first two questions are asked in the same breath and have almost nothing in common. One is a contract and network-topology question with a factual answer. The other is a data classification question your organisation has probably already answered for every other system and has not yet mapped onto this one.

Question 01

Is our data safe? Is it being used to train the model?

Asked in the room as one question. It is three, and they have different answers.

Separate training, retention, and access. Conflating them is why the answer sounds evasive even when it is not.

Training is whether your content is used to update model weights. This is a contractual property of the endpoint you are calling, not a property of the model. The same model, under the same brand name, is typically reachable through a consumer subscription, an enterprise workspace tier, a first-party API, and one or more cloud marketplace endpoints — and the training default is not the same across all four. Enterprise and API tiers generally exclude training on customer content by default; consumer tiers historically have not. Read the terms for the exact endpoint, get it in the agreement, and stop asking the question about the vendor.

Retention is how long your content sits on someone else’s disk, and it is a separate switch. Content can be excluded from training and still be retained for thirty days for abuse monitoring, cached server-side for a prompt-cache TTL, logged by an intermediate gateway, and replicated across regions. Zero-retention modes exist on most enterprise endpoints and usually have to be requested and configured. Ask for the retention window, the abuse-review exception, the subprocessor list, and the region the inference actually runs in.

Access is who can read it — including your own people. A workspace where every member can see every project’s knowledge base has just flattened the entitlement model you spent a decade building. This is usually the real exposure, and it is entirely yours to fix.

One clarification worth making publicly, because it prevents an entire category of anxiety: a model does not learn from your conversation while you are having it. Everything the model “knows” about your business inside a session is text placed into the request. In-context is not training. The reason the session appears to remember is that the transcript is being resent on every turn.

What to implement. One egress path. Route every model call through a gateway you operate, so there is exactly one endpoint with one contract and one log. Then block the consumer surfaces at the network and identity layer — not because they are unsafe in principle, but because you cannot answer any of the three questions above for a surface you do not control. Shadow usage is not a policy failure, it is a routing failure: it happens wherever the sanctioned path is slower than the unsanctioned one.

Ask the vendor Training exclusion, in the contract Retention window per endpoint Abuse-monitoring exception Human review conditions Inference region Subprocessor list Cache TTL
Question 02

What am I actually allowed to upload — client names, PII, portfolio data?

The question that has no good answer at the level it is asked.

If you cannot answer this for email, a ticketing system, or a spreadsheet on a shared drive, you will not answer it for AI. Map your existing classification tiers onto approved surfaces and publish the mapping — not a list of forbidden words.

A prohibited-terms list fails on contact. People cannot apply it, it produces false comfort, and it makes the compliant path slower than the shadow path. What works is a short decision rule: for each classification tier your firm already defines, name the surfaces it may reach and the surfaces it may not, and make the approved surface at least as convenient. One page. Reviewable by legal in an afternoon.

There are two twists that are genuinely new and worth raising with risk functions rather than hand-waving:

  • Aggregation. A model is extremely good at combining individually permitted facts into a conclusion that is not permitted. Twenty disclosed data points can constitute a restricted inference. Classification schemes designed for documents do not describe conclusions.
  • Information barriers. A chat surface has no concept of a Chinese wall. An assistant with retrieval across both sides of a barrier is a control failure even when every individual document was lawfully accessible to the service account that indexed it. This is the finding that ends pilots in regulated firms, and it is an architecture decision made months earlier.

Redaction helps and does not save you. Pattern-based detection of names, account numbers and identifiers has a false-negative rate that makes it a speed bump rather than a control; treat it as defence in depth on top of the real control, which is what data the surface can reach at all. Where you do need to send sensitive fields, prefer deterministic tokenisation with the mapping held on your side, so the response can be rehydrated locally and the vendor never holds the join.

The rule that survives contact. Do not govern what people type. Govern what the surface can reach, who it authenticates as, and where the output can land. A control that depends on every employee remembering a policy under time pressure is not a control — it is a hope with a training deck.

The vocabulary problem

Three of the fifteen questions are the same question: the words are marketing terms, they differ per vendor, they are renamed every few quarters, and none of them describe a capability boundary. Here is a layering that does. Learn this one and every product’s vocabulary becomes a translation exercise.

LayerWhat it actually isWhat it can do by itselfMarketed as
Model A stateless function from tokens to tokens. No memory, no clock, no ability to act. Produce text. Nothing else. The brand name on the dropdown
Harness The loop around the model: assemble context, call the model, parse the output, execute the tool it asked for, feed the result back, decide whether to stop. Everything interesting. This is where all engineering, all risk and all differentiation live. Rarely named at all
Context bundle Everything placed into a single request: instructions, retrieved documents, tool definitions, conversation history, injected state. Determine the answer more than the model choice does. “Knowledge”, “memory”, “files”
Tool A typed function the model may request by name, executed by the harness under an identity you control. Reach systems and cause effects. The only layer with real-world reach. Connector, integration, plugin, MCP server, function
Procedure Instructions plus optional resources, loaded into context when a condition matches — how your organisation does a task, written down. Change what the model knows how to do. Holds no privileges of its own. Skill, playbook, prompt template, recipe
Agent A harness configured with a goal, a tool set, an autonomy ceiling and a stopping condition, running the loop without a human on each step. Decide the next step. That is the whole distinction. Agent, autonomous worker, workflow
Preset A named, shareable bundle of instructions plus tools plus knowledge, published so other people can reuse it. Distribute a configuration. It is packaging, not capability. Custom GPT, assistant, bot, app
Workspace A scoping container: default context, data access, membership, retention. Bound what a set of conversations can see. A governance object. Project, space, team, workspace
Artifact An output object the harness stores and renders outside the message stream, usually versioned. Persist and present a result. A rendering concern, not a capability. Artifact, canvas, document, side panel
Question 03

What is an agent, and how is it different from a skill?

A procedure — a “skill” — changes what the model knows how to do. A tool changes what it can touch. An agent changes who decides the next step. Almost all of your risk is in the second and third, and almost all of the enablement material is about the first.

A skill is content. It is a piece of writing — often with a snippet of code or a reference file attached — that the harness loads into context when it looks relevant. Give the same skill to a model with no tools and nothing can happen: you have changed the vocabulary and the method, not the reach. Reviewing a skill is like reviewing a runbook. It belongs in version control, it wants an owner and a diff, and it does not need a security review unless it instructs the model to use a tool in a way you did not intend.

An agent is a control-flow decision. Somebody removed the human from between the steps. The model now chooses which tool to call, reads the result, and chooses again — for as many iterations as the harness permits. Its intelligence is not what makes it dangerous; the loop and the credentials are. An agent with read-only tools and a five-step ceiling is a report generator. The same agent with write access to a change-management system and no ceiling is an unsupervised operator with your credentials.

The practical consequence for a platform team: govern by layer, not by product. Procedures get content review. Tools get security review — they are new API surface with an identity attached. Agents get change-management review, because they run unattended and their blast radius is the union of their tools.

Questions 09 & 15

What is the difference between a project, a skill, an assistant, an artifact, and an agent?

Asked twice in the same session, with different nouns, which tells you the vocabulary is doing no work.

They are four different kinds of object and one of them is not like the others: a workspace bounds, a procedure instructs, a preset distributes, an artifact persists — and an agent acts.

  • Project / workspace — a boundary. Answers “what can this set of conversations see, and who is in it”. Your access-control unit. If it is doing anything else, someone is using it as a folder.
  • Skill / procedure — an instruction. Answers “how do we do this here”. Content, versioned, no privileges.
  • Custom GPT / assistant — a package. Answers “how do fifty people get the same configuration without rebuilding it”. Its risk is not what it does but how widely it is shared and whose data it carries when it is.
  • Artifact — an output. Answers “where does the result live so it is not lost in a transcript”. Treat it as a document, with the retention and classification a document gets.
  • Agent — an operator. Answers “who takes the next step”. Everything else on this list is inert.

What to implement. Publish this taxonomy internally with your own product names filled into the right-hand column, and require every new AI capability request to name the layer it lives in. It ends the recurring meeting where four people use the word “agent” to mean four different things, and it makes the review path mechanical: content review, security review, or change-management review.

Instructions, precedence, and what was actually sent

Custom instructions are the highest-leverage and least-governed configuration surface in most organisations. They are edited by anyone, versioned by no one, tested never, and they run on every single request.

Question 04

What should I put in custom instructions?

Durable, non-obvious facts about your environment that change the answer. Nothing else. If you cannot say what wrong answer the line prevents, delete the line.

Mechanically, custom instructions are a persistent prefix concatenated into every request in scope. That has three consequences people do not think about. They cost tokens on every call. They compete for the model’s attention with the actual task, so a bloated instruction block makes behaviour worse, not safer. And they cannot be conditional unless your harness makes them conditional — which is exactly why the procedure layer exists.

Belongs in instructions

  • Stack, versions, and conventions the model cannot infer
  • House terminology where an industry word means something specific here
  • Required output shape — format, length, structure, citation style
  • Who the reader is, and what they already know
  • Escalation rules: what to refuse, what to flag, what to ask about
  • Standing corrections for mistakes the model reliably makes in your domain

Does not

  • Anything retrievable — put it in a document and retrieve it
  • Anything task-specific — put it in the task
  • Anything that will be stale in a quarter
  • Aspirational tone-setting nobody can verify the effect of
  • Long examples that would be better as one short example
  • Security controls. See below — this is the important one

An instruction is not a control. “Never modify production” in an instruction block is a preference expressed in the same channel as the attacker’s input and the model’s own uncertainty. It will hold most of the time, which is worse than failing loudly. The control is that no tool in the bundle can modify production, or that the one that can requires an approval the model cannot grant itself. Write the instruction too — belt and braces — but never count it.

For anyone building a harness: instructions are source code. Put them in the repository, ship them as a build artifact rather than a text box someone edits in a browser, and run a golden task suite against a change before it goes out. A prompt edit is a production change with no type system and no compiler; the test suite is the only thing standing in for both.

Question 08

If I have instructions set globally, in a workspace, and in an assistant — which wins?

The most technically interesting question on the list.

Usually none of them. There is no precedence resolver in most systems: the layers are concatenated, and “wins” is decided by the model’s attention rather than by a rule. A conflict does not raise an error. It produces nondeterminism.

This surprises people because every other configuration system they have used — environment variables, Kubernetes manifests, CSS — has documented override semantics. Prompt layering has the shape of a config system and none of the guarantees. Position matters somewhat: text near the beginning and the end of a long context is attended to more reliably than text in the middle, and adherence degrades as the context grows. That is a tendency, not a contract, and it is not something to design a policy on top of.

So the answer people can actually use is: do not rely on precedence, design the layers to be disjoint. Give each layer a subject it alone owns.

LayerOwnsMust never contain
OrganisationPolicy, refusals, escalation, classification handling, disclosure rulesTask or formatting preferences that a team would reasonably want to override
WorkspaceDomain context, terminology, which data is in scope, who the audience isAnything contradicting policy; anything a single task should decide
Assistant / presetTask shape, method, output format, worked examplesData access decisions; anything with a compliance consequence
UserTone, verbosity, language, personal working styleAnything that changes what is true, permitted, or reachable

If two layers can both make a statement about the same subject, that is a design bug and it will be found by an employee at the worst possible moment.

For harness builders, four things to implement, in this order:

  • Render the composed context and make it inspectable. The single highest-value debugging feature you will ship. Every support ticket about “it ignored my instruction” is answered in ten seconds instead of two days.
  • Delimit the layers structurally and state the precedence in the text itself, at the top, in the highest-authority block. Models follow a stated hierarchy far better than an implied one.
  • Lint for conflicts at build time. Layers are text you own; a check that flags a workspace block contradicting a policy block is straightforward and catches the embarrassing cases before release.
  • Enforce the authority boundary outside the prompt. A lower layer must not be able to reach a tool the higher layer forbids. The instruction is the documentation of the control, not the control.
Question 11

Where do I find the custom instructions?

The useful version of this question is “how do I see what was actually sent”. If your platform cannot show a user the composed request, that is the next thing to build — before any new connector, agent, or model.

The effective instruction set on any given call is the union of more sources than anyone expects, and users can typically see only two or three of them:

  • The vendor’s own system prompt, which you cannot see and which changes without notice
  • Organisation-level instructions set by an administrator
  • Workspace-level instructions and attached knowledge
  • Assistant or preset instructions, often written by whoever shared it
  • User-level personal instructions
  • Tool and connector descriptions — routinely forgotten, and they are prompt content, written by whoever built the tool, injected on every call
  • Retrieved documents, memory records, and injected state — text you did not write, selected by a retriever you may not control

Auditing “the instructions” therefore means enumerating all seven and diffing them over time. The two most common surprises in that exercise: a tool description containing a paragraph of behavioural guidance nobody reviewed, and a memory store quietly asserting something that was true six months ago.

Memory, state, and what a conversation is worth

Three different mechanisms get called “memory”, they fail in three different ways, and the governance problem belongs almost entirely to the third.

Question 06

Does a workspace remember what we discussed in its other chats?

In most systems, no — conversations in a shared container do not see each other’s history. What is shared is documents, not discussion. But verify per system, and know which of the three mechanisms is actually in play, because they behave differently under load.

Mechanism 1

Context

Everything currently in the request. Within one session it looks like perfect recall, because the transcript is resent every turn. It is not memory; it is input.

Fails by: truncation and compaction. Long sessions silently drop or summarise the middle, and the model does not tell you which facts left the building.

Mechanism 2

Retrieval

Documents fetched by relevance and inserted at request time. This is what “the workspace knows things” almost always means: shared files, re-read on demand.

Fails by: retrieving the wrong chunk, the stale version, or the draft — confidently, with a citation.

Mechanism 3

Written state

The system extracts facts and persists them to a store that is read back on later sessions. This is the only one that is genuinely memory, and the only one that accumulates.

Fails by: persisting something unverified, or something classified, and re-asserting it for months.

Written memory is a data engineering problem wearing an AI costume, and the naive implementation loses two properties at write time. The first is provenance: a memory record needs a source, a timestamp, a confidence, and the identity of whatever wrote it, or you cannot ever audit why the system believes something. The second is classification: a fact derived from a restricted document is a restricted fact, and the extraction step is exactly where that label is usually dropped. That is the leak — not the chat window, the memory table.

What to implement. Give memory a schema, a TTL, an eviction policy, and the same access-control model as the source data. Make it readable and deletable by the user it describes. And separate user memory (preferences, context about a person or a team) from execution memory (what a task tried, what failed, what remains) — they have different lifetimes, different owners and different blast radii, and merging them into one store is a decision you will regret at the first audit.

Question 07

I have a chat that is not in a workspace. Can I move it into one?

Sometimes, product-dependent, and the wrong thing to build a habit on. The durable answer is that a conversation is a log, not a knowledge base — and anything worth keeping should be promoted out of it into a system you already govern.

Transcripts are a terrible store of record. They are unstructured, unversioned, full of abandoned branches and corrected mistakes, invisible to search, invisible to access review, and they carry the classification of the most sensitive thing anybody pasted into them. Teams that treat chats as an archive discover this at the first legal hold.

The pattern that survives: when a session produces something worth keeping, it becomes a durable artifact — a document, a procedure, a ticket, a commit, a decision record — in a system that already has retention, access control and search. The chat then becomes disposable, which is what you want it to be.

What to implement. Build promote as a first-class action: export the composed context and the result, write it to the knowledge store with provenance and classification, link back to the session. And insist on a portable session format — messages, tool calls, artifacts, model and prompt versions. You will change harness vendors more than once in the next five years, and the organisations that treated conversations as proprietary state will pay for it twice.

Choosing a model, choosing a surface

Both of these are asked as taste questions and answered best as routing policy. The right artifact is not an opinion; it is a table in configuration plus an evaluation suite that lets you change the table in a day.

Question 10

Which model should I use, and when?

Stop ranking models and start tiering tasks by cost of being wrong and tolerance for latency. Then pick the cheapest model that passes your own evaluation for that tier, and re-run the evaluation every time a frontier release lands.

Task tierCharacteristicsWhat to route it to
High volume, low consequenceClassification, extraction, routing, tagging, first-pass drafting. Wrong answers are cheap and visible.The smallest model that passes the suite. The cost difference at volume is an order of magnitude and the quality difference is often nil.
Reasoning-heavy, low volumeArchitecture, review, root cause, ambiguous requirements, anything where a plausible wrong answer costs a day.The frontier model, with extended reasoning where offered. Do not economise here; the human time dominates the token bill by two orders of magnitude.
Long-horizon agenticMany tool calls, long chains, recovery from failure, work spanning sessions.Whatever holds up over long tool-use chains — a different property from single-shot answer quality, and one you must measure separately because the public leaderboards do not.
Deterministic-adjacentAnything with a correct answer computable another way.Not a model. A query, a script, or a rule. The most common architectural mistake in this space is using inference where arithmetic would do.

The mechanism matters more than the choice. Never hardcode a model identifier in application code: route through a layer keyed on task type, with model identifiers in configuration, so a swap is a config change and a canary rather than a release. Then hold an evaluation suite of thirty to a hundred tasks drawn from your own workflows, with a graded rubric and known-good answers. That suite is what turns “should we switch models?” from a quarter-long argument into an afternoon.

Measure cost per successfully completed task, not cost per token. Price per token is the most misleading metric in this industry. A cheaper model that needs two retries, produces a subtly wrong answer once in twenty, and costs an engineer fifteen minutes of review is not cheaper. Include retries, human review time, and rework in the denominator, or you will optimise your way into a more expensive system.

Question 05

Which tool should we use for what?

Choose by where the data lives and where the output has to land — not by which model is better. The gap between models is much narrower than the gap between a surface that can reach your systems and one that cannot.

  • Chat surface — for discovery. Exploration, drafting, one-off analysis, thinking out loud. The output is read by a human and then thrown away. Cheap to adopt, impossible to audit, and the right tool for exactly this.
  • Embedded in the system of record — for work in flight. The editor, the ticket, the pull request, the document. The output lands where the work already lives, so it inherits that system’s review, history and permissions. This is where most durable value shows up, and where adoption sticks without a change programme.
  • Programmatic — for anything repeated. The moment a task runs more than about weekly, or has to be audited, or feeds another system, it should leave the chat window. A prompt in a browser tab is not a process.

The useful framing to give your organisation is a promotion path rather than a product list: chat → procedure → tool → scheduled agent. A person solves something ad hoc. It works, so it gets written down as a procedure others can load. It gets used enough that the fiddly part becomes a typed tool. Then, if it needs to happen without anyone asking, it becomes a scheduled job. Each promotion adds governance in proportion to the reach acquired, and each one is a decision someone should make deliberately.

Reaching your data, and building what is missing

The two questions that decide whether an AI programme produces anything of value — and the two most likely to produce a serious control failure if answered in a hurry.

Question 12

Can I point it at one specific folder — our document store, an intranet site, a network drive?

Technically yes, in an afternoon. The interesting part is the four problems it creates, one of which is severe and routinely shipped.

Severe

Permission parity

The integration runs as some identity. If that is a service account with broad access, every user who queries it inherits that account’s reach, and the document permissions you maintain in the source system have been erased. The index becomes a permission-laundering machine, and the first person to notice is usually an auditor.

Non-negotiable: resolve permissions per end user — delegated or on-behalf-of tokens — or partition the index and filter by the user’s entitlements at query time. Test it by asking the assistant, as a low-privilege user, for something only executives can see.

Freshness and revocation

A nightly crawl answers from last night’s world. Content staleness is annoying; permission staleness is a breach. When someone is removed from a document, the index must forget faster than it re-reads.

Permission changes need a faster propagation path than content changes. Most implementations use one pipeline for both, at content speed.

Corpus quality

A shared drive is a graveyard: six near-duplicates, four drafts, one authoritative version, and no marker distinguishing them. Retrieval is exceptionally good at finding the wrong one and citing it.

Curate a corpus; do not point at everything. Start narrow, measure answer quality against known-good questions, widen deliberately. “Index the whole drive” is how a pilot dies of plausible wrong answers.

Whether to copy at all

The default assumption is a bulk copy into a vector store. Often the better design is no index: give the agent a search tool that calls the source system’s own API with the user’s own token.

Slower per query, and you delete an entire replica of your sensitive data along with its permission-sync problem. Then “is it safe?” has the answer that survives audit: it can only see what you can see.

Question 14

We do not have the connector we need — how do we get one?

You build it, and that is now a two-week task rather than a vendor roadmap request. A connector is an auth exchange plus a handful of typed operations plus a description of when to use them. Since the tool interface converged on an open standard, this stopped being a per-vendor integration project.

The decision rule. Wait for a first-party integration when the system is major third-party SaaS and your usage is generic. Build when the system is internal, when you need scoping the vendor’s version does not offer, or when the value is in your specific operations rather than generic access — which is most of the time, because the operations that matter encode your process, not the vendor’s data model.

The design mistake to avoid. Do not expose the raw API. A tool called execute_query invites unbounded behaviour, cannot be permission-checked meaningfully, cannot be cached, and cannot be tested. A tool called get_position_summary(account_id, as_of) is typed, authorisable, cacheable, testable, and hard to misuse. Task-shaped operations with narrow types beat general-purpose access every time — for reliability as much as for security, because a narrow tool is one the model can use correctly on the first attempt.

Every tool needsBecause
A typed schemaValidation is your first line of defence and your best reliability lever. Reject malformed calls at the boundary, before anything executes.
An ownerTools rot exactly like services. An unowned tool with credentials attached is technical debt with a login.
An authorisation checkPerformed by the harness against the caller’s real identity — never against the model’s claim about who it is acting for. The model’s assertion of identity is untrusted input.
Idempotency and limitsRetries are normal in an agent loop. A write tool without an idempotency key will eventually do the same thing four times.
An audit record of the callArguments, identity, timestamp, result status — not just the final answer. When you have to reconstruct what happened, the message stream is not enough.
A reviewed descriptionTool descriptions are prompt content executed in your context. A third-party server’s description text is untrusted input: pin versions, review diffs, and do not auto-install from public registries.

What to implement. Run an internal tool registry the way you run a service catalogue — approved tools, named owners, version pins, a review gate, and a deprecation path. Approve tools, not conversations. It is the only governance object in this space that scales, because it is finite, inspectable, and it is where reach actually lives.

Unattended runs: the biggest step change on the list

This is the question that sounds smallest and changes the most. Everything else on this page assumes a human is reading the output and will notice when it is wrong. A schedule removes that assumption.

Question 13

Can an agent run on a schedule and send me a result every morning?

Yes, and it is one of the highest-value patterns available — provided you treat it as a production workload rather than a convenience feature, because that is exactly what it is the moment anyone depends on it.

Six things change the instant the human leaves the loop:

Identity

There is no interactive user, so the job needs a workload identity with its own scoped, short-lived, rotated credentials. The common shortcut — reusing an employee’s personal token — creates an unattended process acting as a named human. It is an audit finding, and it breaks the morning after they leave.

Failure semantics

Nobody is watching. You need timeouts, bounded retries, and a dead-man’s switch that alerts on the absence of a run. Silent non-delivery is the standard failure mode and it goes unnoticed for weeks, because a missing email looks like a quiet day.

Output determinism

The same prompt over different data returns a different shape. Anything downstream needs structured output with schema validation, and a run that fails validation should fail loudly rather than deliver something malformed into a mailbox.

Cost

A schedule multiplies. An agentic job that expands its own tool-call chain on a hard input can cost fifty times its median run. Every scheduled job needs a token and wall-clock ceiling with a hard cutoff, not a dashboard someone reviews monthly.

A new egress path

Scheduled jobs write somewhere — email, chat, a document, a ticket. That destination inherits none of the controls on your chat surface. Classify the output, and be deliberate that a summary of restricted data is restricted data.

Threshold

Side effects

Read-only briefings are the safe entry point. The moment the job acts, you are at meaningful autonomy and it needs blast-radius limits, dry-run, rollback, and a documented containment procedure that has been rehearsed.

Where it should run. The temptation is to use the AI vendor’s built-in scheduler, because it is one click. That puts a production job outside your platform: no shared observability, no on-call, no change control, no cost attribution, and a dependency you cannot migrate. Fine for a personal digest. Not acceptable for anything a team depends on. Scheduled agents belong on the same scheduler, with the same runtime, logging, secrets management and alerting as every other job you operate — the value of an internal harness is exactly that this becomes the default rather than a project.

Good first candidates, in order of increasing ambition: an overnight digest of monitoring and ticket state with citations back to the source; a triage summary that groups and ranks but decides nothing; release notes assembled from merged changes; a “what changed in these systems and what does it imply” brief. All read-only. All with a named human recipient who will notice when it is wrong — which is the actual control in the first six months, and worth designing for rather than pretending otherwise.

If you are building your own harness — and most of you now are

Every organisation past the pilot stage ends up writing the loop themselves: model access is commoditised, the coding harnesses have converged on the same shape, and the parts that matter are the parts that encode your estate. That is the right conclusion. It also means the fifteen questions above stop being product questions and become your architecture, so here is where each of them lands.

One task moving through context and durable state, sandboxed execution, authorization, independent verification, human approval, and a learning loop.
PLANE 01

Context & State

  • Composed context is rendered and inspectable
  • Instruction layers are versioned source, disjoint by scope
  • Memory has schema, provenance, TTL and classification
  • Sessions are portable and promotable into durable artifacts
PLANE 02

Execution

  • One egress path through a gateway you operate
  • Tools are typed, owned, task-shaped and registered
  • Model choice is configuration behind a routing layer
  • Retrieval is delegated and permission-parity tested
PLANE 03

Verification

  • A golden task suite that gates prompt and model changes
  • Schema validation on every tool call and every output
  • Postconditions, not plausibility, decide success
  • Cost measured per completed task, including rework
PLANE 04

Control

  • Authorisation on every action, against the real identity
  • Autonomy ceilings and blast-radius limits per agent
  • Audit of calls and arguments, not just answers
  • Disable that survives a restart, rehearsed
// what the fifteen questions are actually asking
useful, safe AI = context you assembled deliberately
                × tools that are typed, owned and authorised
                × verification the model cannot talk its way past
                × control that holds when nobody is watching

// the model is the one term nobody needs to argue about

Five things to build first

In this order, for the same reason every time: each one makes the next one cheaper, and each one answers several of the fifteen questions at once.

  • The gateway. One egress path, one contract, one log, model identifiers in configuration. Answers questions 1, 2 and 10 in a single component, and it is the only thing that makes the others enforceable.
  • The context inspector. Show, for any call, exactly what was sent and where each piece came from. Answers 4, 8 and 11, and it will retire more support tickets than any other feature you ship.
  • The tool registry. Typed, owned, versioned, reviewed, permission-checked against the real caller. Answers 12 and 14, and it is where reach — and therefore risk — actually lives.
  • The evaluation suite. Thirty to a hundred tasks from your own work, with a rubric. Answers 5 and 10, and converts every future model release from a debate into a test run.
  • The control plane. Registry of agents, autonomy ceilings, per-action authorisation, and a disable that survives a restart. Answers 3 and 13, and it is the one people build last and wish they had built third.

One honest caveat about all of the above. None of it is exotic, and none of it is where the difficulty is. The difficulty is that these components have to encode your estate — your entitlement model, your data contracts, your change process, your definition of done — and that content cannot be bought. The plumbing is a few weeks of work. The encoding is the engagement, and it is the part that is worth owning.

These fifteen answers are a starting position, not a deliverable.

The version that matters is the one written against your entitlement model, your data, your change process and your regulator. If you are standing up a harness, or you have one running and the questions above are still being answered differently in every team, that is a conversation worth having.