Architect Toolkit

Agents are systems that act — which means agent architecture is architecture where a mistake becomes an action. This reel adapts GA-30's toolkit for the agentic era: platform design, tenancy, budgets, and adoption.

▶ Watch this reel

What you'll learn

Agent reference architecture
Agent platform design
Tenancy & cost
Adoption, risk & sourcing

Remember this

Agent reference architecture: gateway, orchestrator, tools, memory, guardrails, observability — with guardrails screening actions and the orchestrator kept stateless
By the third agent, build a platform: shared gateway, tool registry, memory stores, observability, eval harnesses — agents become versioned configuration files
Multi-tenancy: tenant keys enforced at the store ACL (never in prompts), per-tenant sandboxes, and circuit breakers that shed one tenant, not all
Adoption runs pilot → expand → platform; keep the risk & compliance matrix as code with owners and expiry dates — and revisit build-vs-buy twice a year

Reference architecture (6 layers)

Gateway (auth/quota) → Orchestrator (loop, stateless; state in memory) → Tool runtime (contracts, sandbox, audit) → Memory (scoped, TTL'd, ACL'd) · Guardrails (input + output + ACTION) · Observability (full loop tracing).

Platform design

By agent #3, centralize: gateway, tool registry, memory infra, observability plane, eval harness. Agents become YAML definitions: model, tools, memory, guardrails, budget, evals — versioned in git, reviewed like code.

Multi-tenancy

Isolation rings: data (store-level ACL filter — never prompts), execution (per-tenant sandboxes, deny egress), quota (per-tenant circuit breakers).
Noisy-neighbor math: loops amplify — hard breakers, not alerts.
Cost model: per tenant per task class; map to budget blocks per pricing tier.
Compliance matrix: tenant x data-class x model-provider x action-class, as code with owners and review-by dates.

Adoption roadmap

Pilot (1 use-case, HITL, trust metrics) → Expand (3–5 use-cases, self-serve definitions, internal catalog) → Platform (paved road: template + evals + guardrails + budget).

Build vs buy vs configure

Agents = your product → build orchestrator + evals. Internal leverage → configure framework + your gateway/policies. Commodity tasks → buy. Revisit twice a year.

Cross-links

AG-09 (guardrails), AG-14 (loop), AG-16 (registry), AG-17 (memory), AG-18 (HITL), AG-20/21 (observability/evals), AG-22 (sandbox exfiltration), AG-23 (budgets/circuit breakers), GA-30 (base toolkit: selection, NFRs, gates, cost).

Code: The platform contract

# Every agent, in one file, on one platform:
#   shared gateway · registry tools · scoped memory
#   three-surface guardrails · full tracing · CI evals
name: support-triage
version: 3.2.0
model:   { deployment: my-gpt4o, temperature: 0.2 }
tools:   [ticket.search, ticket.reply{hitl}, kb.lookup]
memory:  [conversation{ttl:90d}, user-profile{pii:masked}]
guardrails: { input: standard, output: standard, action: strict }
budget:  { max_steps: 12, max_cost_usd: 0.35, deadline_s: 240 }
evals:   { golden_set: evals/triage.jsonl, min_success: 0.92 }

# New agents: copy, diff, review, deploy — days, not months.