Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.equinix.dev/llms.txt

Use this file to discover all available pages before exploring further.

github.com/equinix/agent-factory is the canonical, Equinix-shipped collection of Fabric automation agents. equinix.dev’s job is to plan the infrastructure (equinix-dev plan, then terraform apply); Agent Factory’s job is to keep that infrastructure healthy after apply.This page maps the Agent Factory inventory to the Use Cases — so for each deployment pattern, you know which agents to run next.

​
The three categories

Agent Factory classifies every agent by execution shape. The classification is what makes it composable — your platform team picks a Run-Once on apply, a Scheduled audit cadence, and the right Event- Driven mitigations, and ships a stack.

Run-Once

Execute immediately on deployment. Use for first-time scans, alert-rule creation, baseline diagnostics, and one-shot reports.

Scheduled

Trigger on a cadence (hourly / daily / weekly). Use for utilization monitoring, drift detection, periodic reports, and proactive bandwidth upgrades.

Event-Driven

React to real-time Fabric Streams events. Use for packet-drop mitigation, metro latency spikes, BGP session churn, and any state-change alerting.

​
Catalog of agents (Equinix-shipped, as of preview)

AgentCategoryWhat it does
Auto-upgrade connection bandwidthScheduledWatch utilization on primary + secondary connections; when threshold crossed, upgrade bandwidth and maintain redundancy parity.
Auto-upgrade Cloud Router packageScheduledMonitor route count on the FCR; upgrade BASIC → ADVANCED when route table approaches package limit.
PING + TRACEROUTE diagnosticsRun-OnceIssue diagnostics from the FCR’s metro perspective; email the report.
Alert rule creation for connectionsRun-OnceCreate the canonical alert set (down, degraded, BGP-session-lost) on every connection at provision time.
Project lifecycle PDF reportScheduledWeekly per-project summary with route table, connection list, recent state changes; emit PDF.
GCP metrics integrationEvent-DrivenSubscribe to Fabric Streams, transform, push to GCP Cloud Monitoring.
Metro latency spike detectionEvent-DrivenWatch P95 latency by metro pair; page when spike exceeds threshold.
Packet drop mitigationEvent-DrivenDetect packet drop pattern; auto-shift traffic to secondary path, page on-call.
Real-time network stream analysisEvent-DrivenGeneric Fabric Streams consumer for custom heuristics.
The repo evolves; check the source for the current list and the agent definitions themselves (each agent is a Markdown file documenting capabilities, tools, and release status).

​
How equinix.dev hands off to Agent Factory

┌─────────────────────────────────────────────────────────────────┐
│  equinix.dev (plan-only)                                        │
│                                                                 │
│  1. equinix-dev init      ──▶  project scaffold                 │
│  2. equinix-dev add       ──▶  provider packages                │
│  3. equinix-dev plan      ──▶  terraform.hcl  +  mcp.json       │
│  4. equinix-dev preflight ──▶  PASS / FAIL gate                 │
│                                                                 │
└──────────────────────────────┬──────────────────────────────────┘
                               │
                            human approves
                               │
                               ▼
                        terraform apply
                               │
                               ▼
┌─────────────────────────────────────────────────────────────────┐
│  Agent Factory (operational)                                    │
│                                                                 │
│  - Run-Once  agents fire     ──▶  alert rules created           │
│                                   diagnostics emitted           │
│  - Scheduled agents activate ──▶  bandwidth audit cadence       │
│                                   route count cadence           │
│  - Event-Driven agents listen ─▶  Fabric Streams subscriptions  │
│                                   packet drop mitigation        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘
The minimum operationally-defensible agent set after this Use Case’s terraform apply:
  • Auto-upgrade connection bandwidth (Scheduled, daily) — GPU traffic to Lambda fluctuates with workload; let utilization trigger upgrades, not paging.
  • PING + TRACEROUTE diagnostics (Run-Once) — bake the baseline latency profile on day one.
  • Alert rule creation for connections (Run-Once) — on both the origin-to-FCR and FCR-to-Lambda connections.
  • Metro latency spike detection (Event-Driven, P95 > 30ms) — the inference path’s first-token latency budget.
  • Packet drop mitigation (Event-Driven) — failover to the secondary FCR if a metro flaps.
See Private AI inference path for the Terraform recipe these agents operate on top of.
For the regulated multi-cloud pattern, the agent set leans on auditing and BGP health:
  • Alert rule creation for connections (Run-Once) — on all 6 cloud connections (3 clouds × 2 metros).
  • Project lifecycle PDF report (Scheduled, weekly) — auditor-ready snapshot of routing posture and connection state.
  • Auto-upgrade Cloud Router package (Scheduled, hourly) — the FCRs handle BGP routes for AWS/Azure/GCP; route count grows with VPC count.
  • Real-time network stream analysis (Event-Driven) — custom rule: any prefix outside the PCI route filter being advertised triggers an immediate page.
See Multi-cloud private interconnect.
The observability Use Case is itself an agent-shaped pattern, so the Agent Factory set is mostly Event-Driven on top of the Fabric Streams subscriptions you already provisioned:
  • GCP metrics integration (Event-Driven) — if your AI inference compute lives in GCP, this routes Fabric metrics to Cloud Monitoring next to your application metrics.
  • Metro latency spike detection (Event-Driven) — paired with the Datadog sink so the spike pages and lands a snapshot.
  • PING + TRACEROUTE diagnostics (Run-Once per metro) — three baseline traceroutes (IAD/DFW/SV5) for the first incident’s “compared to last week” delta.
See Distributed AI observability.

​
Why this split is the right boundary

equinix.dev is plan-only by design — see the Safety model. The mutation that Agent Factory performs (creating alert rules, upgrading bandwidth, shifting traffic) is real, authorized at apply time, and scoped to the specific agent’s capability rather than blanket account access. This means:
  • An attacker compromising the agent-factory runtime can do what the agent’s capability allows — they can’t suddenly drain your whole Fabric account.
  • An audit can answer “what changed and who changed it” because every agent has a Markdown definition that names its tools.
  • A board / regulator can read the Agent Factory repo and the equinix.dev safety model in one sitting, and verify that the plan-only / agent-bounded boundary holds.
This is what a serious developer platform on top of regulated infrastructure looks like.

​
Next

Three full Use Cases

Each one has a Terraform recipe that the agents above operate on top of.

Safety model

The six controls keeping the boundary between plan-only and operational.