Per-claim and per-quote capability minting for insurance agents

An insurance agent asked to triage a quote is given a connector, and a connector is a system rather than a permission. From that moment two sets are in play: what the agent can reach, which is a property of the credential, and what the task needs, which is a property of the quote. The companion teardown to this piece — Why could the pricing agent read that? — walks the evidence that the first set is never enumerated, that part of it is set by a vendor's product rather than by the insurer, and that no approval step ever received the composed set as its input. I take that as established and design against it. The design has one idea in it: make the two sets the same object.

I will call the reference design @authority/broker throughout, purely so the modules below have a name to hang on. It is not a package you can install — I know of nothing published under that name — and the code here is a specification you would implement rather than a dependency you would add. It is written at the level a competent platform team could build from, which is also the level at which it can be shown to be wrong. I would rather it be checkable than persuasive.

The insurer, the agents, the connectors, the vendor feed, the boundary objects and every identifier in this piece and its figures are a constructed illustration, assembled from mechanisms agent platforms document in their own product literature and from duties that appear in the sector's published supervisory instruments. No client engagement, disclosed incident, named carrier, vendor or platform is described anywhere.

Five premises, and the two this sector adds

Everything below follows from five statements. They are separated from the design so that a reader who rejects one can say which, rather than arguing with the consequences.

1. A capability is a triple, not a name. A verb, a resource selector, and a constraint. "The claims-history connector" is a name; "read loss history for applicant A-4471, for the twenty-four months preceding this application, expiring at bind or decline" is a capability. The first cannot be evaluated against a task. The second is nothing but an evaluation against a task.
2. Grants are intersected against declared intent, never unioned into a toolbelt. The current configuration model composes by union — attach four connectors and hold their combined reach. The broker composes by meet: what the principal standingly may do, intersected with what this task has declared it needs. A union grows with every integration; a meet shrinks with every restriction, which is the direction you want a mistake to run in.
3. The intersection is computed at the moment of need and retired when the need ends. Insurance is unusually well served here, because the boundary objects already exist and already have lifecycles: a quote is received and then binds or declines, a claim is opened and then closes. The grant's lifetime is the boundary object's lifetime, which means expiry is a business event rather than a timer somebody has to choose.
4. The transitive closure is computed before execution, not reconstructed after an incident. A grant that says "read the claims file" may transitively reach a medical attachment, a contributory database row, or an outbound contribution. If the closure is not computed at mint time, nobody in the estate is ever holding the number the examiner will ask about.
5. The record must answer a decision-shaped question, including the negative. Not "which connector fired" but "what could and could not have entered this decision, from which sources, under which assessments." The negative is the half that matters and the half no log produces.

Insurance then adds two premises that the healthcare instantiation of this same primitive does not carry, and they are why this is a different design rather than a search-and-replace.

Six: where the output is a price or an eligibility decision, declared intent copies its factor set from the filed rating plan. A filed rating plan is already a bound on the decision, enforceable factor by factor in a rate-regulated line. What it has never been is a bound on the read. This premise makes it one: a pricing task does not declare its own selectors freely, it derives them from the filing it is pricing under, and the grant records the filing reference. The consequence is that the two artefacts stop being able to drift. An agent cannot reach a factor the plan does not name, and an examiner comparing the grant against the filing is comparing two renderings of one decision rather than a system against a document.

Seven: every external consumer data source carries its lineage on the grant, or the mint refuses. New York's Insurance Circular Letter No. 7 (2024), issued 11 July 2024, addresses artificial intelligence and external consumer data and information sources in underwriting and pricing, and its demand is per use: assess before use, be able to demonstrate the assessment, and do not discharge the obligation by pointing at the vendor. In the prevailing pattern that lineage exists only as conversation state and evaporates with it. Here it is a field on the object that already travels — source identifier, vendor, contract reference, assessment reference — checked at mint time, so that a selector naming an unassessed source does not produce a weaker record, it produces a refusal. That inverts the usual economics of governance: the assessment stops being paperwork that trails the integration and becomes the thing without which the integration does not run.

Paraphrase discipline. The expectations attributed to Circular Letter No. 7 above — assessment before use, demonstrable analysis, governance proportionate to the use, retained documentation, third-party accountability resting with the insurer, and specific reasons for adverse decisions — are characterisations of a short letter that should be read whole, not quotations. Where this piece needs the letter's exact words it deliberately does not supply them. Check the text at dfs.ny.gov before relying on any characterisation, including this one.

Why the vendor edge is the hard part

If the only problem were that four connectors compose into a set nobody reviewed, the remedy would be arithmetic. Compute the union, put it in front of a committee, narrow it. The reason that does not work in insurance is one connector in four, and it deserves its own section because it is the place where an honest design has to concede something.

The reachable set of an external-data connector is not a set of rows in a system the insurer owns. It is whatever the vendor's product returns. When the vendor enriches the feed — adds an attribute, a new public-records linkage, a refreshed score version — the reachable set of every agent holding that connector grows. No new approval is issued, no new filing is made, and the insurer's governance function typically learns on no schedule better than an annual vendor review. Part of the closure is a third party's product roadmap.

So the design refuses to expand it, and records it as open-ended instead. The tempting move is to snapshot the vendor's current element list at mint time and treat that as the bound. It is the wrong move, and it is wrong in a way that would be embarrassing in an examination: a snapshot of a set somebody else can grow is not a bound, and recording it as one asserts a property the insurer cannot hold. The closure gate therefore reports vendor-controlled connectors as open-ended rather than expanding them, and the grant carries that flag through to the record. The honest artefact says: this decision's reach included a source whose contents are set by a party outside our control, here is the contract and the assessment behind it, and here is the date of the assessment. That is a worse-sounding answer than a list. It is a much better answer than a list that was wrong.

There is a second edge with the same shape and a different direction. A contributory loss-history database is contributory: what an insurer reads from it, it also feeds. A grant that looks like read a claims file quietly includes populate an industry record about a person, under contribution rules written for human-operated claims systems. The closure gate has to model outward contribution as part of the closure, because a control that only counts reads will report a narrow grant for an operation with an irreversible external effect — and irreversible external effects are the ones that turn up in a complaint rather than in an examination.

The data model

Four objects. A selector, which is a verb plus a resource pattern plus the lineage tag if it names an external source. A declared intent, which is what a task says it needs, pinned to a filing where the output is a price. A capability grant, which is the meet of standing authority and declared intent, sealed and bound to a boundary object. And a refusal, which is recorded with exactly the same care as a grant, because the refusal log is the only inventory of unassessed sources any insurer will ever have.

/** The coarse data domains an insurance integration review already names. */
export type DataDomain =
  | "policy-admin"
  | "claims-history"
  | "contributory-loss-database"
  | "medical-records"
  | "ecdis"
  | "payments"
  | "outbound-communications";

export type Verb = "read" | "write" | "contribute" | "pay" | "communicate";

/** What a decisioning workflow is for. Typed, because the gates below depend on it. */
export type WorkflowPurpose =
  | "pricing"
  | "underwriting-eligibility"
  | "claims-adjudication"
  | "fraud-investigation"
  | "servicing";

/** The boundary object the grant is bound to. Insurance already has these, with
 *  identifiers and lifecycles: a quote binds or declines, a claim opens and closes. */
export type BoundaryObject =
  | { readonly kind: "quote"; readonly quoteId: string }
  | { readonly kind: "claim"; readonly claimId: string };

/** Required on any selector naming an external consumer data source. There is no
 *  constructor that omits the assessment reference. */
export interface LineageTag {
  readonly sourceId: string;
  readonly vendor: string;
  readonly contractRef: string;
  /** The assessment that cleared this source for decisioning use of this class. */
  readonly assessmentRef: string;
  /** The actuarial support for the factor this source feeds, where the output is a price. */
  readonly actuarialSupportRef: string | null;
}

export interface InternalSelector {
  readonly kind: "internal";
  readonly verb: Verb;
  readonly domain: Exclude<DataDomain, "ecdis">;
  /** Resource pattern in the resource server's own grammar. Compared, never parsed here. */
  readonly resource: string;
}

export interface ExternalSelector {
  readonly kind: "external";
  readonly verb: Verb;
  readonly domain: "ecdis";
  readonly resource: string;
  /** Not optional. This is the seventh premise, expressed as a type. */
  readonly lineage: LineageTag;
}

export type Selector = InternalSelector | ExternalSelector;

/** What a task declares it needs. Where the purpose produces a price, the selectors are
 *  derived from the filed plan rather than chosen — see deriveFromFiling in the broker. */
export interface DeclaredIntent {
  readonly purpose: WorkflowPurpose;
  readonly boundary: BoundaryObject;
  readonly selectors: readonly Selector[];
  /** Required for pricing intent. Null is legal only for non-pricing purposes. */
  readonly filedPlanRef: string | null;
}

/** What a principal standingly may do. The other operand of the meet, and the only place
 *  a vendor-controlled connector is declared as such. */
export interface StandingAuthority {
  readonly principal: string;
  readonly selectors: readonly Selector[];
  /** Connector ids whose reachable elements are set by a third party's product. */
  readonly vendorControlled: readonly string[];
  /** Connector ids whose reads also contribute outward into an industry record. */
  readonly contributesOutward: readonly string[];
}

export interface ClosureReport {
  readonly domains: readonly DataDomain[];
  /** True where any held connector's reach is a third party's product rather than a set.
   *  The design records this rather than expanding it: a snapshot is not a bound. */
  readonly openEnded: boolean;
  readonly outwardContribution: readonly string[];
}

export interface CapabilityGrant {
  readonly id: string;
  readonly principal: string;
  readonly boundary: BoundaryObject;
  readonly purpose: WorkflowPurpose;
  readonly selectors: readonly Selector[];
  readonly filedPlanRef: string | null;
  readonly closure: ClosureReport;
  readonly mintedAtEpochMillis: number;
  /** Retired at bind, decline or claim closure — a business event, not a timer. */
  readonly retiredAtEpochMillis: number | null;
  readonly seal: string;
}

export interface Refusal {
  readonly id: string;
  readonly principal: string;
  readonly boundary: BoundaryObject;
  readonly reason:
    | "unassessed-external-source"
    | "selector-outside-standing-authority"
    | "pricing-intent-without-filed-plan"
    | "selector-outside-filed-plan";
  readonly detail: string;
  readonly refusedAtEpochMillis: number;
}

export interface Env {
  readonly mac: (key: Uint8Array, message: Uint8Array) => Uint8Array;
  readonly newId: () => string;
  readonly nowEpochMillis: () => number;
}

The control path

Seven layers, and the discipline is in which of them are allowed to decide anything.

One — the boundary object opens. A quote is received or a claim is opened. The agent holds nothing at this point, which is the property that distinguishes this design from every configuration-based one: there is no standing toolbelt for a task to inherit, so the absence of a mint is an absence of capability rather than a fallback to the union.

Two — intent is declared, and for a price it is pinned. Purpose, boundary identifier, verbs, selectors. Where the purpose produces a price or an eligibility outcome, the selectors are copied from the filed plan rather than chosen, and the filing reference is carried on the grant. This is the layer where a carrier discovers whether its filings are machine-readable, which is often the most expensive finding in the whole programme and is much better found in week two than in month nine.

Three — the lineage check. Every external selector must carry vendor, contract and assessment references, and where it feeds a rating factor, the actuarial support reference too. A missing reference refuses the mint. This is the only layer whose primary output is intended to be failures: the refusal log is the dated inventory of sources nobody assessed, which is an artefact no insurer currently possesses and cannot obtain any other way.

Four — the closure gate. Walk the estate graph from the named systems. Vendor-controlled edges are recorded as open-ended rather than expanded. Contributory edges are recorded as outward contribution rather than counted as reads. The output is a closure report that travels on the grant, so that the number an examiner asks about is one somebody computed before the decision rather than after the question.

Five — the broker computes the meet. Standing authority intersected with declared intent. One case deserves explicit handling rather than silence: the referral path to a human underwriter or adjuster legitimately carries standing authority, because a person picking up a referred case cannot declare in advance what they will need to look at. That path is marked unnarrowed on the record rather than quietly narrowed, because a design that pretends to bound a human's judgement will be worked around within a week and will then be lying.

Six — the resource server recomputes. The verifier walks the chain from the root and re-derives the effective selector set rather than reading the grant's claim about itself. Without this, the invariant depends on every minting party being honest, and one of the parties in an agent system is a model inside a tool loop, which is a category of thing that can be persuaded.

Seven — the record is written and retired. Grant, intent, lineage, closure report, every exercise with the identifiers it touched, and the retirement timestamp at bind, decline or claim closure. Written when it happens, not assembled when asked. The record is the deliverable; everything above it exists to make the record true.

What the examiner sees

The examination stack in this sector is unusual, and it is worth saying precisely what is being relied on and what is not. The NAIC Model Bulletin on the Use of Artificial Intelligence Systems by Insurers was adopted 4 December 2023 and is in more than twenty jurisdictions by mid-2026; it interprets law already on the books rather than creating new obligations, and it tells insurers in advance that their programme and its documentation are examinable material. The NAIC AI Systems Evaluation Tool is the examiner-facing instrument being built to operationalise it, in a twelve-state pilot running January through September 2026, at version 4.0 as of a public discussion on 1 June 2026, with adoption expected — not scheduled — for consideration at the Fall 2026 National Meeting.

What this design relies on is the kind of instrument that is, which is publicly established: a structured, examiner-facing set of questions about AI systems, their data, their governance and their outcomes. It does not rely on any particular question, and nothing here quotes, paraphrases at question level or imitates the Tool's internal text, which is pilot-stage work product and has already moved through four versions. Anyone reproducing that text — or inventing a plausible version of it and presenting it as the instrument — is doing the thing this practice exists to argue against.

The fourth row is the whole argument. Three of the four question shapes in the figure can be answered from logs, badly and slowly, by an engineer who knows which joins to write. Which sources may enter this class of decision, how each external source was assessed, and what this decision actually used are all recoverable at some cost from connector grants, vendor files and tool-call logs. The fourth — what could not have entered this decision — is not recoverable at any cost, because a log records what happened and the question asks about what was impossible. It can only be produced by construction, from a set somebody minted before the decision ran. That is why an unfair-discrimination analysis and an adverse-decision reason are the sharp end of this argument rather than the soft end: both are claims about the input set, and one of them is a claim about the complement.

There is a state-variance consequence worth stating once. Adoption of the bulletin is uneven, and a national carrier is not examined by the average of its jurisdictions — it is examined by whichever one is looking. So the record is built to the union of what any state in the footprint can ask and projected down per state, which is cheap because subsetting a record you hold is arithmetic, while widening a record you did not build is a rebuild. New York's circular letter runs on its own track and is in force now rather than expected in the autumn, which means a carrier that built to the twenty adopting jurisdictions and skipped it has built to the wrong union.

Boundary objects behave badly, and the design has to survive that

The premise that grants expire with the boundary object is the design's cleanest idea and the one most likely to meet reality unpleasantly, because quotes and claims do not have the tidy lifecycles a diagram gives them.

A quote does not simply bind or decline. It is re-rated when the applicant changes a declared fact; it lapses and is revived; it is bound with a subjectivity that resolves weeks later. A claim does not simply close. It reopens on a supplemental estimate, it splits into coverage parts that close on different dates, it generates a subrogation action that outlives the indemnity payment by years, and after a catastrophe an entire cohort of closed claims can reopen at once because of a construction-cost adjustment nobody anticipated.

The rule that survives all of that is: reopening mints, it never revives. A retired grant stays retired. A reopened claim produces a new mint, with a new intent, a fresh lineage check against whatever the sources' assessments say now, and a new closure report — which is exactly right, because a source assessed in March may have been superseded by August and a revived grant would carry the March assessment forward silently. The cost is issuance volume and a longer chain of grants per claim, and the benefit is that the record's answer to "what was permitted at the time" is correct at every point in a lifecycle that can span years. Anyone tempted to add a revive function should be asked which assessment date it carries.

India is drafting, the Gulf has not written it, and banking is context

IRDAI constituted a seven-member working group on artificial intelligence on 18 June 2026, with a three-month window to report — a window that closes as the NAIC's examiner pilot ends. Indian insurers are deploying the same agent architectures on the same platforms as everybody else, which means the composition mechanism the teardown describes is accumulating in Indian estates during precisely the period in which India's instrument is being drafted. The play is the same one this practice argues in banking against an unfinalised model-risk framework: what the industry has demonstrably built by the time the group reports is the installed base the recommendations get written against. An insurer that can already answer the decision-shaped question will find the eventual instrument describing its practice. One that cannot will find the instrument describing its gap.

On the Gulf, the honest sentence is short: I can verify no insurance-specific AI instrument in any GCC jurisdiction as of this writing, and this piece therefore cites none. For a carrier or reinsurer operating there the binding expectations on an agent estate arrive through counterparties — group policy, reinsurance security committees, bancassurance partners governed as financial institutions — which tend to transmit exactly the questions examined above. An absence of a local instrument is an absence of a local answer sheet, not an absence of the exam.

Banking is context and nothing more, but insurers inside financial groups will meet it. The revised interagency model risk management guidance of 17 April 2026 — Fed SR 26-2 / OCC Bulletin 2026-13 — places generative and agentic AI models outside its scope in footnote 3 of the shared interagency document, not of any single agency's wrapper, while returning responsibility for their governance to the institution. That is a deferral rather than an exemption, and it does not govern an insurance quote or claim. The comparison that matters runs the other way: banks are waiting on a consultation that has not opened, while insurers can watch an examination instrument being piloted. The sector that can see the exam coming has the least excuse for building estates that cannot answer it.

How this design fails

Eight failure modes, in rough order of how likely each is to be the thing that actually goes wrong.

One: a refused mint produces a widened intent, not a smaller closure. This is the most probable failure by a distance, and it is the same one the healthcare instantiation has. When a mint refuses, somebody with a service-level target reopens the intent and declares more, or an engineer adds the source to standing authority to make the refusal stop. The design does not prevent it and cannot. What it changes is that widening now leaves a diff — a change to standing authority, with an author and a date, that a reviewer can put beside the refusal it followed. The diagnostic is the ratio of refusals resolved by assessment to refusals resolved by widening, and it should be a standing report rather than an archaeology exercise after a bad examination.

Two: the filed-plan pin assumes machine-readable filings, and most carriers do not have them. Premise six is the strongest idea in this piece and the least deployable. A filed rating plan is a document, sometimes a very old one, in a form built for an actuary and a regulator rather than for a broker's permitted-resource list. Producing the mapping from plan to resources is real work, it has to be redone at every refiling, and getting it wrong in the permissive direction silently disables the gate. In lines where the filing cannot be reduced to a resource list, the honest position is that this premise does not apply and the design falls back to the meet alone — which is weaker, and should be recorded as weaker on the grant rather than quietly assumed away.

Three: the negative is only as strong as the closure computation behind it. The fourth row of the projection is the commercial argument, and it rests entirely on the estate graph the closure gate walks being complete. A domain reachable through an undocumented path — a shared retrieval sub-agent nobody registered, a cache, a data-lake copy of a system the graph does model — falsifies the complement, and it falsifies it silently and confidently, which is the worst combination available. An answer that says "this could not have entered" and is wrong is far more damaging than one that says "we cannot tell". The mitigation is unglamorous and non-negotiable: the graph is an audited artefact with an owner, and the complement should be published with the graph version it was computed against.

Four: contributory write-back cannot be revoked. Everything else in this design is about narrowing reach, and reach is reversible. Outward contribution is not. Once a claim record has been contributed to an industry database, no subsequent narrowing, retirement or revocation retrieves it, and the correction path runs through the utility's own rules rather than through the insurer's controls. The design records outward contribution in the closure report so that it is visible at mint time, which is genuinely useful and is also the limit of what a capability system can do about it. The control that matters for contribution is a human approval before the first contribution of a claim, and that is outside this design's scope.

Five: a lineage tag certifies that an assessment exists, not that it was any good. The lineage check is a presence check. It establishes that somebody recorded an assessment reference for a source before that source could enter a decision, which is a real and currently absent control. It establishes nothing about whether the assessment tested the right things, was performed by anyone competent, or has been repeated since the vendor last changed the feed. Presenting a green lineage check as evidence of a fair outcome would be exactly the overreach a market-conduct examiner is trained to find, and it would discredit the rest of the record along with it.

Six: per-task minting meets straight-through processing. A personal-lines carrier quoting at volume mints on every quote, most of which decline in seconds. That is a high-rate issuance path with a cryptographic operation and a graph walk on it, and the closure computation is the expensive half. The available mitigations are all compromises: cache the closure per intent shape rather than per boundary object, which is safe only while the graph is unchanged and therefore needs the graph version as a cache key; or compute closure asynchronously and mint optimistically, which reintroduces the window this design exists to close. I would cache on graph version, publish the hit rate, and treat a falling hit rate as a signal that the estate is changing faster than anyone is tracking.

Seven: the record is discoverable in a rate hearing and in litigation, not only in an examination. A per-decision record naming the sources that could enter a price, with assessment references and a complement, is precisely as useful to an intervenor in a rate proceeding, or to plaintiff's counsel in a discrimination or bad-faith action, as it is to an examiner. That is not a reason to avoid building it — an insurer who cannot answer the question in an examination will enjoy the deposition less — but it is a reason retention, privilege and disclosure should be decided by people who do that for a living before the first grant is minted rather than after the first subpoena.

Eight: this bounds the inputs and says nothing about the model. A perfectly minted grant establishes what could and could not have entered a decision. It establishes nothing about whether the model that consumed those inputs was sound, whether its outputs were monitored, or whether a permitted factor produces a disparate outcome. Those are model-governance questions, and the programme the Model Bulletin expects still has to answer them. Authority and scope are one layer. Anyone selling this as an answer to unfair discrimination is selling something else, and the sector will notice.

What it costs

On the request. A mint is a graph walk, a set intersection, a canonical serialisation and a MAC. Verification at the resource server is a re-derivation linear in chain depth. All pure computation, no network on the critical path once the graph is resident. That much is a property of the algorithm. A latency figure is a different matter and I do not have one: nothing here has been measured under a representative quoting workload. The measurement is specified — p50 and p99 for mint and for verify, at estate graphs of a hundred and a thousand nodes, cold and warm cache — and the prediction under test is that a warm mint stays inside the budget of a single connector round trip. It is planned, not performed, and anyone who reads a number into that sentence has read one I did not write.

On the people. The estate graph needs an owner and a change process, because the complement is only as true as the graph. The refusal log needs a triage path, or it becomes a queue that gets bulk-resolved by widening. The filed-plan mapping needs an actuarial owner and a refiling trigger. And there is a new incident class — the mint refused during a catastrophe intake surge — whose fail-open-or-fail-closed decision must be made deliberately, in advance, by somebody senior, rather than discovered at two in the morning by whoever is on call.

On the migration. A grant does nothing until something verifies it, and the things that would verify it are policy administration and claims systems under change control measured in quarters. So the order runs backwards from what people expect. Mint in shadow and enforce nothing, letting the record fill until the real composed reach of a live workload is visible — which, in every estate I have reasoned about, is the point at which somebody says a sentence beginning "I did not know it could get to". Then run the lineage check in report-only mode and triage the refusals it would have produced. Then enforce at one boundary you own. Then widen. Every step reverses except the last, and the payoff arrives at step one, because a complete composition record with no enforcement attached is already the artefact that answers the examiner's question.

If you had a week

1. The two properties, as tests. That mint never returns a grant holding a selector absent from standing authority, at any input; and that for a pricing purpose it never returns a resource the named filed plan does not permit. Two days, and the only part where being wrong is unrecoverable.
2. The estate graph, drawn by hand, for one workflow. Not the whole estate. One agent, its connectors, and every path out of them including the shared sub-agents and the caches. Do it on paper with the platform team in the room. The output is usually an argument, and the argument is the finding.
3. Shadow minting on one quote path. Declare intent, compute the closure, write the grant, enforce nothing. Inside a week you have the composed reach of a live workload and a refusal log, neither of which any dashboard in the estate produces today.
4. One cold negative. Take a single declined quote out of the shadow record, run answerForDecision over it, and hand the result to somebody in compliance who did not build the system. Ask them whether they would put the fourth field in front of an examiner. If the answer is no, you have learned the graph is incomplete, which is exactly what week one is for.

Skip, deliberately: revocation infrastructure, possession binding, a selector grammar, any user interface, the per-state projection matrix, and the actuarial mapping for lines you are not piloting. All six are real requirements of a real deployment, and all six are ways to spend a week without ever seeing the composed reach.

The sentence worth carrying out of this, and out of the teardown it answers, is the same one in both directions. In insurance the read is never just a read — what an agent could reach is evidence about what could have entered a price — and until scope is minted at the size of the task, no insurer can put a boundary around that evidence. The boundary objects already exist. The filings already exist. The assessments mostly exist. What does not exist is the moment of minting, because nothing in the current stack treats the start of a quote or a claim as a moment when permission is decided. That moment is a few hundred lines of code and one uncomfortable conversation about an estate graph, and it is the difference between answering an examiner and describing a configuration to one.