Run the sandbox demo

Install the evaluation fleet from your onboarding bundle and send a governed request end to end without connecting a payment, ticketing, or model provider.

What you will prove#

The sandbox installs three deterministic evaluation agents and routes a refund request to one of them. The point is not that an agent answers — it is what the control plane does around the answer:

• The gateway selects an agent by capability, and refuses to route to an unhealthy one.
• Policy evaluates the request before the agent runs.
• The agent's attempt to move money comes back as a governed intent, never an execution.
• Every decision emits audit evidence without capturing the payload.

Before you begin#

You need the AgentFleetGateway onboarding bundle, kubectl, Helm 3, registry access, and a running Minikube cluster. Give the cluster at least 6 GB of memory for the control plane and evaluation agents.

minikube start --memory=6144 --cpus=4
kubectl get nodes

Install the demo#

1. Verify the supplied artifacts#

   Use the chart and versioned image values from your onboarding bundle.

   sha256sum --check SHA256SUMS
   ls agentfleet-<version>.tgz agentfleet-images.values.json

   Verify

   The checksum command completes without a mismatch.

2. Install the control plane and demo fleet#

   This installs the CRDs, the control plane, and an agentfleet-demo namespace holding the refund, order, and IT support agents with their routes and policies.

   kubectl apply -f crds/
   
   tar -xzf agentfleet-<version>.tgz
   
   helm upgrade --install agentfleet ./agentfleet \
     --namespace agentfleet-system --create-namespace \
     -f agentfleet/profiles/local-durable.yaml \
     -f agentfleet-images.values.json \
     --set console.enabled=true \
     --set console.config.defaultTenant=retail \
     --set console.inventory.kubernetes.enabled=true \
     --set console.demoCatalog.enabled=true
   
   kubectl apply -f examples/demo-agents/manifests/

   Verify

   Pods reach Running and the agents report Ready:

   kubectl get pods -n agentfleet-system
   kubectl get agents -A

   A restart or two on first install is expected

   Services start before PostgreSQL is accepting connections and retry until it is, so a low restart count on a fresh install is normal. Sustained CrashLoopBackOff is not — see Troubleshooting.

3. Send a governed request#

   Port-forward the gateway, then ask for a capability rather than naming an agent. Choosing the agent is the gateway's job, not the caller's.

   kubectl port-forward -n agentfleet-system svc/agentfleet-gateway 8080:8080 &
   
   curl -s http://127.0.0.1:8080/v1/run \
     -H 'Content-Type: application/json' \
     -d '{"tenant":"retail","capability":"refund-processing",
          "input":{"message":"refund order 123"}}'

   # Global flags (tenant, gateway) come before the command.
   agentfleetctl --tenant retail \
     --gateway http://127.0.0.1:8080 \
     run --capability refund-processing \
     --input 'refund order 123'

   Trimmed to the fields that matter, the response looks like this:

   {
     "agent":  { "name": "refund-agent", "runtime": "langgraph" },
     "route":  { "mode": "capability",
                 "reason": "Matched healthy agent by capability." },
     "output": {
       "status": "denied",
       "toolCalls": [
         { "name": "stripe-refunds",
           "action": "create_refund_intent",
           "status": "intent" }
       ]
     }
   }

   In the AKS sandbox profile

   That profile sends every agent.run routed by the refund capability to the Approval service, so the same request is queued instead of run. The Gateway answers 409 approval_required with an approval id, and the request needs a requester in its body: add "user": {"id": "demo-requester", "type": "user"} to the request in the curl tab above. agentfleetctl run cannot name one against this profile (its --actor flag sends a header that the Gateway reads only in header_dev mode), so it gets 503 approval_unavailable. A queued request shows in the Console's Approval Inbox. This has not been run on a cluster.

   What this proves

   On an install without the approval rule, the agent asked to move money and the control plane held it. "status": "intent" on the Stripe call is the whole thesis in one field — the tool call was recorded and governed, never executed. route.reason shows the selection was explainable rather than arbitrary.

4. See the same decision in the Console#

   The Console shows the request from the operator's side: which agent served it, what policy decided, and what evidence was emitted.

   kubectl port-forward -n agentfleet-system svc/agentfleet-console 8089:8089 &
   open http://127.0.0.1:8089

Try the interesting failure#

The demo is more convincing when you make it say no. Ask on behalf of a tenant no policy covers:

curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/v1/run \
  -H 'Content-Type: application/json' \
  -d '{"tenant":"unknown-tenant","capability":"refund-processing",
       "input":{"message":"refund order 123"}}'

You get 403 and policy_denied. The request never reached an agent. That is policy working, not an error — Write a policy that allows traffic explains how the allow list is built.

What got installed#

See it in Grafana#

The steps above are enough to prove routing. If you want to watch it instead — request rates, audit events, model cost — layer the optional observability profile onto the same install. It packages Prometheus, Grafana, and ClickHouse, with two dashboards provisioned automatically:

helm upgrade agentfleet ./agentfleet \
  --namespace agentfleet-system \
  -f agentfleet/profiles/local-durable.yaml \
  -f agentfleet/profiles/demo-observability.yaml \
  -f agentfleet-images.values.json \
  --set console.enabled=true

kubectl -n agentfleet-system port-forward svc/agentfleet-demo-grafana 13000:3000

Open http://localhost:13000 (admin / agentfleet-demo) and re-run the governed request from step 3. Both dashboards update live. Details on what each one shows — including policy decisions and audit delivery — are in Operations.

Clean up#

kubectl delete -f examples/demo-agents/manifests/ --ignore-not-found
helm uninstall agentfleet --namespace agentfleet-system
kubectl delete namespace agentfleet-demo --ignore-not-found

Where to go next#

• Write a policy that allows traffic — turn default-deny into a working allow list.
• Require approval for an action — make that refund wait for a human.
• Operations — the Grafana dashboards, Usage Center, and Approval Inbox in full.
• Architecture — what happened between the request and the response.
• Install with Helm — move off the demo profile onto a real cluster.