One agent can’t run your exposure program. A team of agents can.
Inside the Decision Center, and why we built specialized agents instead of one generalist.
Key takeaways
- One agent's reasoning over every exposure question is hard to test, explain and trust. Specialized agents each own one question.
- The different agents (for example: Reachability, Exploitability, Context, Ownership, Prioritization, Remediation and Mitigation) feed one decision card in the Onit Decision Center.
- A person reviews each decision once. Approved, it becomes a standing rule that covers every matching exposure, now and later.
- When evidence is missing, an agent returns "unknown" with the reason, never a confident guess.
- You approve the decision once. Every later action runs under that rule, logged and reversible.
Say a payments company has 212 servers running a vulnerable version of Apache Tomcat. In most programs that becomes 212 tickets and a week of arguing about which ones matter. In the Onit Decision Center it becomes one decision card, filled in by dozens of agents that each answer one question.
When we designed the Onit Decision Center, we made an early product call: no single all-knowing agent. Instead, we modeled the agents on how the best security teams already work. No one expects the threat intel analyst to trace firewall rules, or the network engineer to judge whether an exploit is weaponized. Each role has deep expertise, a clear remit and work others can review. Our agents follow the same design: each one owns a single area of expertise, works from defined inputs and produces an output a person can check. Here's how they fit together, and why that structure matters more than any single model.
The pain behind the design
The structure came from watching how teams argued about priority, not from an architecture diagram.
In almost every prioritization review we sat in on, the debate was rarely about the score. It came down to one missing fact. "Is this actually exposed?" "Is that package even loaded?" "Who owns this cluster now?" The score was only as good as the weakest answer underneath it, and nobody could see which answer that was.
That gave us the product requirement: every question that decides priority needs its own owner, its own evidence and its own accuracy bar. In an agentic product, that owner is an agent.
Why does specialization beat one big agent?
Because each agent owns one question, its answer can be tested, explained and traced to evidence. A security team can see which answer is weak and adjust that agent alone, instead of arguing over one opaque score.
Exposure decisions depend on very different kinds of evidence. Is there a working exploit in the wild? Can an attacker reach this host at all? Does the vulnerable code actually run? Who owns the box? One agent reasoning over all of it at once is hard to test, hard to explain and hard to trust.
Splitting the work gives us three things a CISO cares about:
- Accountability: Every conclusion traces back to the agent that produced it and the evidence it used.
- Accuracy: Each agent is tuned and measured on one question, so we know when it's right.
- Control: A security team can adjust one agent's behavior without touching the others.
What do the agents do?
Each agent answers one question: can an attacker reach it, can it be exploited here, does the business care, who owns it, where does it rank, how is it fixed, and what lowers the risk before the fix lands.
Reachability Agent: Answers "can an attacker get to it?" It reads the network path an attacker would take, from the internet edge inward, and marks each exposure Reachable, Not Reachable or Unknown.
Exploitability Agent: Answers "can this actually be exploited here?" It goes past the CVE description to check conditions on the host itself: is the vulnerable component present, loaded, configured in the exploitable way? A finding that fails that check is still recorded, with the reason, and moves down the list.
Context Agent: Answers "does the business care?" It pulls business context from wherever the organization keeps it, from asset inventories and cloud tags to service catalogs and the rules a team defines, so the decision reflects what the asset actually supports: revenue, regulated data, production versus test.
Ownership Agent: Answers "who acts?" It resolves the real owner across the organization's knowledge sources, including inventories, ticketing history, directories, code repositories and team communications, so the decision lands with the team that can execute it instead of bouncing between queues.
Prioritization Agent: Puts it all in order. It ranks in a fixed order instead of blending everything into one opaque score: active exploitation in the wild, then whatโs true in your environment, then what the asset means to the business. A known-exploited vulnerability on a critical, reachable asset always outranks a theoretical one, no matter how the other numbers look. Deterministic ordering means two analysts looking at the same data get the same answer, every time.
Remediation Agent: Answers โhow exactly do we fix it?โ It summarizes the exposure and builds a full, step-by-step remediation plan grounded in the assetโs context. That covers the right patch or version for that OS and package, the deployment path the owning team already uses, the restart and validation steps, and a rollback.
Mitigation Agent: Answers โwhat can we do before the fix lands?โ It finds mitigation opportunities, from disabling a vulnerable feature to tightening a firewall rule or applying a compensating control. It tags each one by time to apply, complexity and operational impact, so teams can cut risk today while the patch waits for its change window.
From evidence to one decision
The different answers become one decision. A person reviews it once, with the evidence attached, and approving it creates a standing rule for every matching exposure, now and later. The platform then runs the resolution and confirms the fix.
The agents don't each open a ticket. Their outputs converge in the Decision Center, where related exposures are grouped into a single decision with its evidence attached: why it ranks where it does, what was checked, who owns it and the recommended remediation or mitigation.
A person reviews that decision once. Approve it, and it becomes a standing rule the platform keeps executing as matching exposures appear or return. Most agents help you work the queue faster. Ours shrink it. Once a decision is approved, the platform runs the resolution end to end in the background: routing the work, following up with owners, confirming the fix and reapplying the rule whenever the exposure returns. Your team moves on to the next call.
This is Decision-Based Exposure Management at work. The unit of work becomes the decision, not the ticket. One decision resolves thousands of exposures, present and future, and persists as an operating rule, so the same exposure is never solved twice. Ownership comes from live context in the CMDB, identity, ticketing and communications, and each decision makes the next one faster. The knowledge stays after the analyst leaves.
Here's what that looks like on an example decision card. Take the 212 servers running a vulnerable Tomcat version from the start of this post. The Decision Center shows one decision, with each agent's answer on it:
| Agent | Question | Answer on this decision |
| Reachability | Can an attacker get to it? | 38 of 212 hosts are reachable through the public load balancer; the path is shown hop by hop |
| Exploitability | Can it be exploited here? | On 29 of those 38, the vulnerable connector is enabled and no mitigation is present |
| Context | Does the business care? | All 212 sit in the Payments collection, tagged in scope for PCI |
| Ownership | Who acts? | Payments Platform team, from the CMDB and the last 90 days of change tickets |
| Prioritization | Where does it rank? | Top tier for the 29, standard SLA for the rest |
| Remediation | How exactly do we fix it? | Step-by-step plan: target Tomcat version for each OS, rollout through the team's existing deployment pipeline, restart order for the payments cluster, validation and rollback |
| Mitigation | What can we do before the fix lands? | Disable the vulnerable connector on the 29 hosts: low complexity, under an hour, one service restart, no patch window needed |
| Decision | What happens? | Patch all 212, since every host runs the vulnerable version. The 29 go first, in this weekโs change window, because they are reachable and exploitable today. The other 183 follow under the standard SLA. Once approved, the same rule covers any Payments host that turns up on this version later |
The analyst doesn't open a separate tool for each question to build this picture. It's already on the card, with the evidence one click away. The review takes minutes. The decision covers all 212 hosts, and the next one that shows up on this version.
Disruptive steps stay under human control. The system proposes, a person approves, and every action is logged and reversible. In this example, the connector change on the 29 hosts runs only under the approved decision, with an audit trail and a one-step rollback.
How we make each agent production-grade
Getting an agent to work in a demo is the easy part. Getting its answers to hold up on real production data, with duplicate assets, stale CMDB records and scanners that disagree, is where most of our time goes. Four rules every agent has to pass:
- One job, one benchmark: Each agent is measured against its own set of verified real-world cases. When we change a model, a prompt or a tool, we know whether that agent got better or worse at its one question.
- Fail toward honesty: When evidence is missing or conflicting, an agent returns "unknown" with the reason, never a confident guess.
- Deterministic seams: Agents hand off through structured outputs, not free text, so one agent's mistake can't quietly turn into another's input.
- Corrections close the loop: When an analyst overrides an agent, that correction is captured and used to improve it.
What I've learned building it
The models were rarely the hard part. Four things around them were: the tools an agent can call, the data underneath, the boundaries between agents and the language used to explain an answer. None of them is a model problem.
- The tools: An agent is only as good as what it can call. Every tool we expose has a typed input, a typed output, a defined scope and a read-only default. The Reachability Agent can parse a firewall policy but can't touch an endpoint. The Exploitability Agent can run a check on a host but can't open a ticket. Designing that toolset took as much product work as any screen we've shipped.
- The data underneath: Agents reason over one normalized model of assets, exposures and owners, deduplicated across scanners and joined to everywhere the organization's knowledge actually lives: CMDBs and asset inventories, ticketing and change history, internal wikis and runbooks, Slack and Teams threads, email, cloud tags, identity directories and code repositories. Hand even a strong model raw scanner exports and it will reason confidently over duplicates.
- The boundaries: Deciding what each agent is not allowed to do. Narrow scope makes an agent testable, and testable makes it trustworthy. Every time we let one agent "just also handle" another question, quality dropped.
- The language: Explain in the userโs language, not the modelโs. Analysts donโt want a confidence score. They want โthis is internet-facing through the edge load balancer, and the vulnerable service is running.โ That sentence gets a decision made.
One agent can give you a confident answer from a scanner export. A team of agents, each with one job, one benchmark and a clear boundary, gives you a decision your CISO can inspect, approve once and trust to keep running. Humans define judgment. Agents execute.
Frequently asked questions
One agent reasoning over every kind of evidence is hard to test, hard to explain and hard to trust. Specialized agents each own one question, work from defined inputs and produce an output a person can check, so a weak answer can be found and fixed without touching the rest.
It groups related exposures into one decision with its evidence attached: why it ranks where it does, what was checked, who owns it and the recommended remediation or mitigation. A person reviews it once, and the approved decision becomes a standing rule.
It returns “unknown” with the reason, never a confident guess. The finding stays on the decision card so a person can see exactly what is still unresolved.
The system proposes and people approve. You approve the decision once. Every later action runs under that rule, logged and reversible.
No. Onit works with the scanners, CMDB, ticketing and collaboration tools already in place. It joins their data into one model and routes the work through the ticketing tools your teams already use.