All writing
Network automation

Collector vs Executor: Reading the Network Is Not the Same as Changing It

Safe network automation starts by separating the read path from the write path. Collectors gather operational evidence. Executors make controlled changes. Mixing those roles is where automation risk creeps in.

Collector vs Executor: Reading the Network Is Not the Same as Changing It

In the last article, I wrote about the orchestration gap: the missing coordination layer around scripts, workflows, approvals, execution, and evidence.

The next practical split is even simpler:

Reading the network is not the same as changing the network.

That sounds obvious, but a lot of automation systems blur those two paths. The same script logs into a device, gathers state, decides what it thinks is wrong, applies a fix, and writes a success message if nothing throws an error. That may be acceptable for a lab or a small utility script. In production, the read path and the write path deserve different levels of control.

This is where the NAF (Network Automation Forum) model gives us a useful way to think. In the NAF architecture, Collector and Executor are separate functional roles. A collector retrieves information from the network. An executor changes something in the network.

That distinction matters because collection and execution have very different risk profiles. You can collect broadly, frequently, and safely if you design the read path correctly. Execution needs more control. It should be validated, approved where appropriate, logged, limited in scope, and followed by post-change verification.

If the first article in this series was about intent versus operational state, and the second was about orchestration, this one is about trust. Before a team trusts automation to change the network, it usually needs to trust automation to read the network correctly.

What Is the Difference Between the Read Path and the Write Path?

Most engineers already understand the difference between a show command and a configuration session. One observes. The other changes.

The problem is that our automation often does not make that boundary as clear as our CLI (Command Line Interface) habits do.

A script may connect to a router, collect BGP (Border Gateway Protocol) state, parse the output, decide a neighbor is wrong, and then apply a route-map change in the same run. A workflow may check interface status and then immediately enable the port if it looks down. An AI (Artificial Intelligence)-assisted tool may collect logs, summarize the likely issue, and offer remediation without making the risk boundary obvious.

The automation may be doing useful work, but the architecture gets muddy.

A cleaner design separates the read path from the write path. The collector gathers current state from devices, controllers, APIs (Application Programming Interfaces), logs, telemetry streams, or monitoring systems. The executor performs controlled changes after the workflow has enough context to act safely.

In practical terms, the collector answers questions like: what is configured, what is running, what is the session state, what prefixes are present, what counters changed, and what does the firewall rulebase look like today?

The executor answers a different class of questions: what change should be made, is the change allowed, who approved it, how do we apply it, how do we roll it back, and how do we prove it worked?

Those two roles can be implemented by the same platform, but they should not be treated as the same responsibility.

Why Does Trust Start With Collection?

Most teams should start with collection before they start with execution.

The point is not to avoid execution. The whole reason to automate is eventually to do useful work. But teams usually build trust by first proving that automation can gather accurate context, compare it against intent, and present useful evidence without changing anything.

Read-only automation is a good place to start because it lowers the risk while still delivering value. You can collect device state, compare it against your desired-state model, detect drift, summarize findings, and route issues to engineers before you ever allow the system to remediate anything.

This is also where teams discover how messy their data really is.

The source of intent may say a device is in one site, while the hostname suggests another. The CMDB (Configuration Management Database) may list an interface as unused, while LLDP (Link Layer Discovery Protocol) shows a neighbor. The monitoring platform may know a circuit is critical, but the inventory record may not have the service owner. The firewall object name may say TEMP_APP_MIGRATION, while the rule has been there for three years.

I actually like starting with collection because it exposes these problems before the automation has permission to make them worse. It is less exciting than pushing changes, but it is usually where the most useful cleanup starts. The first time a collector shows that your “trusted” inventory disagrees with the live network in fifty different ways, it gets everyone’s attention.

The read path is where the automation team learns whether the rest of the operating model is ready for the write path.

What Should a Collector Collect?

A collector should do more than grab raw command output and dump it somewhere.

Raw output is useful, but automation needs structured evidence. If the collector retrieves BGP state, the workflow should be able to understand the neighbor IP, remote AS (Autonomous System), session state, accepted prefixes, advertised prefixes, route-policy references, uptime, and last reset reason.

If the collector reads interface state, it should capture administrative status, operational status, VLAN (Virtual Local Area Network) membership, neighbor information, errors, utilization, optics data where available, and whether the interface is part of a port channel.

The point is not to collect everything forever. That becomes its own mess. The point is to collect the right operational facts for the workflow you are trying to support.

For example, if your workflow is BGP drift detection, collecting CPU (Central Processing Unit) and memory is probably not the first priority. You need intended neighbor definitions, live neighbor state, policy references, received and advertised routes, reachability, and recent change history. If your workflow is interface turn-up, you need port availability, current configuration, LLDP or CDP (Cisco Discovery Protocol) neighbor data, VLAN membership, error counters, and post-change link state.

The collector’s job is to provide enough evidence for the orchestrator to make a better decision.

It should also preserve the difference between facts and interpretation. The collector may gather the fact that a BGP session is idle. Another layer should decide whether that idle state is expected, risky, or actionable. Mixing those too early makes troubleshooting harder because you lose the trail between observed data and workflow decision.

What Should an Executor Be Allowed to Change?

Executors need tighter boundaries.

A collector can safely gather broad state from many devices. An executor should usually operate inside a defined scope. It should know which systems it is allowed to change, what types of changes it can make, what inputs are required, what validations must pass, and what approval level is needed.

This is where teams need to be careful with automation accounts. I have seen environments where the automation account has more access than most humans because it was easier to make the permissions broad and move on. That works until a script bug, bad variable, or wrong target turns into a very expensive lesson.

The executor should have the least access required for the workflow. If the workflow only updates interface descriptions, it should not have permission to change routing policy. If the workflow only manages firewall objects, it should not be able to push broad security rules without approval. If the workflow is supposed to remediate low-risk drift, the allowed drift types need to be explicit.

A mature executor should also leave evidence. It should record what changed, why it changed, who or what approved it, what the pre-checks found, what the post-checks found, and where rollback information lives.

If the executor simply pushes a change and reports “success,” it is not giving the team enough to trust the workflow over time.

How Should a Workflow Collect BGP State Before Remediation?

BGP is a good place to see why the collector and executor need different responsibilities.

Imagine a workflow detects that a BGP neighbor is idle. A weak version of automation might collect show bgp summary, see the idle state, and immediately try a standard remediation step. Maybe it clears the session. Maybe it reapplies a neighbor configuration. Maybe it rolls back to the intended config.

That might fix a simple issue, but it can also hide the real problem or make the situation worse.

A better workflow starts with collection. It gathers the intended neighbor definition, local AS, remote AS, update source, route-policy references, expected prefixes, live neighbor state, last reset reason, interface reachability, and recent changes. It also checks whether there is a provider maintenance window or an approved change that explains the behavior.

A small collector result might look like this:

bgp_collection:
  device: edge-rtr01
  neighbor: 192.0.2.2
  intended_remote_as: 65002
  configured_remote_as: 65002
  current_state: idle
  last_error: "Hold timer expired"
  expected_prefixes: 42
  received_prefixes: 0
  recent_local_change: false
  provider_maintenance_window: true

In this case, the executor probably should not touch the router. The collector found evidence that the session is down during a provider maintenance window, with no recent local change. The orchestrator can notify the team, attach the evidence, and suppress unnecessary remediation until the window ends.

If the same collector found a remote AS mismatch with no approved change, the workflow might route the issue to an engineer or prepare a remediation plan for approval.

The important part is that execution happens after the workflow understands enough about the situation, not immediately after the first symptom appears.

How Does the Read/Write Split Improve Interface Turn-Up?

Interface turn-up is another place where the read/write split helps.

The request may look simple: enable Ethernet1/10 on leaf01, assign VLAN 120, and set the description to app-server-01. The executor can probably do that in a few lines of configuration. The risk sits in everything the workflow fails to check before it gets there.

Before execution, the collector should read the current interface state. It should check whether the port is already configured, whether LLDP or CDP shows something connected, whether the interface is part of a port channel, whether errors are already present, whether the requested VLAN exists at that site, and whether the port is currently shut down for a reason.

It should also compare the live data against inventory because stale records are common around access ports.

Only after those checks pass should the executor apply the change.

After execution, the collector comes back into the picture. It confirms the interface came up, validates VLAN membership, checks for the expected neighbor or MAC (Media Access Control) address, and confirms error counters are clean enough for the workflow to call the turn-up successful.

The same platform may coordinate all of this, but the responsibilities are different. Collection gives the workflow evidence. Execution makes the controlled change. Collection verifies the result.

That loop gives the team much more confidence than a script that pushes the interface config and assumes the job is done.

Why Should Firewall Policy Be Collected Before Rule Deployment?

Firewall automation is where I get especially cautious about executors.

A firewall rule request often starts cleanly enough. Someone needs source A to reach destination B over port C. A basic automation pipeline can take the request, create the object if needed, add the rule, commit the change, and update the ticket.

The problem is that firewall risk usually sits in the context around the rule.

Before anything changes, the collector should read the existing policy, object groups, zones, hit counts, duplicate rules, shadowed rules, recent denies, and ownership data. It should check whether the requested access already exists through a broader rule. It should identify whether the destination is in a restricted zone. It should also look for expiration requirements, because temporary firewall rules have a magical way of becoming permanent if nobody forces a review date.

The executor should only create or update the rule after policy validation and approval are clear. If the request touches a restricted zone, the workflow may require security approval. If the access is temporary, the executor should include an expiration or review mechanism. If the requested rule is redundant, the workflow may stop before execution and tell the requester that the access already exists.

This is also a good place for AI, but not as the owner of the change. AI can summarize the request, explain the policy impact, and draft a review note that a human can actually read. The executor should still be bounded by deterministic checks and approval rules.

How Does the Orchestrator Use Both Paths?

The orchestrator is where the collector and executor become part of a complete workflow.

A collector on its own gives you data. An executor on its own gives you a way to make changes. The orchestrator coordinates when to collect, how to compare that data against intent, whether the workflow is allowed to execute, who needs to approve, and what evidence gets recorded afterward.

A simple pattern looks like this:

Intent
  ↓
Collector
  ↓
Validation
  ↓
Risk Decision
  ↓
Approval
  ↓
Executor
  ↓
Collector
  ↓
Evidence

The important part is that the collector appears twice.

It collects before execution so the workflow understands the starting point, and it collects after execution so the workflow can prove what happened.

This pattern also makes human approval more useful. When an engineer is asked to approve a change, they should not be looking at a vague message that says “Approve VLAN update?” They should see the intended change, the collected pre-checks, the validation results, the risk level, and the expected post-checks.

After execution, they should be able to see whether the network actually matched the intended result.

That is how approval becomes meaningful instead of something people click through just to keep the workflow moving.

Where Does AI Fit in the Collector and Executor Model?

AI should sit on top of collected evidence, not in place of it.

If the collector gathers BGP state, recent changes, maintenance windows, and intent data, AI can summarize the likely cause of a peer issue in plain English. If the collector gathers firewall policy context, AI can help explain whether a rule request is risky and why. If the collector gathers interface counters and optics data, AI can help turn a pile of telemetry into a useful troubleshooting summary.

The quality of the AI output depends heavily on the quality of the collected context.

This is why I keep coming back to harness design instead of prompt tricks. A clever prompt against weak context will still produce weak answers. A decent prompt inside a good workflow, with the right collected evidence and clear execution boundaries, is much more useful.

AI should help engineers understand the evidence faster. It should not quietly cross the line from explanation to production change without the workflow making that boundary obvious.

What Should Teams Build First?

If you are early in this journey, start with the collector.

Pick one workflow where read-only automation would immediately help your team. BGP neighbor validation is a good option. Interface inventory verification is another. Firewall rule review, DNS (Domain Name System) and IPAM (IP Address Management) consistency, and VLAN assignment validation are also good candidates.

For that workflow, define the intended state, collect the live state, compare the two, and show the evidence to the engineer. Do not rush into execution until the team trusts the collection and validation path.

Once the read path is reliable, add controlled execution for narrow use cases. Start with low-risk changes where the validation rules are clear and rollback is understood. Keep the executor scoped. Record what happened. Run the collector again afterward.

The best early wins usually come from workflows where the engineer still makes the decision, but the system removes the repetitive work around gathering evidence. That builds trust without asking the team to accept full autonomy before the foundation is ready.

What Are the Common Mistakes?

The first mistake is giving the executor too much power too early. Broad credentials, broad device scope, and vague remediation logic are a bad combination. If the workflow is still young, keep the blast radius small.

The second mistake is treating parsed output as truth without checking data quality. Parsers break. Vendor output changes. APIs return partial data. Controllers have their own view of the world, which may not match the device. Collection needs validation too.

The third mistake is skipping post-change collection. A successful API response or CLI commit does not prove the network is operating correctly. It only proves the command or request was accepted. The workflow still needs to verify operational state after execution.

The fourth mistake is letting AI blur the boundary between recommendation and action. If AI is summarizing evidence, make that clear. If AI is recommending a change, make that clear. If anything is going to execute, the workflow should have deterministic checks and approval rules around it.

None of these mistakes are exotic. They show up because teams are trying to move fast, prove value, and avoid overbuilding. I understand that. But the read/write split is one of those architectural habits that saves pain later.

What Should Good Collectors and Executors Capture?

A useful collector should capture structured facts that support a workflow, not just raw output. It should record when the data was collected, where it came from, how fresh it is, and whether the collection succeeded fully or partially.

Partial collection matters because a workflow should not treat missing data as a clean bill of health.

A useful executor should capture the exact action it attempted, the target, the inputs, the approval context, the result, and the post-change evidence. It should also expose failure clearly. A failed execution should not leave the engineer guessing whether the device changed, partially changed, or never received the request.

If you want a simple mental model:

  • Collectors gather evidence.
  • Validators compare evidence against intent.
  • Orchestrators decide the next step.
  • Executors make controlled changes.
  • Collectors verify the result.

That separation gives each part of the workflow a cleaner job.

What Is the Final Thought?

Reading the network and changing the network are different responsibilities, and safe automation should treat them that way.

The collector builds trust by gathering evidence. The executor creates value by making controlled changes. The orchestrator connects the two so the workflow can compare intent against operational state, decide what should happen next, and verify the result afterward.

If your team wants to move toward safer network automation, start by making the read path strong. Once the evidence is reliable, execution becomes a lot less scary.

Frequently Asked Questions

What is the difference between a collector and an executor in network automation? A collector reads from the network. It gathers operational state such as interface status, BGP neighbor state, firewall rules, route tables, counters, logs, or telemetry. An executor changes the network by applying configuration, updating a controller, modifying a firewall rule, or triggering a remediation step. The distinction matters because reading is usually lower risk and can happen frequently, while execution requires stronger validation, approval, logging, and post-change verification.

Why should network automation separate read and write workflows? Separating read and write workflows makes automation easier to trust. The read path can collect evidence, compare live state against intent, and show engineers what is happening without changing anything. The write path can then be limited to specific, approved actions with a clear blast radius. When those paths are mixed together too early, automation can move from observation to change before the workflow has enough context.

Should teams start with collectors before executors? In most cases, yes. Read-only automation is usually the safest place to start because it exposes data quality issues, drift, stale inventory, and missing context without creating production risk. Once the team trusts the collection and validation path, it can add narrow execution workflows for low-risk, well-understood changes.

Where does AI fit in the collector and executor model? AI is most useful after the collector has gathered enough context. It can summarize evidence, explain likely causes, compare messy information, draft review notes, and help engineers understand what happened. AI should not quietly become the executor. If a workflow is going to change production, that action should pass through deterministic validation, approval rules, and clear execution boundaries.

What should happen after an executor makes a change? The collector should run again. A successful command, API response, or commit does not prove the network is behaving correctly. Post-change collection should confirm that the live state matches the intended result, whether that means a BGP session is established, an interface is up with the expected VLAN, a firewall rule exists with the right scope, or monitoring can see the new service.

Comments

No comments yet — be the first to share your thoughts.

Leave a comment