Network automation has always been about closing the gap between what your network is doing and what your systems know about it. Simple Facts was built to close that gap — discover devices, collect structured facts, sync them to NetBox or Nautobot. But there’s a newer, wider gap opening up: between your automation tooling and the AI agents that are increasingly being asked to reason about, act on, and report from your infrastructure. We’re adding an MCP connector to Simple Facts to close that one too.
The Model Context Protocol (MCP) is an open standard — initially developed by Anthropic — that gives AI agents a structured, discoverable way to call external tools. Think of it as a common interface layer: instead of every agent needing a custom integration for every tool, MCP defines how tools advertise themselves and how agents invoke them. The analogy most people reach for is USB-C — one protocol, many devices.
For network automation specifically, this matters a lot. Today, if you want an AI assistant to help you investigate a network issue, you’re either copy-pasting CLI output into a chat window or building a one-off integration from scratch. Neither scales. Your inventory data lives in NetBox or Nautobot. Your automation logic lives in Python. The AI has no principled way to reach either.
MCP changes the equation. Once Simple Facts exposes its capabilities as MCP tools — discover a subnet, collect device facts, trigger an IPAM sync, query current inventory state — any MCP-compatible agent can call them. Claude Desktop, custom agents built on the Anthropic API, and a growing ecosystem of tools that speak MCP all become first-class consumers of your network automation workflows. No glue code. No copy-pasting. Just structured, repeatable tool calls.
The deeper shift is about agency. Scripts run when you tell them to. MCP tools run when an agent decides it needs them — as part of a longer reasoning chain, in response to a question, or as a step in an autonomous workflow. That’s a meaningfully different model, and it’s where network automation is heading.
Simple Facts already has Prefect handling orchestration — scheduling, retries, artifact history, long-running flow management, and a UI for operational visibility. Adding MCP raised an immediate design question: what does MCP own that Prefect doesn’t already cover?
The answer we landed on is clean: Prefect owns execution, MCP owns access. Prefect is the engine — it runs the pipelines, keeps the audit trail, manages credentials via Secret blocks, and handles the operational concerns of running automation reliably at scale. MCP is the interface — it’s the surface that lets an agent ask “what’s on this subnet?” or “sync the latest facts to NetBox” without knowing anything about how Prefect works underneath.
This means the MCP connector is intentionally thin. The tools it exposes are wrappers around the same tasks and flows that Prefect already orchestrates — no duplicated logic, no parallel implementation to maintain. When an agent calls a discovery tool via MCP, it’s invoking the same proven code path that runs in production. The connector adds the protocol layer; it doesn’t rewrite the automation.
There’s also a transport consideration. MCP supports two main transport modes:
The design principle throughout was the same one that shaped the Prefect integration: add the new capability without disturbing what already works. MCP sits alongside the CLI and Prefect deployments, not instead of them.
When your network automation toolkit speaks agent protocols, the use cases multiply quickly. Here are the ones we’re most excited about.
Instead of writing a NetBox API query or grepping through JSON output, you ask: “What devices were added to the production subnet in the last seven days?“ The agent calls the right tools, interprets the results, and gives you an answer. The inventory becomes queryable in plain language — which is genuinely useful when you’re troubleshooting under pressure and don’t want to context-switch into an API browser.
An agent handling an incident can autonomously: discover the affected subnet, collect current device facts, compare them against what’s in NetBox, identify discrepancies, and post a structured summary to Slack — all as a single, coordinated response to a trigger. What would take a network engineer 20 minutes of tooling through multiple systems becomes a sub-minute automated workflow.
Sometimes you just changed something on the network and you want IPAM to reflect it immediately — without opening the Prefect UI, without running a CLI command. With MCP, the agent can trigger a targeted sync on request. “Sync the lab subnet to NetBox” becomes a one-sentence workflow.
Network documentation drifts. Devices get added, renamed, reconfigured — and IPAM falls behind. An agent with access to Simple Facts’ MCP tools can run periodic checks: collect live facts, compare against current IPAM state, and surface anything that doesn’t match. Drift detection stops being a quarterly audit and starts being a continuous background process.
New device appears on the network. The agent detects it, calls discovery, identifies the device type, collects facts, creates the records in NetBox or Nautobot, and notifies the team — without a human in the loop. This is the kind of workflow that previously required custom scripting and careful orchestration. With MCP as the connective tissue, it becomes composable from existing tools.
The MCP connector isn’t just a new feature — it’s a repositioning. Simple Facts started as a CLI tool for network engineers who wanted to stop doing inventory by hand. Adding MCP makes it an AI-native automation surface: something that AI agents can discover, call, and compose as part of broader autonomous workflows.
The broader trend is clear. Infrastructure tooling that speaks agent protocols will compound in value as models improve. The tools you build today — with proper MCP interfaces — become more capable without any additional work on your part, because the agents calling them keep getting better. That’s a different kind of investment than one-off scripting, and it’s the direction we’re building toward.
The MCP connector for Simple Facts is in active development. Watch the GitLab repository for the release, and if you have a use case you’d like to see supported, open an issue or start a discussion — the design is still open enough to incorporate good ideas. You can find us on PiPy as well!
