pAIchart ● LIVE paichart.app/mcp
you › add a Loopback0 per switch and advertise it into BGP▌

High-level design in. Reviewed low-level design out.

Give pAIchart your requirements and your topology; get back per-device config, the exact commands that prove it worked, and a rollback. An independent reviewer gates it, and hands off to the provisioning team.

From high-level design to a reviewed low-level design Your requirements and topology enter pAIchart, which runs a multi-agent graph, halts at a human approval gate, and returns a reviewed low-level design containing config, proof commands and rollback. YOUR HLD requirements.md topology.json pAIchart multi-agent graph harvest → design → author → review reading your live systems, read-only HUMAN GATE per role REVIEWED LLD config · proof · rollback your team applies it
pAIchart never applies the change. Applying stays out-of-band, idempotent, and yours.

Configuration change is automated for the network and platform teams who own multi-vendor change such as Cisco, Juniper, Arista, Terraform, Kubernetes. The agents read your live devices through a read-only MCP service you run. Your credentials never reach an LLM, and no config is ever pasted into a chat window.

the problem you already havetoday, in your team

Your device configs are already leaking into chatbots.

Not hypothetically. An engineer with a change to make and a deadline pastes the running config into an AI chat, because it is the fastest way to get a draft. There is no redaction, no policy, and no record that it happened.

01

You cannot police your way out of it.

It is happening now, it is invisible, and it is rational — the chatbot writes good config, and an engineer with a deadline uses what works. Forbid it and you do not stop it; you lose the last thread of visibility into it. What no policy can hand back is control of the system prompt, a limit on which device is in scope, or a record afterwards of what was actually sent.

02

Nothing strips the secrets on the way out.

Community strings, keys, pre-shared secrets, credentials sitting in a Terraform state file — a copy-paste carries all of it, verbatim, to a third party. Nothing in the path redacts it, because there is nothing in the path at all.

the alternativeread-only, yours, borrowed for one run

Give the agents direct read-only access instead. You keep the credentials.

Place a read-only MCP service in front of your infrastructure — network devices, cloud state, Kubernetes, GitOps. The agents read what is actually running, at the moment they need it. You own that service and its credentials. pAIchart never holds them.

Where the trust boundary sits AI clients and the web GUI reach pAIchart, which is hosted. pAIchart reaches an MCP service that you run inside your own infrastructure, registered only for the duration of a run. Your device credentials stay inside your boundary. AI CLIENT Claude Desktop · ChatGPT WEB GUI paichart.app MCPHTTP pAIchart : on-premises/hosted multi-agent graph (DAG) MCP hub · RBAC · identity agent prompts & redaction service registry no device credentials stored here — there is nowhere for them to be MCP — registered at execution, read-only, torn down after the run YOUR INFRASTRUCTURE — YOUR CREDENTIALS, YOUR SCOPE, READ-ONLY your MCP service read-only by construction · you run it native transport NETWORK DEVICES NAPALM: Cisco, Juniper, Arista INFRA AS CODE Terraform state KUBERNETES cluster state
Everything below the dashed line is yours.
the graphmultiple legs, one contract

A graph of reviewed changes, not a chat about one.

Each node is a pipeline of specialist agents: Harvester → Designer → Author → Reviewer → Synthesize. Each edge carries a value that did not exist until runtime. Legs with no edge between them run in parallel; a dependency edge forces order and hands the real derived value forward.

The multi-agent graph HLD requirements enter a program which halts at approval gates assigned per role. Legs then run: a network leg and a cloud leg joined by a dependency edge carrying a value derived at runtime, plus a third leg running in parallel. All legs feed an integration review, then a human release gate, then the released low-level design. HLD REQUIREMENTS PROGRAM a pipeline of pipelines — plans the graph APPROVAL GATES, PER ROLE project manager · network architect · cloud specialist NETWORK LEG harvest live device state design author config + rollback review derives the exporter range CLOUD LEG harvest live state design author policy + rollback review authorises exactly that range ANOTHER LEG k8s / GitOps / firewall same four stages no edge → runs in parallel derived value INTEGRATION REVIEW all legs against one contract — catches what no leg can see RELEASE GATE — a human LLD RELEASED
The orange edge is the difference between a graph and a script: it carries a value that did not exist until the network leg ran.
—

Cross-domain parameters are passed, not retyped.

The cloud leg authorises exactly the address range the network leg derived, because it reads what that leg produced. Vendor A to vendor B to cloud to GitOps, with no human reconciling the values by hand and no pre-agreed constants in the high-level design.

—

Approval gates per domain, for the person who owns it.

A program stops at the gates you define, and each one waits for the right human — a project manager on the plan, a network architect on the fabric change, a cloud specialist on the policy. Released from an AI client or the web UI, over one common code path.

—

Granular control, agent by agent.

Each node is separately configured. One agent only fetches; another reviews adversarially and can return needs-revision. Different models for different functions, chosen per agent, because the job of harvesting is not the job of judging.

—

The integration reviewer sees what no single leg can.

Each leg’s own reviewer is blind to the others. It can confirm its own package is well-formed, but not that the range it authorised is the one the network leg actually derived. The integration reviewer runs once at the end across all the legs: drift between them, and collisions that only exist when you look at everything at once.

the deliverableyou approve; you don’t author

What comes back is a change package, not an answer.

Every run ends the same way, in every domain: one reviewed change package, the same four parts each time.

CONFIG
per device, in that vendor’s language
candidate configuration blocks, designed against the state harvested minutes earlier — not against a stored copy
PROOF
the exact commands that prove it worked
deterministic validation steps with their expected output, so the engineer applying it can confirm success rather than assume it
ROLLBACK
the config that restores prior state
per device, plus a recommended change ordering and a maintenance-window note
REVIEW
an independent verdict, and its reasoning
a reviewer that did not write the package, that can and does return needs-revision, and whose finding is recorded either way
The expertise a multi-vendor change used to demand shifts from authoring across every system to approving one reviewed result.
one real run — not a mock-up Run 20260722-0444 · network → cloud, sequenced
harvested live, minutes before design

ceos1 loopbacks in use .3 .28 .30 ceos2 loopbacks in use .13 .15 .29 all six read from the devices, not from a store

two free adjacents — .4 / .5
10.99.0.4/31
minimal covering /31 · zero unused addresses authorised
the reviewed change that came back

aws_s3_bucket_policy bucket acme-app-logs allow s3:PutObject where aws:SourceIp = 10.99.0.4/31 integration reviewer: APPROVED

The cloud leg authorised exactly the range the network leg derived — a value that did not exist until the switches were read. Every check ran against the harvested evidence, not the package’s restated copy, and nothing was applied. read the full change report →
how it is checkedthree tiers · a lower one cannot be overruled

Not “the AI said it was fine.”

Tier 1, arithmetic in code. Whether a derived range covers exactly its declared members is set membership, not judgement, so it runs deterministically against the harvested evidence — never against the package’s restated copy. And when a value is of a kind the checker does not implement, the platform says so and escalates rather than counting it as passed.

Tier 2, independent reviewers. One per leg against its own contract, plus the integration reviewer across all legs — running your domain’s own validators over the composed set (Batfish, terraform plan, kubeconform). It consumes those validators; it does not reimplement them.

Tier 3, the release gate. A deterministic AND: every leg approved, no containment violation, the integration reviewer approved, coverage complete. No confidence number appears in it.

A Tier-1 violation blocks the release regardless of who approved above it. An approval on top of a wrong number does not rescue it, and a check that could not run is a block, not a pass.
Why there is no confidence score in the gate. A controlled study ran two reviews of byte-identical input and got 45 and 92. The number carries verdict direction, not correctness. It is still recorded as a fact; it decides nothing.
We publish the rounds we failed. Fourteen verification documents, each stating its expected observables before the run. Including VT-12, where a program self-certified releasable while shipping an authorization widening — five tiers passed it, and the requirements edit meant to help is what caused it. Defect, root cause and fix are all public. Every document now cites the run record it came from.
read the verification pack — every claim linked to its machine record →
read the real change reports — network, k8s, terraform →
running itconfiguration, observability, access

Change how the agents think without a deploy.

—

Agent system prompts live in the database.

Edit any agent’s instructions in the web app and the next execution uses them. No restart, no redeploy, no release. The same is true of the graph definition and its approval gates.

—

Configure and run from an AI client or the GUI.

Define the graph, launch it, and release its gates from Claude Desktop, ChatGPT, or the web application — one common code path, so the behaviour is identical whichever door you came in.

—

Full observability and forensics.

Every run’s metadata and artifacts are browsable: what each agent saw, what it produced, which checks ran, which gate held and why. A run stays inspectable long after it finishes — the change reports on this site were pulled from the artifact store after the lab was gone.

—

Keys per user or system-wide, services registered by tool.

Bring your own model API key per user, or run one at the organisation level. Register any MCP service through an MCP tool call — no ticket, no console.

connectnothing to install

Point your client at it and state the objective.

hub endpoint
https://paichart.app/mcp
connect with
Claude Desktop (GitHub OAuth) · ChatGPT (Microsoft OAuth) · or the web app
you supply
requirements.md (your HLD) and topology.json, at any fetchable location
first thing to say
"Help me get started with paichart"