PRD — AgentLand (agentland.world)

"AgentLand is a microscaler — the opposite bet from a hyperscaler." Microscaler (n., category we are coining): where a hyperscaler sells infinite anonymous capacity, a microscaler provisions small, governed, fully-metered units of intelligent work — agents — at a scale a human can see, afford, and hold accountable. Hyperscalers sell you the ocean; a microscaler sells you an aquarium where you can watch every fish. AgentLand is the first. Version: Gen-1.4 — microscaler category rebrand (Gen-1.2 critique loops in §16; Gen-1.3 additions in §17) Author: Claude Fable 5 (all planning through Fable per Byron's directive), 2026-07-11 Executor: written for one-shot overnight execution by a Claude Opus 4.8 session with no other context. SPEC ONLY — nothing is built. Domain: agentland.world (owned at GoDaddy, verified 2026-07-11; picked per Byron: "I like the world one").

---

0. The one-paragraph pitch

AgentLand is a microscaler — a new category — where the primitive isn't a VM, it's an agent. Visitors sign in with Google, get free credits ($5–$25, or redeem a $100 coupon Byron sends), and provision agents the way you'd provision EC2: pick a model mix, set dials for compute / storage / network / context, attach Responsible-AI agents (traffic, police, courts, judges, councils) as first-class infrastructure, wire agents into workflows that execute monetizable transactions, and watch it all live in Mission Control. Everything runs small-by-design inside Byron's Mac Mini with hard cost fences (per-account caps, idle purges, acknowledgment gates), because the product being demonstrated is the shape of the future utility — modularized, metered, governed agents — not raw horsepower. It is simultaneously a working test platform, a Responsible-AI showcase, and Byron's sharpest demo asset.

1. Why (Byron's intent, distilled from his notes)

• Coin and own the microscaler category: agents as the sellable, meterable, governable primitive — the counter-position to "what AWS and other hyperscalers are selling," not a miniature imitation of it.
• Make model choice and mixture-of-models a real feature, not plumbing: primary/secondary model selection, restricted to a couple of very cheap models, visible and dialable.
• Make Responsible AI structural: the traffic, the police, the courts, LLM-as-judge, councils — attachable governance agents, not a compliance page. (This extends Byron's existing Glass Court work; its Ed25519-signed verdicts and policy live on this same machine.)
• Keep it radically cheap: $5 account caps (later maybe $1), tiny simulated hardware slices, automatic purge gates.
• Be demoable: click-through narrated demo, Mission Control that makes the invisible visible, marketing a stranger understands in one minute.

2. Vocabulary (used consistently everywhere)

Term	Meaning
Agent	The provisionable unit. Has a model mix, four dials, a role card, credits meter, lifecycle policy.
Model Mix	An agent's primary + secondary (+arbiter, see §5) model config from the platform's cheap-model allowlist.
Dials	Compute · Storage · Network · Context. Simulated capacity settings with real enforced budgets (§6).
RAI Family	Governance agents: Traffic, Police, Court, Judge (LLM-as-judge), Council. Attachable to any org or workflow (§7).
Workflow	A wiring of agents (DAG) that processes Transactions.
Transaction	A monetizable unit of work entering a workflow (e.g. "what's the best stock for me?" → advice pipeline). The billing atom (§8).
Org	A tenant. Google-auth owner + delegated members (§9).
Mission Control	The live observability surface for everything (§10).
LandCredits	The currency. $1 = 100 LC. All caps, meters, coupons denominated in LC.

3. Non-goals (Gen-1 — say no loudly)

• No real infrastructure resale, no GPU rental, no arbitrary code execution by users. Agents run ONLY platform-defined behaviors against allowlisted LLM APIs.
• No real-money billing (credits are play-money metered against real API cost internally; Stripe is Gen-2).
• No custom user-supplied models or keys. No fine-tuning.
• No public unauthenticated compute — every call is behind Google auth + org + cap.
• Financial-advice transactions are DEMO content: outputs carry a "simulation, not financial advice" banner (Court-enforced, §7).
• Not mobile-native; responsive web + PWA only.

4. Cast of screens (each gets a mockup — the mockup site mirrors this list)

1. Landing (agentland.world): pitch, 1-minute promo, "Sign in with Google", coupon field.
2. Onboarding: first-login credit grant ($25 default; $5 configurable; $100 coupon path), pick-your-first-agent wizard.
3. Provision an Agent: the marquee screen. Role card, model-mix picker, the four dials, lifecycle policy, RAI attachments, price-per-hour estimate updating live.
4. Agent detail: live meters (LC burn, calls, context fill), logs, pause/destroy, dial adjustments.
5. Workflow Studio: drag agents onto a canvas, wire them, drop a Transaction template in, run it, watch tokens flow.
6. Marketplace: launch catalog of agent templates, RAI family front-and-center, install-to-org.
7. Mission Control: platform-wide live board — every agent, org, transaction, verdicts feed, spend heat, purge queue.
8. Org & Members: members, delegated sub-logins, roles, coupon management (admin), caps.
9. Transactions ledger: every transaction with cost breakdown per contributing agent.
10. Demo mode: the narrated click-through (§12).

5. Model Mix — the feature Byron called out first

• Allowlist (Gen-1, cheap by construction): claude-haiku-4-5, gemini-2.5-flash, deepseek-chat, ollama/gemma4 (local, $0). Admin can edit the allowlist; users cannot.
• Per agent: Primary (default route), Secondary (fallback + second opinion), optional Arbiter for mixture mode.
• Mixture modes (visible dial, per agent): single (primary only) · failover (secondary on error/timeout) · second-opinion (both answer; arbiter or self-consistency picks; costs 2×, UI says so) · council (N models vote — only via a Council RAI agent, §7).
• Every response in logs/Mission Control is stamped with which model(s) actually served it and LC cost. The mix is the pedagogy: users should see quality/cost trade-offs. Each mode shows live "expected LC/1k tokens."
• Platform-wide kill switch per model (admin) when a provider misbehaves.

6. The Dials — microscale capacity with real enforcement

Four dials per agent, 1–10 scale, each mapping to a REAL enforced budget (simulation with teeth, not theater):

Dial	Simulates	Actually enforces (Gen-1 mapping)
Compute	vCPU class	max LLM calls/min + max concurrent calls (1→2/min, 10→30/min)
Storage	disk	max bytes of memory/artifacts persisted per agent (1→256KB, 10→25MB, SQLite-backed)
Network	bandwidth/egress	max outbound tool calls (web fetches, inter-agent messages)/hour + payload size cap
Context	RAM	max context tokens assembled per call (1→2k, 10→24k) + the context organizer setting: what gets packed first (recency / pins / semantic recall), visible as "organizing principles" per Byron's note

• Dial changes re-price the agent instantly (LC/hour hold + LC/call), shown before confirm.
• Physical reality: everything shares the Mac Mini. A global scheduler enforces fleet ceilings (total concurrent LLM calls, total storage GB, total calls/min); user dials are fractions of those ceilings, so the box can never be overrun. Ceilings live in admin config.
• Idle agents cost a tiny LC/hour "hold" (drives the purge story and teaches real cloud economics).

7. Responsible AI family — governance as infrastructure (the differentiator)

Attachable governance agents, modeled on Byron's existing Glass Court (policy + Ed25519-signed verdicts, preserved at ~/court-public/ + OB1 postgres):

• Traffic — rate/flow governor. Sits on a workflow edge; enforces throughput, dedupes, queues. (Maps to real limiter middleware.)
• Police — content/action inspector. Screens transactions in-flight against org policy (prompt-injection flags, PII, banned intents). Can stop a transaction; every stop is logged with reason.
• Court — adjudicates disputes/escalations (a Police stop appealed, an inter-agent contract breach). Produces signed verdicts (reuse the Ed25519 signing pattern). Verdicts are public within the org; Mission Control shows the docket.
• Judge (LLM-as-judge) — quality scorer attachable to any agent's output (rubric configurable). Feeds scores to Mission Control and to Council votes.
• Council — N-model deliberation (uses the model allowlist; ties into §5 council mode). Configurable: members, voting rule (majority / unanimous / judge-weighted).
• Multiple instances, each configurable; attach points: org-wide, per-workflow, per-agent. Every RAI attachment visibly adds LC cost — governance costs compute, which is exactly the honest lesson.
• Default: every new org gets Traffic + Police attached org-wide, free tier (platform-subsidized) so governance-by-default is the norm; detaching them is allowed but Mission Control badges the org "ungoverned."

8. Transactions & monetization

• A Transaction = template + input + workflow run. Launch templates: advice.stock ("what's the best stock I should buy" — demo-banner enforced), commerce.order ("buy a hamburger" pipeline: intent → options → checkout simulation), content.brief (research + draft + judge).
• Each transaction shows a cost waterfall: which agents touched it, tokens, LC per hop, RAI overhead — the "stitched together" contribution view Byron described.
• Revenue simulation: templates carry a notional price (e.g. advice.stock = 50 LC); the ledger shows margin = price − cost. This is the "monetizable agents" story without real money.
• Ledger is append-only; per-org and platform-wide (admin) views.

9. Identity, orgs, credits, admin

• Auth: Google only (GIS, same pattern as branding-console/Mentor: server verifies id_token, HMAC session token; server-only secrets — no client-embedded secret half-keys, see §16 loop-1).
• First login → org auto-created from email; grant = 2,500 LC ($25) (admin-settable to 500/$5). Coupon codes: admin mints codes (value, count, expiry); $100/10,000 LC is Byron's send-to-a-friend unit. Redeemable at signin or later.
• Delegation (keep it simple per Byron): an org owner invites collaborators by email; invitee Google-signs-in and lands in the org with role member (provision/run within org caps) or viewer. Sub-identities are just role-scoped members — no password machinery ever.
• Roles: platform-admin (Byron + designates: allowlist, ceilings, coupons, org caps, kill switches, purge overrides), org-owner, member, viewer.
• Caps (fail-closed): org hard cap (default 500 LC/day), per-agent cap, per-transaction cap. Cap hit ⇒ agent pauses, never silently degrades. All caps admin-adjustable per org.

10. Mission Control

One screen that makes the whole simulated world legible (Byron: "the ability to basically see how anything is working"):

• Live board: every running agent (org, model mix, dial profile, LC burn sparkline), transactions in flight (animated through workflow hops), RAI events feed (Traffic throttles, Police stops, Court verdicts, Judge scores).
• Spend heat: LC/hour by org/agent/model; projected vs cap; platform totals vs the real internal API budget.
• Purge queue: what dies when and why (§11), with one-click stay (admin/owner).
• Health: fleet ceilings utilization, provider status, queue depths.
• Org members see their org; platform-admin sees all. Built on server-sent events; every number clickable through to logs.

11. Lifecycle & cost gates (the "keep this cheap" machinery)

• Idle purge: agent untouched (no calls, no owner visit) for 3 days → archived (config + memory snapshot kept 7 days, then deleted). Settable per org 1–14 days; badge shows countdown.
• Acknowledgment gate: provisioning arms a check-in timer (24h default; 6h for anonymous-tier orgs). An email ("your agent X wants to live — click to keep it") must be acknowledged or the agent is destroyed. Every subsequent 72h of activity re-arms a lighter version. All timers visible on the agent card and in Mission Control's purge queue.
• Credit exhaustion: LC=0 ⇒ org frozen (nothing destroyed for 72h; email nudge; then normal purge flow).
• Global monthly real-dollar budget (admin): platform stops accepting new transactions when the real upstream API spend hits the ceiling — the platform itself obeys the same fail-closed philosophy it teaches. (Reuses the true-cost-ledger discipline from Byron's fleet.)

12. Demo mode, use cases, marketing (launch-blocking, not afterthoughts)

• Narrated click-through demo: auto-advancing guided tour (provision → dial → attach RAI → run advice.stock → watch Mission Control → get the Court verdict), narrated in Byron's cloned voice (Chatterbox pipeline, exists) with optional talking-head intro (avatar speak.sh pipeline, exists — "the speaking demo with my boys": recorded with/for his boys as the audience-test). Skippable, restartable, runs off canned data so it never costs credits or breaks.
• Three business use cases (each a marketplace bundle + a landing section + one mockup state):
  1. Restaurant ("buy a hamburger" made real): order-intake agent + upsell agent + Police (allergy/compliance) + Traffic (rush-hour flow) → commerce.order transactions.
  2. Financial advisory (the monetizable question): intake agent + research agent + Council (3 cheap models deliberate) + Judge scoring + Court-enforced disclaimer → advice.stock.
  3. Photography studio (Libeso): inquiry-to-booking agent + portfolio-brief agent + pricing agent + RAI Police for image-rights language — ties AgentLand to the Mentor white-label story with one brand.
• Marketing kit: 1-minute promo video (screen-capture of demo mode + avatar narration — the avatar app makes this a render, not a shoot); one-sentence explainer ("Provision an AI worker like you'd provision a server — governed, metered, five dollars"); landing copy written for a smart non-engineer; QR to the demo.

13. Architecture (Gen-1, sized to reality)

• One Node service on the Mini (port 18960, same ops pattern as avatar app: nohup + LaunchAgent + Caddy agentland.world if self-hosted) OR Vercel frontend + Mini API. Decision: all-on-Mini — SSE for Mission Control, SQLite (+ existing OB1 postgres for verdict signing), zero cold-start weirdness; Vercel hosts only the static landing/mockups until launch.
• Stores: SQLite (orgs, users, agents, dials, workflows, transactions, ledger, coupons, purge_timers, rai_events); agent memory = per-agent SQLite blobs under the Storage dial's byte cap.
• LLM access via ONE gateway module: allowlist enforcement, per-call LC metering (token-priced per model), fleet ceiling semaphores, model-mix routing, kill switches. Every call writes a ledger row. No other code path may call a provider.
• Email (ack gates, coupons) via the existing Gmail-API pattern; sender is a platform address, display "AgentLand".
• Simulation loop: agents "run" only when serving transactions or scheduled ticks (no idle LLM chatter — idle costs hold-LC only, no real tokens).
• Auth/session/HMAC identical to branding-console _common.js but with server-only secrets.

14. Build phases with acceptance criteria (for the overnight executor)

• P0 — skeleton + auth + credits (night 1): Google sign-in → org; grant + coupon redeem; admin role; SQLite schema; LLM gateway with allowlist + metering + org cap. Accept: two test Google accounts each get orgs/credits; a metered haiku call debits the ledger; cap-hit freezes; admin adjusts a cap.
• P1 — provision + dials + lifecycle: agent CRUD, dials with live pricing, purge/ack timers + email, agent detail with meters. Accept: dial change re-prices; storage-dial byte cap enforced (write over cap → refused); ack email arrives, non-ack destroys at deadline (test with 2-minute timer override); Mission Control purge queue shows it.
• P2 — RAI family + workflows + transactions: Traffic/Police/Judge/Council/Court, Workflow Studio (minimum: linear chains + one branch), three transaction templates, cost waterfall. Accept: advice.stock runs through intake→research→Council→Judge with Court-signed disclaimer attached; Police stop on a banned intent is visible in Mission Control; waterfall LC sums to ledger debit.
• P3 — Mission Control + marketplace + demo mode: SSE live board, install-from-marketplace, narrated click-through (canned data), landing with promo. Accept: Byron watches a transaction animate across Mission Control while it runs; demo completes hands-free with voice; marketplace installs the Restaurant bundle into a fresh org.
• Each phase ships behind agentland.world with a version stamp; CANONICAL-STATE-style log mandatory (the Mentor discipline, adopted).

15. Risks & honest limits

Risk	Position
Small scale mistaken for fakery	The category IS the answer: a microscaler is small on purpose. Dials enforce real budgets, every call is really metered, and nothing claims to rent servers.
Abuse of free credits (LLM proxy farming)	Cheap-models-only allowlist, org caps, coupon gating, per-IP org-creation limit, global real-dollar ceiling. Worst case exposure = ceiling.
One Mac Mini	Fleet ceilings + queueing; it's a demo platform, backpressure is acceptable and even pedagogical (Traffic agents!).
Email deliverability of ack gates	Purge never fires on email failure alone (log + Mission Control warning instead); Gmail-API sender is a known-good path.
Scope explosion	Non-goals (§3) + the phase gates. The overnight executor builds P0–P1 minimum, P2–P3 only if green.
Fable sunset	All planning was Fable (this doc); execution targets Opus 4.8; model strings in code are config, never literals.

16. Critique log (two loops, as ordered)

Loop 1 (found and fixed):

• C1: Dials were pure theater in draft 1 (labels, no enforcement). Fixed: every dial maps to an enforced budget (§6) — the simulation must have teeth or the platform teaches nothing.
• C2: Draft 1 copied the Mentor/branding auth pattern including a client-shipped secret as part of the HMAC key — reproducing a known Mentor vulnerability into a NEW system. Fixed: server-only secrets (§9, §13).
• C3: Credits could go negative mid-flight on long transactions. Fixed: per-transaction cap pre-authorization (hold LC before run, settle after) (§9).
• C4: RAI agents were optional garnish. Fixed: governed-by-default (free Traffic+Police org-wide), "ungoverned" badge as social pressure (§7) — Responsible AI as the default posture is the whole brand.
• C5: No answer for "what stops a coupon farm?" Fixed: per-IP org limits, coupon expiry/count, global real-dollar ceiling (§15).
• C6: Purge emails as a hard dependency = data loss on a bounced email. Fixed: purge-on-silence only when email delivery succeeded (§15).

Loop 2 (what I forgot, per Byron's "see what you forgot" order):

• F1: Mission Control was missing from draft 1's screen list despite Byron naming it explicitly. Added as §10 and made a launch-blocking P3 item.
• F2: The demo/marketing kit (1-minute video, voiced click-through, "with my boys") was an afterthought paragraph. Promoted to §12, launch-blocking, and wired to the avatar/voice pipelines that now exist on this machine.
• F3: Network dial — Byron said "don't forget network." Draft 1 had three dials. Fixed (§6).
• F4: No admin coupon management UI — Byron: "I can send them a code." Added to screen 8 and P0.
• F5: The context dial lacked Byron's "organizing principles around the context" — added the context-organizer setting (recency/pins/semantic) (§6).
• F6: No tie between transactions and the contribution view ("different agents contribute") — added the cost waterfall as a first-class ledger artifact (§8).
• F7: Draft said "maybe Vercel, maybe Mini." Committed: Mini-hosted app, Vercel for static only (§13) — an executor can't build a maybe.
• F8: Libeso/Mentor cross-story synergy (use case 3) — one brand across both platforms strengthens the demo narrative.

---

17. Gen-1.3 additions — third forget-loop + competitive steal list (2026-07-11, pre-build)

17.A Positioning upgrade (from the landscape scan)

The July-2026 scan validates the premise — AWS AgentCore provisions agents from {model, prompt, tools} via CreateHarness; Anthropic, Microsoft, Google all ship hosted agent runtimes — and reveals the gap AgentLand owns: every real platform buries governance in settings pages and economics in invoices; the only watchable agent worlds (AI Village, Project Vend) have no provisioning console. AgentLand is the fusion: "the microscaler: SimCity for the agent economy" — a legible toy civilization where every token spent, verdict signed, and purge executed is a visible public event, which is simultaneously the sharpest RAI demo in the room. This sentence goes on the landing page.

17.B Invites & People-First communications (Byron's explicit ask, now first-class)

• Invite object: admin/org-owner enters an email → the platform creates a pending membership + escrowed credit grant keyed to THAT email; templated invite mail goes out ("Byron provisioned you 2,500 LC — sign in with this Google address to claim"). First Google sign-in with the matching address claims org, role, and credits atomically. Byron sends invites from the Org screen with zero assistance.
• Referral loop: inviter earns 500 LC when the invitee activates (first successful transaction). Caps: 10 rewarded referrals/org.
• One communications register: every outbound (invite, ack-gate, purge warning, weekly digest, verdict notice) goes to the member's email identity through one ledgered comms table — People-First: a person's email is their identity, their inbox is the contract channel, one-click unsubscribe per category honored everywhere except ack-gates (safety-critical, but frequency-capped).
• Weekly org digest: spend vs cap, verdicts, purge queue, best transaction of the week (feeds the Inspector-General brief, 17.C-11).

17.C Steal list — 12 features from the landscape, adapted to a $5 microscaler (each cited)

1. Spectator Mission Control with public reasoning (AI Village, theaidigest.org/village): opt-in "observatory" mode streams agents' live action feed + reasoning summaries + inter-agent chat to viewers. Costs a websocket; makes the sim a show. → P3.
2. Economy drama: balances, insolvency, public purges (Anthropic Project Vend): agents carry visible balances; hitting zero is a Mission Control EVENT (insolvency → freeze → purge countdown), not a silent state. The purge queue becomes narrative. → P1 (already specced; upgrade: make events public/animated).
3. Agent Cards at /.well-known/agent-card.json + a registry (A2A protocol / MCP registry): every AgentLand agent serves a real A2A-style agent card; the marketplace doubles as a registry API. Static JSON — nearly free — and makes "A2A-discoverable, MCP-registered" literally true. → P2.
4. Agent citizenship (Microsoft Entra Agent ID): every agent has a directory identity with an owner/sponsor and an org-chart slot. Gives Police/Court someone to subpoena; lifecycle policies ARE purge gates, now with a name on them. → P1 (fold into agent schema).
5. Split-line billing: tokens + session-hours (Claude Managed Agents, $0.08/session-hour precedent): the cost waterfall itemizes tokens + runtime-hold + storage + network as separate meters, so the $5 decays visibly across four lines. → P0 gateway (meter design).
6. 402 payments + signed mandates (Google AP2, Coinbase x402): sim services reply HTTP 402 "Payment Required" in LC; agents pay and retry; every agent purchase requires a signed spending mandate the Court audits against the cap. Teaches the real emerging standards with zero real money. → P2.
7. Command-center IA + OTel traces (Salesforce Agentforce): Mission Control = health tiles → drill into per-session span traces (every reasoning step, tool call, guardrail check as spans). Emit actual OTel-shaped JSON for standards credibility. → P2/P3.
8. CreateHarness-shaped provisioning + marketplace listing schema (AWS AgentCore + AWS Marketplace agents category): the provision API takes {model_mix, charter, tools, dials} exactly harness-style; marketplace listings carry the AWS-style schema (pricing model, endpoint, category). → P1/P2, pure CRUD.
9. Model compare grid with lanes (OpenRouter): the model-mix picker shows $/Mtok, latency, context per allowlisted model, with a "commodity vs premium lane" toggle — budget as a strategic choice. → P1 UI.
10. Online judge + precedent promotion (Braintrust): Judge agents score live traces; a conviction promotes the trace to a regression dataset ("precedent") that future agent versions are tested against; repeat offenders escalate to Court → purge. Courts with mechanics, not vibes. → P2.
11. Inspector-General meta-agent (LangSmith Insights Agent): one cheap scheduled agent reads the fleet's ledgers/traces daily and publishes "The State of AgentLand" brief (Mission Control panel + email digest + social-ready snippet). Governance content that markets itself. → P3.
12. Guardrails as visible pipeline nodes (OpenAI AgentKit UX — platform sunsetting, insight stands): render Traffic/Police checks as literal wired nodes in each agent's pipeline view, so trust is something you can SEE. → P2 Workflow Studio.

17.D Loop-3 items not covered above

• Playground: 3 free capped messages with any marketplace template before provisioning (conversion hook; watermarked, platform-subsidized).
• Pricing page: what $5 buys, dial→price table, worked example transactions.
• Docs quickstart + public status page (status = Mission Control health tiles, public read-only).
• Data dignity: org owner one-click export (JSON) and delete-org; retention stated plainly. RAI credibility depends on it.
• Share cards: og image per screen so any page dropped into LinkedIn/Slack looks intentional.
• Demo autopilot toggle in Mission Control for live presentations (canned event stream).

17.E The AWS double-bonus (all $0, verified 2026-07-11)

• Runtime = Strands Agents, AWS's open-source Apache-2.0 agent SDK (aws.amazon.com/blogs/opensource/introducing-strands-agents-an-open-source-ai-agents-sdk). AgentLand's agent loop is implemented as Strands agents; the platform truthfully advertises "every citizen runs AWS's open agent framework." Strands natively speaks MCP + A2A (strandsagents.com), which §17.C-3 already requires.
• Callable FROM Bedrock AgentCore, never hosted on it: AgentCore (GA Oct 2025, pay-as-you-go) supports any protocol incl. MCP/A2A via AgentCore Gateway (aws.amazon.com/bedrock/agentcore) — so any AWS customer can attach an AgentLand agent as a tool. Their bill, our zero. CreateHarness is AgentCore's proprietary API, NOT a standard — we copy its ergonomics (§17.C-8) and implement the open protocols.
• The graduation story (demo closer): Strands agents deploy to AgentCore Runtime unchanged (strandsagents.com/docs/user-guide/deploy/deploy_to_bedrock_agentcore) — "this civilization runs on a Mac Mini; any citizen graduates to Bedrock AgentCore without a rewrite." Microscaler by design, hyperscaler on-ramp built in.
• Landing page gets an "Runs Strands · Speaks MCP + A2A · Graduates to AgentCore" credibility strip; Mission Control health tiles emit OTel (§17.C-7), aligning with CloudWatch GenAI observability.

17.F Workflow Studio interaction model + Agent Definition v1 (Byron's design review, 2026-07-11)

Designer (Workflow Studio) — committed interaction model:

• Palette → canvas drag-and-drop: left palette holds (a) org agents, (b) marketplace templates, (c) the RAI family, (d) primitives: Router, Branch, Human Gate (a person approves/edits in-flight — required for a governance-first platform and previously missing), Trigger (schedule / webhook / email-in), Sub-workflow. Drop → node appears wired-ready.
• Property inspector: click any node → right-side panel edits everything live (model mix, dials, charter, instruction layers, tools, output contract). Every edit reprices the workflow estimate instantly. Canvas has undo and versioning; workflows pin agent-definition versions.
• Typed edges: a connection carries transaction | verdict | context; the canvas refuses type-mismatched wiring (governance edges only accept RAI nodes).
• Test-run mode: push a canned transaction through with per-node reasoning preview at zero LC (fixtures, not live models, until "Run live").

Agent Definition v1 — the quality schema (replaces the thin charter-only definition):

1. Instruction stack (layered, separately editable, composed in order): platform base → org policy → agent charter → task prompt. Inspector shows all four layers.
2. Exemplars: 2–5 input→ideal-output pairs stored on the definition; injected as few-shot. The single cheapest quality lever; the UI nags if empty.
3. Knowledge attachments: docs/URLs linked to the agent; chunked and stored under the Storage dial's byte cap; the Context dial's organizer (recency/pins/semantic) decides packing. Attachment list visible on the agent card.
4. Output contract: JSON schema / format spec; Judge auto-validates every output against it; violations are RAI events.
5. Attached evals: test cases incl. court-precedent promotions (17.C-10); any definition edit re-runs them; failing evals block deployment of that version to workflows.
6. Versioning: immutable definition versions; workflows pin; diffs visible; rollback one click. Marketplace templates ship with all six fields populated — that's what makes a template worth installing.

17.G Memory layer (Byron's design review round 2)

Three tiers per agent, all governed by the existing dials — memory is where agent quality compounds:

• Working memory: the per-session context assembly (already specced via the Context dial + organizer). Ephemeral.
• Episodic memory: an append-only journal of transactions the agent handled — auto-summarized after each run (one cheap flash call), time-decayed, capped by the Storage dial. "What have I done and what happened."
• Semantic memory: distilled durable facts/preferences/lessons, promoted from episodic by a nightly consolidation pass; plus an org-shared knowledge space any org agent can read (write requires org-owner grant). "What do I know." Rules: the Context organizer packs working ← semantic ← episodic in that priority; every memory is inspectable and editable in the agent inspector ("what does this agent remember?" — an RAI transparency requirement, and Police can redact); purge/destroy deletes memory with a pre-purge export offer; memory writes are ledgered (storage-dial bytes). Naming deliberately parallels Bedrock AgentCore's Memory primitive (§17.E credibility).

17.H Professional roster + palette taxonomy (the toolbox)

Roster — Gen-1 marketplace "Staff" templates, every one shipped with ALL SIX Agent Definition fields populated (instruction stack incl. profession-baseline knowledge + norms, exemplars, starter knowledge attachments, output contract, evals, v1): Legal: Lawyer (contract/risk review; output contract = structured risk memo; hard rule: flags, never approves — a Human Gate follows it by default). Engineering: Developer (feasibility, plan, code review), CTO (architecture/tradeoff review), CISO (threat model, security review; evals include an injection-resistance case). Product: Product Manager (requirements, prioritization), Technical Writer/Documentarian (docs from artifacts), Designer (UX critique). People: HR Manager (policy-aware, escalates rather than decides on protected matters — Police-attached by default). Finance: Financial Analyst (models, budgets; advice-banner enforced). GTM: Marketer, Sales/SDR, Support Agent. Ops: Researcher/Analyst, Executive Assistant. Each template names its default model lane (most = commodity/haiku-flash; CTO/Lawyer default second-opinion mode). Palette taxonomy (easy-to-use is the requirement): left palette groups = My Agents · Departments (Legal / Engineering / Product / People / Finance / GTM / Ops — expandable) · RAI Family · Primitives, with search-as-you-type and favorites. Department bundle drops: dragging a whole department chip drops a pre-wired mini-workflow (e.g. Engineering = Developer→CTO review chain with a Judge attached). Hovering any palette item shows its definition card (model lane, LC/hr, output contract) before you commit.

17.I Definition-schema smoke test (executed pre-build — results recorded here)

Byron's order: prove a complete workflow actually works before building the platform. A standalone harness (~/agentland/smoke/) composes real Agent Definitions (layered instructions + exemplars + output contracts) for PM → Developer → Lawyer → CISO on the real cheap-model allowlist (haiku / gemini-flash), runs a launch-review transaction through them with a Judge validating each output contract, and produces the final memo + a token/LC cost waterfall. Pass = every hop honors its output contract and the Judge scores ≥ threshold; the run's artifacts and costs are committed alongside the seeds as the platform's first regression fixture. RESULTS (executed 2026-07-11, real API calls): PASS. PM → Developer → Lawyer → CISO on alternating claude-haiku-4-5 / gemini-2.5-flash; Judge scores 9/8/9/9, overall 8.75/10 (threshold 7); all contracts honored ≤1 retry; total transaction cost 11.56 LC ($0.1156) with a full per-hop waterfall. Quality proof: the haiku-powered Lawyer flagged that the PM's "warn + log" MNPI feature manufactures negligence evidence (critical severity) — charter-true reasoning from a commodity model. Schema lessons folded back into this spec: (1) output contracts MUST carry upper bounds (maxItems/maxLength) as a platform norm — an unbounded findings array made run 1 blow the token cap and truncate JSON; (2) enum restrictions must be restated in the task prompt (cross-provider enum drift) and linted roster-wide in seed CI; (3) judges need schema-valid scores for null artifacts. Artifacts: ~/agentland/seeds/*.json (all 14 roles, exemplars machine-validated), ~/agentland/smoke/run-workflow.mjs, results-2026-07-11.json (the platform's first regression fixture), archived failing run, and REPORT.md with the full memo chain.

17.J Reference integration cases (launch-blocking demo content — Byron, 2026-07-11)

Two presentation-grade reference cases, each an animated auto-advancing walkthrough (same treatment as Demo mode §12: chapters, canned data, optional cloned-voice narration, click-through or autopilot), shipped as chapters in the demo player + an "Integrations" row in the Marketplace + a docs page each. These exist so AgentLand slots directly into Byron's hero project and Claude Code project as reusable set-pieces.

RC-1 — Claude Code in the workflow ("the terminal joins the org chart"):

• The story: an AgentLand workflow's Developer seat is delegated to a real Claude Code session on the Mini via MCP — AgentLand exposes the task as an MCP tool; Claude Code picks it up, does real repo work, and returns the artifact into the transaction, where the CTO/Judge/Court pipeline treats it like any citizen's output (contract-validated, judged, cost-waterfalled — Claude Code's tokens metered as the hop's cost).
• The animation: split-screen — left, the Workflow Studio canvas with the transaction dot entering the Developer node; right, a stylized terminal replaying a REAL recorded Claude Code session (keystroke-timed playback, not video); the dot exits with the artifact and the waterfall increments. The "aha" beat: the Judge scores the terminal's work exactly like an in-platform agent's.
• Why it matters: proves the microscaler governs work it didn't generate — external agents become governable citizens through MCP.

RC-2 — Kiro in the workflow ("spec in, software out, governed"):

• The story: an AgentLand transaction produces a spec (the PM agent's requirements artifact — already Kiro's native food: spec-driven development); the spec hands off to Kiro (AWS's agentic IDE), Kiro's agent builds against it, and the result re-enters AgentLand for the Lawyer/CISO/Judge review chain proven in §17.I. Round trip: microscaler plans and governs → Kiro builds → microscaler verifies.
• The animation: the requirements JSON morphing into a Kiro spec panel, Kiro's task list executing (recorded, stylized replay), the artifact flowing back through the RAI chain to a signed verdict.
• Why it matters: extends §17.E — Strands runtime + AgentCore on-ramp + Kiro in the loop = the full AWS-adjacent story at zero AWS spend; and spec-driven Kiro + contract-validated AgentLand is a genuinely coherent engineering loop, not a logo parade.

Acceptance (P3): both cases run hands-free in the demo player using genuinely recorded sessions (record one real Claude Code run and one real Kiro run; replay — never fake terminal output); each has a "wire this yourself" docs page (RC-1: the MCP endpoint config; RC-2: the spec handoff format); Marketplace lists both as installable integration templates.

17.J-bis — AgentLand-as-a-Service: the consumption model (Byron's key framing: "we are the service — consume us like AWS/Azure/GCP"). The reference cases are two-way; the durable architecture is that ANY harness consumes AgentLand's agents, outputs, and workflows as a cloud service:

• Credentials like IAM: per-org API keys minted/rotated/revoked in the Org screen (scopes: read / invoke / admin), LC-metered identically to console usage, every key's calls visible in the ledger and Mission Control. Key creation shows the one-time secret + a "store this like an AWS access key" warning.
• Service surface (three protocols, one metering path):
  1. REST api.agentland.world/v1 — POST /agents/{id}/invoke, POST /workflows/{id}/run, GET /transactions/{id} (artifact + cost waterfall), GET /events (SSE stream of RAI events/verdicts). OpenAPI spec published.
  2. MCP server per org — tools: invoke_agent, run_workflow, get_transaction, search_marketplace. This is how Claude Code, Kiro, or any MCP client consumes AgentLand natively.
  3. A2A — the agent cards of §17.C-3; external A2A agents call AgentLand citizens directly.
• "Connect your harness" screen (new console screen #11, mockup required): the AWS-console "programmatic access" pattern — pick your tool in tabs (Claude Code → the exact .mcp.json snippet · Kiro → its MCP config · curl · Python/JS), each with the org's real endpoint + key placeholder, copy buttons, and a "test connection" ping. Plus the harness-configuration outline for each: what the tool sees (tool list), what a call costs, what governance applies (Police screens inbound calls; external calls are transactions like any other — same caps, same waterfall, same verdicts).
• Console-wide "</> API" affordance: every screen (agent detail, workflow, transaction) carries a small </> chip that flips open the exact API/MCP call reproducing what you're looking at — the console teaches the service. Screenshots of this affordance are part of the docs and the reference-case walkthroughs.
• Acceptance: an external Claude Code session, configured only from the Connect screen's snippet, invokes a workflow, retrieves the artifact + waterfall, and appears in Mission Control as via api-key <name> with Police screening applied. Same test repeated from Kiro.

17.K Labs: The Observatory — 3D deck (EXPERIMENT, demoted by Byron 2026-07-12)

Status: Labs experiment, not a core screen or launch requirement. Byron's verdict after using it: fun, not usable as a working surface. It stays reachable via a small "🌐 labs" globe on the landing page; the flat Mission Control (§10) is the real observability surface. Everything below is retained as the experiment's design record; build effort on it only ever comes after P3, if at all. A cinematic 3D rendering of Mission Control (new mockup screen #12, observatory.html; platform feature in P3 as the premium view over the same SSE feed):

• Scene: Three.js (vendored, no CDN): agents = volumetric glowing nodes in orbital shells by org; transactions = light streams between hops; Police stops = red interceptions; verdicts = expanding ring pulses with the signature hash; purges = nodes collapsing to embers. Bloom + depth-of-field + glass panels = "photoreal sci-fi" grade; prefers-reduced-motion gets a static beauty frame.
• Manipulation tiers: (1) mouse/touch: orbit, dive, grab-an-agent → it dollies forward and its telemetry cards fan out in 3D; drag a transaction onto a workflow to launch it. (2) In-air hand tracking (MediaPipe, in-browser, webcam opt-in): pinch-grab-swipe over the fleet — the literal Minority Report interaction, demo-mode toggle with full fallback. (3) Voice ("show me org retro-diner") as a stretch goal only.
• Agents get faces: marketplace portraits per professional template, and the flagship: the Court reads verdicts through a rendered talking head in Byron's cloned voice (the avatar.arnao.ai pipeline on this same machine renders it; pre-rendered per-verdict, never live-faked). The most memorable RAI image in the room: a judge with a face, reading a signed verdict.
• Honesty rules: same data as flat Mission Control (one SSE feed, two renderers); the 3D view adds legibility drama, not fake data; hand-tracking is labeled experimental; verdict faces are rendered clips, labeled as Byron's cloned voice.
• Mockup acceptance: observatory.html runs the orbital scene with grab-focus + fanned data cards on the seeded dataset, ships in nav + landing grid, holds 60fps on an M-class Mac and degrades gracefully on mobile.

17.L Phase impact

P0 unchanged + meter design (17.C-5) + Strands as the agent-loop library (17.E). P1 gains citizenship fields, compare-grid picker, public insolvency events. P2 gains agent cards/registry, 402+mandates, span traces, precedent system, pipeline-node guardrails, listing schema. P3 gains observatory mode, Inspector-General, playground, status/docs/pricing pages, the credibility strip, the two reference integration cases (17.J), the as-a-service surface + Connect screen (17.J-bis; API keys land in P0 with auth), and the Observatory stays a Labs experiment (17.K), not a launch item. Nothing here changes the Gen-1 cost posture: every addition is CRUD, static JSON, websockets, replayed recordings, or one cheap scheduled agent.

17.M Hyperscaler-parity check (Byron's "are we missing essentials?" — 2026-07-12)

Parity review against AWS/Azure/GCP surface areas. Covered already: IAM→roles+scoped keys, billing→LC ledger, quotas→caps/dials, marketplace, observability→Mission Control+OTel, compliance→RAI verdicts+export/delete, status/docs (17.D). Deliberately absent BY CATEGORY (not gaps): regions/AZs, GPU scale, enterprise SLAs — "one Mac Mini" is the thesis; the status page pledges honesty, not nines. THREE REAL GAPS, all adopted as requirements:

1. Backup/DR (P1, ops-blocking): nightly SQLite snapshot (sqlite3 .backup) to a dated file + weekly restore test; retention 14 days; a platform holding other people's orgs/credits without backups is negligent.
2. Admin audit trail (P1): every admin action (cap change, coupon mint/revoke, allowlist edit, key revoke, freeze/unfreeze) writes an audit row (who/what/before/after) — visible to the org affected and in Mission Control. A governance-first platform governs its own admins.
3. Budget threshold alerts (P2): email at 50/80/100% of org cap via the People-First comms register — warn before the wall, don't just freeze at it. Nice-to-have noted, not required: declarative org config export ("agentland.json" as toy IaC).

---

Companion mockups: agentland.world (static, deployed alongside this PRD). Build trigger: Byron's explicit go — then P0 begins overnight on Opus 4.8.