Why Autonomous Service Operations Fail on Flat Data: The CMDB Topology Prerequisite
The CMDB (configuration management database) requirements for autonomous service operations come down to one question: what does the script know about the target’s dependents? ServiceNow will present Run IT at the Speed Your Business Demands on Tuesday, 8 December 2026 at the Gartner IT Infrastructure, Operations & Cloud Strategies Conference (IOCS). The abstract opens on rising tickets, outages, and mean time to resolve (MTTR), then describes autonomous service operations built on agents and agentic workflows. It does not address data or dependencies, so the topology view in this post is Virima’s own reading.
One documented case shows how an action can reach further than its author planned. In February 2017, an Amazon Web Services (AWS) engineer followed a playbook and ran a command to remove a small number of servers from a subsystem used by the S3 billing process. One input was entered incorrectly, and the command removed a larger set that supported the index and placement subsystems. Services that rely on S3, including EC2 instance launches and AWS Lambda, were affected while both subsystems restarted. AWS then added safeguards that stop its tool from removing capacity below a subsystem’s minimum.
A person typed that command, and the incident dates from 2017. It still shows how an action can spread beyond its intended target. Self-healing automation faces risk when the record lists the target but omits its dependents. A restart, isolation, or failover needs reliable relationship information before it runs.
Flat Data Lists the Assets. Topology Says What Depends on What.
Flat data is a configuration item (CI) list with attributes such as hostname, status, and owner, where relationships are missing, untyped, or undirected. Topology holds the same records plus typed, directed relationships that end at named business services. The difference decides what an automated action can see before it fires.
| Automated action | What a script sees on flat data | What it sees with topology |
|---|---|---|
| Restart | Hostname and status | Services running above the node |
| Isolate | The record and its host | Workloads that call the target |
| Fail over | Pair membership | The tier both nodes serve |
| Retire capacity | Utilization and tags | Callers that expect fixed capacity |
An engineer on call fills that gap by hand, from memory, during an incident. Automation has no memory to draw on, so the gap stays open and the action runs anyway.
“Connected to” and “depends on” are different statements. A link says two CIs communicate. It does not say which one breaks when the other stops. Teams that need that distinction can start with this explainer on dependencies between configuration items.
Where Self-Healing Automation Reaches Past the Target
Each automated action reads a small set of facts and misses a predictable set of others. The table below lists four common actions and the topology fact each one needs.
| Action | What the script reads on flat data | What it cannot see | Topology fact it needs |
|---|---|---|---|
| Restart a node | Hostname, status, owner | Services running above it | Upstream dependents and their service |
| Isolate a VM (virtual machine) | VM record and host | Other workloads that call it | Inbound edges with direction |
| Fail over a pair | Pair membership | Shared tier both nodes serve | Shared dependents of the pair |
| Scale down or retire capacity | Utilization and tags | Callers that expect fixed capacity | Consumer edges and service tier |

Restart: which service runs above this node?
A restart script needs the dependents of the target, two hops out. A file server that looks idle may carry a nightly export that a finance service waits on. The record shows an owner and a status, and the export appears nowhere in it. A node can also carry several services, and only the team knows which one matters most.
Isolate: who calls this VM?
Isolation cuts a workload off from the network, so the script needs inbound edges with direction. A VM that only receives calls looks harmless to cut, yet the callers lose a dependency they never recorded. Some of those callers never appear in discovery at all, which the next section covers. Blast radius analysis before a change applies the same inbound-edge question to change approval.
Failover: what do both sides share?
A failover pair can look healthy while the tier behind it is saturated or down. The script needs the dependents that both nodes serve. Switching from one node to its twin helps nothing when both rely on the same degraded layer. The S3 case shows how an action can affect other subsystems and dependent services.
Explore Trusted Runtime Truth to see how discovery-sourced information connects assets, services, dependencies, and ownership.
Five Properties a Dependency Graph Needs Before Automation Acts on It
These five properties are Virima’s reading of what an automated action requires. They are not a published standard.
- Typed edges. Runs on, calls, stores data on, and fails over to each say something different. A bare “related to” cannot tell a restart script which direction matters.
- Direction. Each edge states which side breaks when the other stops.
- Depth. The graph includes dependents one and two hops from the target. Each team sets its own depth for its estate, and this post gives no number.
- A service anchor. Every chain ends at a business service that the team defined. Discovery finds relationships, and people decide which service matters most.
- Source and age. Each edge shows which discovery method found it and when it was last seen. Multi-source reconciliation explains how competing sources settle on one record.

Some edges never appear in discovery. Addresses written into configuration files, calls inside a vendor’s platform, and manual failover paths can all stay invisible. The absence of an edge does not prove the absence of a dependency, and Virima does not claim to find every edge or see inside a vendor’s platform.
What does a self-healing script need from a CMDB before it acts?
A script can use typed, directed dependencies tied to a named business service. Teams decide how far to review the dependency chain and check the available source and freshness information before allowing unattended action.
A Per-Runbook Check Before You Let a Script Act Alone
This check is a template for your own review. Fill it in for each runbook in automation scope.
| Runbook action | Edge types needed | Direction needed | Stop and route to a named owner if |
|---|---|---|---|
| Restart | Runs on, calls | Dependents above the target | The target has no service anchor |
| Isolate | Calls, stores data on | Inbound to the target | Inbound edges are missing or undated |
| Fail over | Runs on, fails over to | Shared dependents of the pair | Shared tier status is unknown |
| Scale down | Calls, runs on | Consumers of the target | A consumer expects fixed capacity |
| Roll back a change | Runs on, depends on | Dependents of changed CIs | Related changes are open on the target |
One suggested internal measure: the share of runbooks in automation scope whose target CIs have a service anchor and directed dependents. Track it for your own planning, since no benchmark exists for it. Runbooks that fail the check keep a human approval step until the graph is fixed. That approval step is a setting in the automation or ITSM (IT service management) tool; Virima does not enforce it. The same check extends to the wider seven-point data audit for teams preparing AI agents.
Virima Supplies the Topology the Runbook Needs
CMDB owners now face a new request. They are asked to vouch for relationships that a script will act on, usually with no added mandate and little time. A graph built from discovery data and team-defined services gives them something to stand behind.
| What the runbook needs | What Virima supplies | Where the automation tool takes over |
|---|---|---|
| Typed, directed dependency structure | ViVID™ service maps built from discovery data and team-defined services | Choosing which services are critical |
| Service anchor | Services the team defines in ViVID™ | Setting approval rules per tier |
| Edge source and last-seen date | CMDB records populated from discovery sources | Deciding the maximum age |
| Scheduled and recent changes on the target | ViVID™ service maps with ITSM ticket context where supported | Reading the change calendar in the ITSM tool |
| Owner to route to | IT asset management (ITAM) ownership and lifecycle labels | Paging the owner |
| Reading the graph before acting | REST API (Representational State Transfer application programming interface) access for integrations | The orchestrator’s own logic |
| Keeping the desk aligned | ServiceNow CMDB integration and connections to supported ITSM tools | Ticket workflow |
ViVID™ builds the dependency map from service definitions that the team provides by manual entry, spreadsheet import or integrations. Virima’s service mapping turns those definitions and discovery data into a service map. Discovery runs on a cadence the team sets, so the graph has a gap between runs. Cloud integrations cover AWS and Microsoft Azure.
Virima does not run, approve, block, or roll back a remediation. It does not enforce policy, scan, or patch. It does not discover or register AI models or agents. ServiceNow remains the system of engagement, and Virima feeds CI and relationship context into it. Virima also integrates with Jira Service Management, Ivanti, HaloITSM, Xurrent, Hornbill, and TeamDynamix. See the supported integrations hub for available connections.
Schedule a Virima demo to see service maps and dependency context for your environment.
Questions to Put to Your Automation Vendor
These five questions go to the automation or agent vendor, because the answers show how much topology the product reads before it acts.
| Question | What a useful answer shows |
|---|---|
| Which relationship types does the automation read before it acts? | Named types such as runs on and calls |
| Does it use direction, or only “related to”? | Direction inside the decision logic |
| How many hops out does it check, and who sets that? | A setting the customer controls |
| What happens when the target has no service anchor? | A halt and a named owner |
| Can it show the dependency path it used after the action? | A path stored in the action record |
See the Topology Question in Person at Gartner IOCS 2026
Virima will exhibit at Booth 645 at Gartner IOCS 2026 in Las Vegas, 8 to 10 December. Bring a runbook from your own automation scope and ask what the graph beneath it holds. Details are on the Virima Gartner IOCS 2026 page.
FAQ
What are the CMDB requirements for autonomous service operations?
The configuration management database needs typed, directed relationships and service context that teams have defined. Teams can review discovery sources and freshness against the needs of each runbook.
What is the difference between a flat CMDB and one with topology?
A flat CMDB stores configuration item attributes such as hostname and owner. A CMDB with topology adds directed relationships, so a script can read which services break when a configuration item stops.
Why does self-healing automation cause outages?
Automation acts on the facts in its record. When dependents are missing, a restart, isolation, or failover can reach services that nobody linked to the target, and the script has no way to know.
How many dependency hops should automation check before it acts?
The team decides, based on how deep its services stack. A team can start with nearby dependents and extend its review when a runbook touches shared tiers.
How does Virima send dependency data to ServiceNow or another ITSM tool?
Virima supports bidirectional CMDB synchronization with ServiceNow, including discovered configuration items and relationships. Its REST API supports custom integrations and automation workflows.






