AGENTIC COMMIT · AI NETWORK CHANGE LAYER

From plain-language request to verified network change.

Specialised AI agents plan multi-vendor network changes from your topology and your engineering rules. A deterministic gate validates every plan, a named engineer approves it, and it runs atomically, with automatic rollback if anything fails.

Runs on your own infrastructure · Works behind your LLM gateway · Built on open standards: MCP and A2A

Network change is still engineered by hand.

Operators want autonomous networks, but most changes still depend on an engineer who gathers data from a dozen tools, writes vendor-specific scripts and hopes the maintenance window goes to plan.

Knowledge is scattered

Inventory, topology, planning and change data live in separate systems. Someone correlates them by hand before every change.

Configs are written per vendor

Each script is drafted for one operating system, which is exactly where a typo becomes an outage.

The rules live in people's heads

Engineering standards sit in HLD and LLD documents and with senior engineers. When those engineers move on, the rules go with them.

Rollback is an afterthought

When a multi-device change fails halfway through the night, restoring every node to its exact prior state is slow manual work.

Generic AI assistants make this worse, not better. They draft CLI with confidence and leave a human to catch the mistake.

Five specialised agents. One safe path to the network.

Every model call goes through the gateway; nothing unchecked reaches a device Grounded in live topology, inventory and your guidelines Request plain language Intent agent normalises it Architect grounded design Engineer writes the plan Auditor gate LiteLLM gateway routes each agent's tier to a model, falls back on failure per-workflow budgets, secret masking, injection blocking Fast tier intake, replies Reasoning tier design and plan Embeddings your standards Models behind the gateway open-weight on your GPUs, in-region cloud or hosted APIs Human approval named engineer Execution agent atomic, per device Verified change post-checks pass Automatic rollback every changed device restored a rule fails: findings go back passes approve apply or verify fails 1 2 3 4 Where a hallucination is stopped 1 Typed output: an answer that does not fit the plan schema is rejected and asked again 2 Auditor gate: 15 deterministic rules and a device dry-run check every device, port and address 3 Human approval: a named engineer approves the validated plan and the standards it cites 4 Post-checks: device state is verified after the change; any failure rolls every device back The model never writes device commands: adapters render them from tested code.

change flow · 5 agents, 1 LLM gateway, 3 model tiers, 4 checks before and after the network

The Intent, Architect and Engineer agents reason; the Auditor and Execution agents are deterministic and never call a model. A plan that fails any rule goes back to the Engineer with the findings, and nothing moves until a named engineer approves it.

Three workflows on one engine.

Network change, end to end

Agents plan the change, the gate validates it, an engineer approves it, and it runs across devices with automatic rollback if anything fails.

Step-by-step scripts for multi-vendor estates

From a plain-language request, the agents design the change and deterministic renderers write the vendor script for Huawei VRP, Nokia SR OS and Fortinet FortiOS. Each script includes backup, pre-checks, verification and a rollback that restores every port's previous settings. Engineers approve the script; this workflow never pushes anything to the network.

Planned-work management as a service

Other agents call the planned-work agent to open a change window. It checks the request against your policy: job reference, equipment scope, attached documents, maintenance hours and notice. When the window clashes with another team's work, it emails that team, reads the reply, reschedules and sponsors the work, with a human review when policy asks for one. It also opens and closes execution windows on request.

In our lab, a request for a second uplink produced a validated two-router script, which was handed to the planned-work agent. The agent negotiated a clash with another team's window and had the work sponsored ten seconds after that team replied.

The AI plans. It never commits.

Every safeguard between a plan and the network is deterministic code, not a model. Four layers stand between an idea and a production commit.

A deterministic validation gate

Fifteen built-in rules check scope, protected interfaces, IP validity and conflicts, MTU, naming and post-checks. The device then validates the candidate config itself, without committing it. A rule that crashes counts as a failure, never a pass.

Grounding in the real network

A point-to-point link is only accepted if your inventory says those two ports are cabled together. Plans are built from live device state and the engineering guidelines they cite.

A named human approver

No change reaches the network without explicit approval, and the requester can never approve their own change. The run waits safely for as long as it takes, even across restarts, and approval can come from the console or from your ticketing tool.

Atomic execution with automatic rollback

Each device change is a single transaction. If any device fails to apply or verify, every device already changed is restored to its exact prior state.

Every agent decision, validation report, approval and device action is written to a hash-chained audit trail that anyone can verify in one click.

One core. Any vendor. Your rules.

Agentic Commit separates what is the same everywhere from what is specific to you. Adding a vendor or a new operator is configuration and a connector, not a rewrite.

Layer What it holds How it grows
Core engine Agent chain, validation engine, transaction manager, audit and observability The same for every customer and vendor
Adapters Connectors to devices, controllers, element managers, change-management, inventory and knowledge systems One adapter per vendor OS or system, reused across customers
Profiles Model tiers and budgets, approval checkpoints, rule packs, prompts, terminology and engineering documents One profile per customer

Adapters speak versioned Model Context Protocol (MCP) contracts, so a new connector never breaks an existing one. Agents are discoverable through Agent-to-Agent (A2A) cards, so they fit into a wider AI ecosystem instead of standing alone.

The engine renders changes through vendor adapters, so the same request produces correct configuration for each platform. The first adapter supports Nokia SR Linux; adapters for other vendor platforms and controllers follow the same contract.

Your network data stays under your control.

Gateway-only inference

Agents never call a model directly. Every request passes through your LLM gateway, described below.

Secrets masked twice

Passwords, SNMP communities and keys are masked inside the engine and again at the gateway, before any prompt reaches a model or a search index.

Zero trust between planes

The AI layer holds no device credentials. Only adapters reach the network, and only through defined contracts.

Prompt-injection guardrail

Attempts to talk the system out of its rules are rejected at the gateway before any reasoning starts.

Cost control built in

Every change runs against a token and call budget. A runaway loop hits a circuit breaker instead of your bill.

Graceful degradation

If the AI layer is unavailable, engineers submit a manual plan that still goes through validation and approval, or hand the change back to the traditional process.

Your models, your gateway, your rules.

Agentic Commit never calls a model directly. Every request passes through an LLM gateway. We build and test with the open-source LiteLLM gateway, and any OpenAI-compatible gateway works.

Choose models freely

Run local open models on your own GPUs, or a sovereign-cloud model in your region. Switching changes the gateway configuration, not the agents.

The right model for each task

A fast model reads requests; a stronger one designs changes. If a model fails, the gateway falls back automatically.

Cost under control

Every change runs against a token and call budget, on top of the gateway's own rate limits.

Guardrails before any model sees a request

Secrets are masked and prompt-injection attempts are blocked at the gateway. Managed filters such as Google Model Armor plug in at the same point.

One trail

Every model call carries the change's run ID, so gateway logs line up with the audit trail.

No single point of failure

If the gateway is down, engineers still submit plans that go through validation and approval.

Measured on real routers, not slides.

These results come from our reference lab: a three-router Nokia SR Linux fabric driven end to end by Agentic Commit, with local open models behind the gateway.

15/15
Rules passed
On every plan approved for execution
6s
Approval to verified
From human approval to change verified on both routers
~1s
Auto-restored
To restore a device automatically after a real commit error on its peer
Attempt 2
Plan corrected
A deliberately corrupted plan was caught by the validation gate and replanned by the agents
<3s
Injection rejected
To reject a prompt-injection attempt, before any reasoning started
~8,300
Tokens used
Model usage for a complete link change, against a 100,000-token budget

A restart of the service while a change waited for approval lost nothing: the run resumed at the approval gate with its plan intact.

The same safety pattern for any critical system of record.

The engine is not tied to networks. Wherever AI should propose changes to a critical system under compliance rules, the same pattern applies: agents plan, a deterministic gate enforces policy, a named person approves, and the change runs atomically with a full audit trail.

Area What the gate enforces Connects to
Enterprise firewall and network policy No any-to-any rules; no conflicts with existing policy Fortinet, Palo Alto Networks, Check Point
Cloud infrastructure: security groups, IAM, Kubernetes Policy-as-code checks; the Terraform plan as the dry run Terraform and cloud provider APIs
Access provisioning for joiners, movers and leavers Separation of duties; least privilege Identity and access governance tools
IT remediation runbooks Blast-radius limits; change-freeze windows ServiceNow and monitoring platforms
ERP master data: vendors, prices, limits Financial controls; four-eyes approval SAP and similar
Industrial and utility setpoints Hard safety limits, with vendor certification SCADA and PLC gateways

A new domain needs its own connectors and rule pack. Planning, approval, rollback and audit stay the same.

This shows where the underlying pattern applies, not a list of connectors shipped today. Current adapters cover network devices, change management, inventory, knowledge, source jobs and notifications.

Built for the teams that own network change.

Agentic Commit is for operators and integrators running multi-vendor transport, IP and access networks: network engineers who design changes, change managers who govern them and NOC teams who live with the result.

How an engagement starts:

1

Connect

We connect adapters to your inventory, change-management and network systems.

2

Profile

We load your engineering rules, documents, approval checkpoints and terminology into your profile.

3

Pilot

Agents plan real changes against your own lab, with every step visible in the console.

4

Supervise

Human-approved changes move to production, with validation, rollback and audit on every one.

5

Scale

New use cases and vendors are added through new profiles and adapters, on the same core.

No unvalidated changes. No half-applied rollouts. No vendor lock-in.