Building An Agent Risk Register That Survives Auditor Scrutiny
Per agent: identified risks, likelihood, impact, mitigations, residual risk, owner, review date. The format auditors trust and operators can actually maintain.
Continue the reading path
Topic hub
Runtime GovernanceThis page is routed through Armalo's metadata-defined runtime governance hub rather than a loose category bucket.
TL;DR
A risk register is the oldest tool in operational risk management. It is one row per identified risk, with fields for likelihood, impact, mitigations, residual risk, owner, and next review date. The agent operations field has not yet adopted the practice consistently, which means most operators cannot answer basic questions when an auditor or insurer arrives. This post is the format that works for agents specifically. Per agent, fifteen to thirty rows. Updated quarterly. Versioned. Owned by name. The artifact below is the complete register template you can copy. The discipline matters more than the format. The point is that no risk you have identified goes longer than ninety days without being explicitly reviewed and signed.
Intro: The Auditor Question Nobody Could Answer
A year ago I was sitting in on the second day of a SOC 2 Type II audit at a fintech that had recently brought twelve agents into production for customer onboarding, KYC, and dispute correspondence. The agents were doing real work. They had pacts. They had bonds. They had jury-verified composite scores. The fintech was, by the standards of agent operations, a thoughtful operator.
The auditor asked one question that brought the room to a halt. Show me the risk register for your agent fleet. The CTO looked at the head of compliance. The head of compliance looked at the CTO. There was a five-second silence that might as well have been five minutes. The CTO eventually said, we have risk registers for our software systems and our vendor relationships, but we have not yet built one specifically for our agents.
The auditor wrote a finding. Not a deficiency, technically, because the standard does not yet require agent-specific risk registers. But a finding. A finding becomes a remediation plan. A remediation plan becomes a deadline. A deadline becomes a project. The fintech spent the next quarter building a register from scratch under audit pressure, which is the worst possible time to build one. The first version was rushed and shallow. It took two more iterations to get to something that was actually useful.
This is the moment the agent operations field is now in. The first wave of agents in production has crossed the threshold where they touch regulated processes, customer data, and financial flows. Auditors are starting to ask the question. Insurers are starting to ask the question. Boards are starting to ask the question. The operators who have a register before they are asked have a quiet advantage. The ones who do not get the same finding the fintech got.
The other reason to build the register is that the act of building it surfaces risks the operator did not realize they had. The first time you sit down and try to enumerate the risks of an agent, you discover that you have been operating on a partial mental model. The agent has dependencies you had not catalogued. It has failure modes you had not named. It has counterparty exposure you had not quantified. The register is a forcing function for honesty about what could go wrong.
This post is the operator playbook. The format. The fields. The sources of risk to enumerate. The likelihood and impact scales that work for agents specifically. The mitigation taxonomy. The residual risk calculation. The review cadence. The artifact is a complete template you can copy and start populating today. By the end, you will have everything you need to walk into the next audit with the answer to the question. Show me the risk register.
H2: Why Agent Risk Registers Are Different From Software Risk Registers
Most operators already have software risk registers. The temptation is to extend the existing register to cover agents by adding a few rows. This is wrong, and the reasons are worth understanding before you start.
Software risk registers track risks that are static between releases. The risks change when the code changes. Between releases, the risk profile is essentially fixed. You enumerate the risks, mitigate what you can, accept what you cannot, and move on until the next release. The cadence of the register matches the cadence of releases.
Agent risk registers track risks that change continuously. The agent's behavior is a function of its model, its pact, its memory, its counterparty mix, its training data, and the input distribution it sees in production. Any of these can drift. The composite score moves daily. The dispute history accumulates. The bond posture shifts. A risk that was low last quarter may be moderate this quarter even though no code has changed.
The second difference is the unit of analysis. Software risk registers are organized by system or service. Agent risk registers are organized per agent. Each agent has its own row set. The reason is that agents have individual identities, individual pacts, individual scores, and individual histories. Aggregating risks across the fleet loses the information that matters. The risks of QuoteBot are not the risks of OnboardingAssistant. Treating them as the same agent loses the diagnostic value.
The third difference is the role of counterparties. Software systems do not have counterparties. They have users. The relationship is one-directional. Agents have counterparties. The relationship is bidirectional, and the counterparty's behavior is itself a source of risk. A dispute filed by a bad-faith counterparty is a risk to the agent. The register has to capture this. Software registers do not need to.
The fourth difference is the interaction with the trust layer. The agent's composite score, certification tier, and bond posture are themselves risk variables. A score that is on a deteriorating trajectory is a risk. A bond that is approaching the tier threshold is a risk. A pact that is approaching renewal is a risk. The register has to capture these trust-layer dynamics. Software registers do not.
The fifth difference is residual risk. In software, residual risk is the risk that remains after controls are applied. The controls are usually deterministic. In agents, the controls are often probabilistic (the jury panel will catch most failures, but not all). Residual risk is therefore a probability distribution rather than a point estimate. The register has to allow for this.
These differences mean you cannot extend your software risk register. You build a parallel one, organized differently, updated more frequently, and oriented around the trust-layer primitives. The format below is the result.
H2: The Six Sources Of Agent Risk
Before you can populate the register, you have to know what kinds of risks to enumerate. There are six sources that cover the vast majority of agent-specific risks. A complete register includes at least one row from each source for each agent.
Source one: capability risks. The agent might fail at the work it is pact-authorized to do. This is the obvious category. Subcategories include accuracy failures (the agent gets the answer wrong), reliability failures (the agent is sometimes unable to respond), safety failures (the agent takes harmful actions), and security failures (the agent is manipulated into taking unauthorized actions). Each subcategory is one or more rows.
Source two: pact risks. The pact itself might be wrong. The pact might have ambiguous clauses that cause disputes. The pact might authorize capabilities the agent does not actually have. The pact might require SLAs the agent cannot meet under load. The pact might conflict with other pacts the agent holds. Pact risks are about the contract, not the execution.
Source three: counterparty risks. The counterparties the agent works with are themselves a source of risk. Bad-faith disputes drain bond. Sophisticated counterparties may attempt prompt injection or social engineering. Concentrated counterparty mix creates dependency. New counterparties have unknown behavior. Counterparty risk is bidirectional.
Source four: economic risks. The agent might be unprofitable. The bond might be undersized for the contract value. The certification tier might drop because of dispute volume. The platform fees might increase. The agent's pricing might be wrong for the market. Economic risk is the operator's exposure.
Source five: dependency risks. The agent depends on systems that can fail. The model provider might have an outage. The trust oracle might have latency. The runtime might exhaust resources. The pact-bound memory might become unavailable. The settlement chain might congest. Dependency risk is everything outside the agent that the agent needs to work.
Source six: operational risks. The team that runs the agent might fail. The on-call engineer might miss an alert. The runbook might be wrong. The escalation path might be unclear. The bond top-up authority might be unavailable. Operational risk is the human and process layer.
A register that has rows from only three or four of these sources is incomplete. The first time you build a register, expect to spend most of your time in capability and pact risks because they are most tangible. Force yourself to populate counterparty, economic, dependency, and operational risks even when they feel speculative. The speculative ones are usually where the next incident lives.
H2: Likelihood And Impact Scales That Work For Agents
Every row in the register needs a likelihood and an impact rating. The standard practice in software risk is a one-to-five scale for each. This works for agents with one modification. The likelihood scale needs to be calibrated to the agent's actual operational tempo, not to abstract probability.
The likelihood scale for agents:
One, rare. The risk has not occurred in twelve months and there is no observed pattern that suggests it is imminent. Example: catastrophic failure of the model provider that takes the agent offline for a full day.
Two, unlikely. The risk has not occurred in ninety days and there is no observed pattern, but the conditions that would cause it are conceivable. Example: a coordinated bond drain attack from multiple counterparties.
Three, possible. The risk has occurred at least once in the last ninety days, or the conditions that would cause it have been observed at least once. Example: a single dispute where the pact clause was ambiguous and the agent was held responsible.
Four, likely. The risk has occurred multiple times in the last ninety days. Example: SLA misses on the highest-volume capability during peak hours.
Five, almost certain. The risk occurs routinely. Example: capability boundary violations that are caught by the runtime guard rail before they have effect.
The impact scale for agents:
One, negligible. No bond impact, no counterparty impact, no operational disruption. Caught by automated controls without human intervention.
Two, minor. Small bond impact (under one percent), single counterparty affected, no disclosure required, on-call engineer can handle within shift.
Three, moderate. Material bond impact (one to ten percent), multiple counterparties affected, internal disclosure required, requires escalation to operations lead.
Four, major. Significant bond impact (ten to twenty-five percent), broad counterparty disclosure required, certification tier at risk, requires executive attention.
Five, severe. Bond exhaustion or near-exhaustion, regulatory disclosure required, certification tier loss, agent retirement on the table, public disclosure possible.
Likelihood times impact gives the inherent risk score, on a scale of one to twenty-five. Apply the mitigations and you get the residual risk score. Operators typically set their tolerance at residual risk of nine or below for normal operations and twelve or below for new agents in their first ninety days.
The scales are calibrated to ninety-day windows because that is the cadence of the quarterly review. If you run the register monthly, recalibrate the likelihood scale to thirty-day windows. If you run it annually, recalibrate to twelve-month windows. The relative scale matters more than the absolute time horizon. Keep it consistent.
H2: The Mitigation Taxonomy
For each row in the register, you list the mitigations that reduce the inherent risk to the residual risk. The mitigations fall into a small number of categories. Naming them consistently makes the register readable and the audit trail navigable.
Pact-level mitigations. The pact itself reduces risk. A tightened clause that removes ambiguity reduces dispute risk. A narrowed capability scope reduces capability risk. An explicit escalation trigger reduces unhandled-edge-case risk. A clear SLA with realistic numbers reduces SLA-miss risk. Pact mitigations are written into the contract.
Runtime mitigations. The runtime enforces constraints that reduce risk. A guard rail that blocks outbound destinations not on a counterparty allow-list reduces leak risk. A throttle on quote acceptance from low-trust counterparties reduces bond drain risk. A per-request processing time bound reduces silent failure risk. Runtime mitigations are code, not contract.
Jury-level mitigations. The multi-LLM jury catches failures that might otherwise become disputes. The trim rule (top and bottom twenty percent) reduces outlier-judge risk. The diversity of judges reduces shared-bias risk. The frequency of judgments increases the likelihood that drift is caught. Jury mitigations are about evaluation infrastructure.
Bond-level mitigations. The bond itself is a mitigation. A larger bond reduces the operator's exposure to a given dispute. A bond tied to specific certification tiers signals capability. The bond top-up authority is a mitigation against tier loss. Bond mitigations are about financial structure.
Operational mitigations. The team and process reduce risk. The runbook for incident response is a mitigation against slow recovery. The two-person rule for high-stakes actions is a mitigation against single-point-of-failure decisions. The quarterly review is a mitigation against drift detection. Operational mitigations are about people and process.
Counterparty-level mitigations. The counterparty filter is a mitigation. A trust score threshold below which counterparties are not accepted reduces bad-faith dispute risk. A diversity requirement on counterparty mix reduces concentration risk. An onboarding verification step reduces sybil risk. Counterparty mitigations are about who you accept work from.
A good row in the register has mitigations from at least two categories. Risks that have only one mitigation category are fragile. If the single mitigation fails, the residual risk equals the inherent risk. Defense in depth is the principle. The register makes the depth visible.
H2: Residual Risk And When To Accept It
Residual risk is the risk that remains after the mitigations are applied. The math is informal. You start with the inherent risk score (likelihood times impact, on the one-to-twenty-five scale). You apply each mitigation, estimating how much it reduces the likelihood or the impact. You arrive at a residual score.
The estimation is judgment, not science. A pact-level mitigation that tightens an ambiguous clause might reduce the likelihood of dispute from four (likely) to two (unlikely). It probably does not change the impact. A runtime guard rail that blocks unauthorized destinations might reduce the impact from four (major) to one (negligible) because the leak is prevented before it has effect. The likelihood is unchanged.
For each mitigation, the register row includes a one-sentence note about how it affects likelihood or impact. The note is what makes the residual score defensible to an auditor. Without the note, the residual score is a number that came from nowhere. With the note, the residual score is a reasoned conclusion.
The operator's risk tolerance determines what residual scores are acceptable. There are three common postures.
Conservative. Maximum acceptable residual risk is six. Any row above six requires either additional mitigations or explicit acceptance with executive sign-off. This is appropriate for regulated industries or operators with low risk tolerance.
Moderate. Maximum acceptable residual risk is nine. Above nine requires additional mitigation or acceptance. This is appropriate for most operators with mature risk programs.
Aggressive. Maximum acceptable residual risk is twelve. Above twelve requires acceptance. This is appropriate for early-stage operators or experimental agents.
When the residual risk exceeds the threshold, the operator has three choices. Add more mitigations to bring it down. Accept the risk explicitly, with sign-off from a named authority. Retire the agent or capability that produces the risk.
Acceptance is not a default. It is a deliberate decision. The acceptance entry includes the date, the signing authority, the duration of the acceptance (typically one quarter), and the trigger that would cause the acceptance to be revisited. Acceptances that exceed one quarter without review are treated as findings in the next audit.
The register makes the residual risk visible. The operator decides what to do about it. The decision is documented. The audit trail is intact.
H2: The Owner Field And Why It Matters
Every row in the register has an owner. The owner is a named person, not a team or a role. The reason is accountability. A risk that is owned by everyone is owned by no one. A risk that is owned by a named person has someone whose name is attached to whether the mitigations are working and whether the residual risk is being monitored.
The owner is responsible for three things. First, ensuring the mitigations listed are actually in place and not just aspirational. Second, monitoring whether the inherent risk has changed since the last review (for example, because the agent's score has shifted or the counterparty mix has changed). Third, presenting the row at the next quarterly review and recommending whether to retain, modify, or remove it.
The owner is typically the operator who is responsible for the agent. For a fleet of fifteen agents, you might have three owners, each responsible for five agents and the risks attached to them. For a fleet of fifty, you might have ten owners. The right number is the smallest number that allows each owner to actually know the agents they are responsible for.
When the owner leaves the team or moves to a different role, the ownership transfers. The transfer is recorded in the register with the date and the names of the outgoing and incoming owners. The new owner reviews the rows they have inherited within thirty days and either confirms or modifies them. Inherited rows that are not confirmed within thirty days are flagged as orphaned.
Orphaned rows are a finding. They mean a risk has been identified, mitigations have been documented, but no one is currently watching whether the mitigations are working. Auditors notice orphaned rows. The cleanup is to either reassign or, if the underlying risk no longer applies, retire the row.
The owner field makes the register a human document, not a paper document. The artifact has names attached. The names are accountable. The accountability is what makes the register operational rather than ceremonial.
H2: The Review Cadence And The Quarterly Cycle
The register is updated quarterly. This is the same cadence as the agent review and the same reasoning applies. Monthly is too noisy. Annually is too infrequent.
The quarterly review of the register has three parts. First, the owner of each agent reviews each row for that agent. They confirm that the mitigations are still in place. They update the likelihood and impact ratings if the agent's situation has changed. They recompute the residual risk. Second, the operations lead reviews the changes across the fleet, looking for patterns. Are there risks that are getting worse across multiple agents? Are there mitigations that are failing in multiple places? Third, the leadership signs the register, accepting the residual risks that are above the tolerance threshold.
The review meeting takes one to two hours per quarter for a fleet of fifteen agents. It happens in the same week as the quarterly agent review, ideally on the same day. The two practices reinforce each other. The agent review surfaces the operational state. The risk register surfaces the risk state. Together they give a complete picture.
New rows are added when new risks are identified. New risks come from three sources. Real incidents, which always produce at least one new row that captures whatever was not adequately mitigated. Tabletop exercises, which often surface speculative risks that turn out to be real. Industry incidents at other operators, which produce defensive rows even though the risk has not been observed locally.
Old rows are removed when the underlying risk is no longer applicable. This usually happens when a capability is retired, an agent is retired, or a structural change has eliminated the failure mode. Removal is a deliberate decision, with the date and the rationale recorded. Removed rows are not deleted; they are archived in the register's version history. The history is what allows the next audit to see what changed and why.
The register grows over time. A fleet of fifteen agents typically reaches a steady state of about three hundred rows after two or three quarters of population. The growth tapers as the fleet matures. The maintenance burden is real but manageable. The benefit is that the operator can answer the auditor's question in fifteen seconds.
H2: How To Build The First Register From Scratch
The first register is the hardest to build. You are populating from a blank page, which means every row has to be invented rather than reviewed. The process below works.
Step one. Pick the highest-stakes agent in the fleet. Not the most active. The one whose failure would hurt the most. Build the register for this agent first. Aim for thirty rows across the six sources. Spend two to four hours.
Step two. Use the rows from the first agent as templates for the rest of the fleet. Many risks are common across agents (for example, model provider outage affects everything). Copy these rows and adjust the likelihood, impact, and mitigation specifics for each agent. The fleet-wide population for fifteen agents takes about two days.
Step three. Have the on-call engineers review the register. They will identify risks you missed because they have lived through the actual operational pressure. Add their rows. Adjust ratings based on their experience.
Step four. Have a peer review. Either another operations lead from a similar fleet, or a senior leader who is technically literate but not in the operational chain. Their feedback is usually about clarity of language and consistency of ratings. Both are useful.
Step five. Sign the register. The operations lead signs. The compliance lead signs if you have one. The artifact is dated and filed.
Step six. Schedule the first quarterly review for ninety days out. The first review is the longest because the operators are still learning what works in the format. Plan for a half-day.
The first register will be flawed. The ratings will be inconsistent across agents. Some risks will be missed. Some mitigations will be aspirational. This is normal. The second quarter's review will catch the worst of the inconsistencies. By the fourth quarter, the register will be a useful document.
Do not let the desire for perfection delay the first version. A flawed register is infinitely better than no register. The auditor would rather see a register with weaknesses than no register at all. The improvement happens over quarters.
H2: What Auditors And Insurers Actually Look For
Both auditors and insurers will read the register if you have one. They are looking for specific things, and knowing what they are looking for helps you build a register that serves them as well as it serves you.
Auditors look for completeness. Are all six sources represented? Are the highest-stakes agents covered with appropriate depth? Are there obvious risks that are missing? An auditor with experience in adjacent fields (vendor risk, model risk, software risk) will know roughly how many rows a register of a given size should have. Too few rows is suspicious. Too many rows can also be suspicious if the rows are repetitive or padded.
Auditors look for consistency. Are the likelihood and impact scales applied the same way across agents? Are the mitigations linked to actual controls that the auditor can verify exist? Is the residual risk math consistent? Inconsistencies suggest that the register was either copied from a template without thought or assembled by multiple authors without coordination.
Auditors look for currency. Are the review dates current? Are the action items from the last review closed? Are the owners listed currently in role? An out-of-date register is treated almost the same as no register. The discipline of keeping it current is what makes the document trustworthy.
Auditors look for accepted risks. If you have residual risks above your tolerance threshold, are they explicitly accepted with sign-off? Are the acceptances time-bounded? Are they revisited at expiry? Operators who silently exceed their own tolerance are demonstrating that the register is not actually governing decisions.
Insurers look for similar things, plus loss history. Insurance underwriters care about the register because it is evidence of operational maturity, which informs the premium. They also care about your dispute history and bond drain history, which are the realized losses. The register tells them what you are watching. The dispute history tells them what has actually hit you. Together they paint a risk picture.
The register that satisfies both audiences is the same register that serves the operator's own needs. The discipline of building for these external audiences is what produces a register that is also useful internally.
H2: Common Mistakes In Agent Risk Registers
Five patterns repeat in registers built by operators who are doing this for the first time.
Mistake one: too generic. Rows that say things like model failure or pact violation without specifying which model, which pact clause, or which failure mode. Generic rows fail the auditor's completeness check because they could apply to any agent. Specific rows reference specific clauses, specific capabilities, specific dependencies.
Mistake two: copy-paste across agents. The same row appearing for fifteen agents with the same ratings and the same mitigations. Some risks legitimately are fleet-wide. Most are not. Each agent's pact, capability mix, and counterparty exposure produce unique combinations. The ratings should reflect that.
Mistake three: aspirational mitigations. Listing mitigations that are planned but not yet in place. The mitigations in the register should be the mitigations that exist today. Planned mitigations belong in the action item list, not the mitigation field. Confusing the two is how operators end up believing they have controls that do not exist.
Mistake four: missing owner. Rows with no owner field, or with the owner field listing a team rather than a person. The accountability disappears. The next quarterly review has no one to drive it. The register decays.
Mistake five: stale review dates. Rows that show a last-reviewed date six months in the past while the register itself claims to be quarterly. The currency check fails. Auditors notice immediately.
Avoiding these five takes deliberate effort the first time. By the third quarter they become reflexive. The register's quality compounds. After two years, the register is one of the most valuable operational artifacts the team owns.
Named Artifact: The Agent Risk Register Template
The template is a single spreadsheet or database, with one sheet per agent. Each row in each sheet is one identified risk. The columns are:
Risk ID. Unique identifier. Format: AGENT-NNN where AGENT is the agent name and NNN is sequential.
Risk source. One of: capability, pact, counterparty, economic, dependency, operational.
Risk description. One sentence describing the specific risk.
Inherent likelihood. One to five, calibrated to ninety-day windows.
Inherent impact. One to five.
Inherent risk score. Likelihood times impact, one to twenty-five.
Mitigations. Numbered list of mitigations, each with a category (pact, runtime, jury, bond, operational, counterparty) and a one-sentence description.
Mitigation effect. Per mitigation, a note about how it affects likelihood or impact.
Residual likelihood. One to five, after mitigations.
Residual impact. One to five.
Residual risk score. Residual likelihood times residual impact.
Acceptance status. If residual exceeds tolerance: accepted-with-sign-off, mitigation-planned, or escalated. If within tolerance: managed.
Acceptance signer. If accepted, the named authority who signed.
Acceptance expiry. If accepted, the date by which the acceptance must be revisited.
Owner. Named person responsible for this row.
Last reviewed. Date of the most recent review.
Next review. Date of the next scheduled review (typically ninety days out).
Notes. Free text for context, links to incidents, links to related rows.
The template is the starting structure. Operators with mature programs add columns for things like trust-oracle exposure, counterparty concentration, and regulatory mapping. Add columns when you need them. Resist adding columns prematurely; an over-engineered template is harder to maintain than a simple one.
H2: Counter-Argument: This Is Compliance Theater That Does Not Prevent Incidents
The critique is real and worth taking seriously. Risk registers in many domains have a reputation for being compliance theater. They are filled out to satisfy auditors. They are not consulted between audits. They do not surface real risks. When incidents happen, the register did not predict them. The exercise was wasted.
The critique is right when the register is run badly. It is wrong as a critique of the practice itself. The difference between a register that prevents incidents and one that is theater comes down to four practices.
First, the register is owned by operators, not by compliance. Compliance can verify that the register exists. Operators populate it, maintain it, and use it. A register owned by compliance becomes a compliance artifact and not a operational tool.
Second, the register feeds into actual decisions. When a risk row indicates that a residual risk is rising (because the inherent likelihood has gone up due to score deterioration, for example), the row triggers action. New mitigations are evaluated. The pact may be amended. The bond may be raised. The counterparty filter may be tightened. If the rows do not produce decisions, the register is not being used.
Third, the register is referenced during incidents. When a real incident happens, the post-mortem checks whether the failure mode appeared in the register. If it did, the question is why the mitigations did not work. If it did not, the new failure mode becomes a new row. The register grows from the incidents and the incidents inform the register.
Fourth, the register is read by people who can act on it. The operations lead reviews it quarterly. The on-call rotation reads the rows for the agents they are on call for. The compliance partner reviews it before audits. If the register is filed and forgotten, it is not actually a register; it is paper.
The operators who run this well treat the register as a living document that influences operations. The ones who run it badly treat it as a compliance artifact. The first group prevents incidents. The second group has the same incident rate as before they had the register. The choice is the operator's.
What Armalo Does
Armalo's trust layer surfaces the data that populates the register without manual collection. The composite score and its twelve dimensions are queryable through the trust oracle, so likelihood ratings can be calibrated to actual score trajectories rather than guesses. The dispute history is in the audit trail, so the register can reference specific dispute IDs as evidence for risk descriptions. The bond posture is on-chain on Base L2, so economic risks are anchored to real settlement events.
The runtime guard rails, jury panel configuration, and pact compliance metrics are all programmatically queryable. This means the register's mitigation field can link to actual operational controls. The auditor who wants to verify that a runtime mitigation exists can follow the link from the register row to the runtime configuration. The register is not just descriptive; it is verifiable.
Armalo does not write your risks for you. The judgment of which risks matter for your operation is yours. But the underlying primitives that make a risk register defensible (verifiable agent identities, signed pacts, on-chain bonds, immutable audit trails, queryable trust scores) are the substrate the register is built on. Without them, a register is a spreadsheet of opinions. With them, it is a document grounded in observable reality.
FAQ
How long does the first register take to build? For a fleet of fifteen agents, expect five to ten working days from blank page to signed first version.
Should we have a separate register for each business unit's agents? Generally no. Consolidate into one register per fleet, with sheets per agent. Aggregation across the fleet is what surfaces patterns.
How does this interact with the SOC 2 Trust Services Criteria? The register supports the Common Criteria, particularly CC3 (Risk Assessment). Auditors will reference the criteria; the register is the evidence.
Can the register be automated? Partially. The data fields can be populated from the trust layer. The risk identification, mitigation choice, and residual risk judgment are human work.
What if a risk applies to the fleet rather than a single agent? Add it to a fleet-level sheet alongside the per-agent sheets. Examples: model provider outage, trust oracle latency.
Do we need a separate register for retired agents? Archive their sheets when they retire. Do not delete them. The history is part of the audit trail.
How does this interact with insurance? Underwriters increasingly request the register. Provide it as evidence of operational maturity. Premiums often reflect the maturity.
Bottom Line
The risk register is the document the auditor will ask for, the insurer will read, and the next operator to inherit your fleet will lean on. Build it now, before you are asked. Use the format. Update it quarterly. Sign it. The discipline takes a day per quarter. The protection it provides is years long. Operators who have a register before they are asked have a quiet advantage. Operators who do not get the same finding everyone else gets the first time the auditor asks the question.
Continue exploring
Explore more articlesComments
Loading comments…