Cloud infrastructure and AI agents on one canvas

Your cloud and your AI agents on one diagram. With the bill on every node.

ArcFoundry reads your cloud accounts and your agent runs and draws the system itself. Every node carries its billed cost. Budget caps and approval gates are enforced while the run is happening, not reported after it.

Start free Open the live canvas

A read-only role, or three lines of SDK. Revoke either in one click.

arcfoundry.app/canvas

AWS · ALB

public-alb

$0.00/mo

load balancer · 1.2M requests billed

AWS · ECS

api-service

$0.00/mo

4 tasks · 2 vCPU · billed hourly

Agent · SDK

support-bot

$0.0000/run

3 steps · sonnet + haiku · 4,102 tokens

AWS · RDS

orders-db

$0.00/mo

db.t4g.large · agent wrote 412 rows

Guardrail

refund approval

enforced

pauses the run until a person approves

measured spend $0.00 this month1 gate pending

The canvas: infrastructure and agents on one graph, each node carrying what it actually costs.

$4,182

cloud spend this month, billed per resource

$911

agent spend, provider-reported per step

1,204

runs halted at their budget cap

Figures from a demo workspace. Yours are your own, to the cent.

The platform

The queue, the database, and the agent that writes to it.

Diagram tools draw pictures. Monitoring draws charts. ArcFoundry draws the system, priced, controlled and provable.

The diagram is generated, not drawn

Read your cloud accounts and your agent runs, and the canvas assembles itself — including drift, so a resource that appears at 3am appears on the picture.

last sync 40s ago · 214 resources · 3 changed

The bill lands on the node

Billed cloud spend per resource and provider-reported token cost per agent step. Cost sits on the thing that caused it, not in a separate dashboard.

orders-db $214.90/mo · support-bot $0.0141/run

Guardrails run during the run

A budget cap halts the agent before the call is made. An approval gate pauses it mid-flight until a person decides. Both are enforced, not reported afterwards.

1,204 runs halted at cap · 38 gates awaiting approval

Proof you can hand to a reviewer

Every action, cost, approval and denial in a SHA-256 hash-chained record you export as a file. The security questionnaire answers itself.

evidence-2026-08.json · 14,802 entries · chain verified

Two halves of the same picture

Your cloud and your agents, together.

The support agent and the database it writes to belong on one diagram. Today they live in two tools bought by two different teams.

Cloud infrastructure

The systems you deployed

Import what you have, connect what is live, see what it truly bills.

Import Terraform and tfstate, and keep the diagram tied to the live account
Connect AWS, Azure or GCP with a read-only role and draw what is deployed
Billed cost per resource, straight from your provider's cost data
Vercel, Supabase, Fly, Railway and Modal in the same picture as the cloud
Drift detection and an exposure view over the resources you actually run

AWSAzureGCPTerraformVercelSupabaseFlyRailwayModal

AI agents

The systems you set loose

Your code, your framework, your loop. ArcFoundry observes and controls it.

Instrument any agent in three lines. Anthropic and OpenAI, streaming and concurrency safe
The agent diagram comes from run data, so it cannot drift from the code
Exact per-step token cost on every node, from provider-reported usage
Replay a run across the canvas and watch the cost accumulate step by step
Budget caps, approval gates and quality scoring enforced at runtime

AnthropicOpenAILangGraphCustom loopsTools and MCP

The combined effect. Both halves sit on one graph, so you can answer the two questions nobody can answer today: which of our systems do the agents touch, and what did that cost?

How it works

A read-only role, or three lines of SDK.

You keep your accounts, your framework and your loop. ArcFoundry only reads — and, where you tell it to, stops.

Connect or instrument

Attach a read-only cloud role, drop in a tfstate file, or wrap your model client. Whichever you start with lands on the same canvas.

The diagram assembles itself

Nodes, edges, costs and latency come from the running system. Nobody maintains the picture, so it cannot go stale the week after someone drew it.

Control it and prove it

Set budget caps and approval gates enforced at runtime, then export a hash-chained record of every action for the review that always comes later.

agent.py

import anthropic
import arcfoundry

client = arcfoundry.wrap(
    anthropic.Anthropic(), agent="support-bot"
)

# your code, unchanged from here
with arcfoundry.run(client, task=ticket.id):
    reply = client.messages.create(...)

Access and trust

We read. We do not touch.

Connecting an account means attaching a role scoped to describe and billing calls. No write permissions are requested, and none would work.

Read-only by constructionThe role we ask for grants Describe, List and Cost Explorer reads. Nothing that can create, modify or delete.

Revoke in one clickDetach the role or delete the SDK key and ingestion stops immediately. Your diagram freezes at its last known state.

Your prompts stay yoursThe SDK records token counts, timings, tool names and costs. Prompt and completion bodies are never transmitted.

Evidence, on requestExport the hash-chained record for any period. Tamper-evident by design, so a reviewer can verify it independently.

arcfoundry-readonly.json

{
  "Effect": "Allow",
  "Action": [
    "ec2:Describe*",
    "rds:Describe*",
    "ecs:List*",
    "ce:GetCostAndUsage"
  ],
  "Resource": "*"
}

Comparison

What the existing tools don't do.

Diagram tools produce a picture. Infrastructure maps mirror resources. Neither covers agents, and neither enforces anything.

ArcFoundry compared with diagram tools (Cloudairy, Lucid, Eraser) and infrastructure maps (Cloudcraft, Hava).
Capability	ArcFoundry	Diagram tools	Infrastructure maps
Where the diagram comes from	The live account and run data	A person drawing it	The live account
Cost shown per node	Billed, per resource and per step	None	Estimated from list price
AI agents on the canvas	Metered, replayable, priced	None	None
Agents and infrastructure together	One canvas, one graph	No	No
Runtime control	Halts spend, pauses for approval	No	No
Audit evidence	Hash-chained, exportable	No	No
Freeform whiteboarding and brainstorms	No — we only draw running systems	Yes	No

See your systems as they actually are.

Connect an account or instrument one agent, and watch the diagram assemble itself with real costs attached.

Start free See pricing