Essays & field notes
HUMΛN Community
Depth for builders, teams, and buyers — organized so you can start where you actually are, not at the top of a chronological firehose.
Start here if you are…
If you are a developer
Start with Builders
SDK, extensions, publishing
If you are leading a team
Start with Living HAIO
Shared workflows & human gates
If you are an enterprise buyer
Start with Governance
Deployment, audit, procurement
If you are joining the work
Start with Join Us
Shape the protocol from day one
Category explainers
What HAIO is, why governed workflows matter, and how the trust layer fits together.
Introducing HAIO — the category for trust between people and AI
Friday’s agent demo works. Monday, security asks who acted under which grant. HAIO names the systems built backwards from that question — identity and receipts first, model choice second.
The Validity Ladder: How Trust Grows
Progressive verification explained. Each layer, real scenarios, and why we don't demand everything upfront.
When code becomes a commodity, trust becomes the operating system
The demo compiles on Friday. Monday, someone asks for the receipt. Cheap code did not remove accountability — it moved the bottleneck to Passport, HumanOS, and provenance.
Agents Before and After a Trust Layer
Same request—reschedule my meetings, update my project board. Two worlds: OpenClaw-style vs HUMΛN-governed. The difference is identity, policy, and provenance.
OpenClaw and the Cost of Skipping the Trust Layer
Always-on agents with real system access are here. What's missing isn't capability—it's governance.
Builder education
SDK, CLI, extensions, and the path from first bundle to production governance.
An API designed for builders (and the AIs that help them)
First contact with HUMΛN should not be a dead end—discover, OpenAPI, and errors that teach instead of shrug.
CLI & SDK Scaffolding for HUMΛN Workflows — From Zero to Production in 15 Minutes
How the HUMΛN CLI, SDK helpers, and code generators cut workflow development from hours to minutes — patterns from the Signals implementation.
Workflows as Platform Extensions: Command Plane, Companion, and Workforce Cloud
How the HUMΛN manifest system turns a workflow into a full platform citizen — Command Plane surfaces, Companion actions, and Workforce renderers.
From zero to governed agent — HumanOS CLI and scaffolding
Wave 7: human humanos-manifest validate and scaffold; why the CLI is co-equal product with the API.
What a “HUMΛN-Compliant Extension” Actually Means
Extensions are how agents get useful. A HUMΛN-compliant extension gets its power through HumanOS, Passport, and the Capability Graph—not around them.
Operational patterns
Field notes on receipts, connectors, hosted-to-self-hosted moves, and honest governance.
Field notes: Hosted to self-hosted without rewriting workflows
Same manifests and agents; only endpoints and bootstrap secrets change — zero-regret deployment.
Field notes: What a real decision receipt looks like
A receipt is a binding summary — policy, delegation, resources, provenance link — not a chat log.
Field notes: Why demo-grade workflow products fail in production
Demos optimize for speed; production needs identity, delegation, and provenance — not a bigger canvas.
Field notes: Sharing an AI workflow without hidden authority
Governed bundles expose scopes and install-time delegation — not ambient trust or credential zips.
Field notes: Connectors, muscles, and governed workflows
Three different roles — integration, governed execution, orchestration — not three names for the same thing.
Use-case depth
Signals, workforce, artifacts — real surfaces with real constraints.
Building a Reference-Grade Market Intelligence Workflow on HUMΛN
How the Signals reference workflow was designed, what makes it a good example, and how to fork it for your own domain.
Building human-in-the-loop workflows with the HUMΛN Workforce Module
From zero to a live work item in the inbox: declare renderers, configure routing, test with WorkItemTestHarness, and understand what the human sees.
HumanOS artifacts and the “why am I seeing this?” bundle
Lifecycle vs chat tokens; explainability with policy_applied_id; FSM transitions that earn trust.
Four lines of Python. The protocol enforced the rest.
The same human.call governance story in every language: delegation, Fourth Law, provenance—not a separate 'Python SDK' with fewer guarantees.
Designing Learning-Enabled Workflows on HUMΛN
Declare feedback, memory scopes, proposals, and marketplace learning contracts — then wire the same REST + SDK paths your operators already audit.
Comparison & evaluation
How hosted and self-hosted line up — and what “trust” means under scrutiny.
CT Scans, Corporate Docs, and Self-Hosted Giants
Three stories: healthcare data in the vault, enterprise data in your datacenter, and email branding with clear delegation.
Field notes: Hosted to self-hosted without rewriting workflows
Same manifests and agents; only endpoints and bootstrap secrets change — zero-regret deployment.
Progressive honesty in protocol design
Ship the narrow honest version first; encode the upgrade path in schema; never hide the gap in marketing prose alone.
Safety that moves at business speed
Cross-SDK human.call, ML risk grounded in audits, and policy DSL in the Command Plane—compliance without a migration for every rule change.
Pay for the Engine, Not the Gas: Why HUMΛN Prices Trust—Not Tokens
The AI industry is figuring out how to stop subsidizing power users. Some platforms mark up tokens aggressively. Others hide costs until the bill arrives. HUMΛN does neither.
All posts
Browse the full archive with categories and search-ready filters.
ProductFeatured
Build it in HUMΛN. Run it from any AI.
Publish a workflow in HUMΛN. Run that same version from the Console or from the AI you already use.
- Developer
Context Compact — start thin, fetch on demand
Context windows are not a strategy. Context Compact crushes redundant bulk for agents and Companion muscles — magic by default, CCR retrieve when you need the original, receipts for every crush. Not a proxy.
- Developer
Canon in the loop — scaffold, check, publish from MCP
The same agent that calls platform tools can human.canon.check and scaffold docs. Developer Tools + Canon MCP is governance that rides with the work.
- Developer
Your org is an MCP server — mesh, not a toy catalog
https://{org}.mcp.haio.run exposes workflows and agents as tools at catalog scale. This is the platform mesh — not a weather-demo MCP.
PassportPassport and delegation as MCP trust primitives
Every tools/call rides a delegation. Mint, narrow, and revoke from the AI client — identity is not a sidebar to MCP; it is the load-bearing beam.
GovernanceProvenance from tools/call — receipts, not screenshots
Every governed MCP invocation should leave an attributable receipt. If the agent acted, the ledger can say who, under which delegation, and why.
- Developer
Resources and prompts — ground the agent without pasting the KB
human://docs, kb, schemas, patterns — plus review prompts like design-delegation-scope. Token-efficient grounding so tools/call stays sharp.
- Developer
WebMCP vs org MCP — two products, one trust story
Org mesh MCP exposes your platform to AI clients. WebMCP governs browser tools on the open web. Confuse them and you ship the wrong threat model.
- Engineering
Canon-as-Code — trusted operational memory for agent-driven companies
Stale docs are no longer harmless debt — they are execution risk. How HUMΛN versioned, reviewed, and CI-enforced the truth agents act on.
GeneralTrusted finished work in conversation
- Developer
Keep This Moving: Momentum on HUMΛN
One-shot runs die when the chat ends. Momentum turns successful Intent work into scheduled, governed loops — magic by default, full control when you need it.
- Developer
The Autonomic Engine: Routing That Learns Without Burning Tokens
HUMΛN classifies every human.call() in ~15ms with zero LLM tokens, routes to the minimum capable model, and compounds org-specific quality from your own audit history.
- General
Capability Reflexes: The Pre-Reasoning Fast Path
- Engineering
AI-native mobile UX: the primary surface isn't the browser
Most users experience HUMΛN on their phones. How we built the Companion's mobile UX contract — bottom-sheet command palette, swipe-to-close canvases, scroll-strip suggestion chips.
Developer GuideBuilding discoverable AI capabilities: the command registration model
How HUMΛN's bundle command registration pattern solves the dark spot problem — capabilities that exist but users can't find. A step-by-step guide with the HITL bundle as the worked example.
- Architecture
The Companion is the new AI UX
Why the blank canvas problem kills AI products — and how HUMΛN's Companion solves it with bundle-registered commands, living canvases, and discovery surfaces that make every capability findable.
- General
MCP from the CLI and SDK
- General
MCP Streamable HTTP on HUMΛN
- Developer
Certifying Marketplace Prompts Without Exposing IP
How HUMΛN Check #15 attests third-party agent prompts with SHA-256 fingerprints and trust-boundary metadata—while keeping proprietary system prompts off public listings.
- Developer
Shipping Prompts with Your Marketplace Agent
Your agent is ready for the marketplace — but your prompts live on disk. Here is how agent_prompt_contributions seeds governed prompts at install time so ctx.prompts.load() works for every customer.
- Developer
Every Workflow You Build is Instantly an AI Capability
You don't write API docs, schema specs, or MCP adapters. You build a workflow. That's it. It's immediately callable by Claude, Cursor, or any AI client — with the full governance stack.
- Engineering
One org, many Companions: the deployment model that powers context-aware embeds
How HUMΛN's companion_deployments table gives you an unlimited number of purpose-built Companion instances — each with its own surface context, KB scope, delegation token, and chrome — without a single bespoke integration.
- Engineering
Inside the Companion React wrapper: Shadow DOM, stable refs, and zero conversation loss on route changes
How @human/companion-widget/react mounts the Shadow DOM widget once, keeps it alive across all React renders, and rewires surface context on route change without ever destroying the conversation.
- Developer
Delegation Scope Design Guide
A delegation token is a signed contract between a human and an AI agent. Scope it to exactly what the agent needs, and the human stays in control.
- Developer
Getting Started with HUMΛN MCP
One package. Three tiers. Start with human.ask and drop down only when you need explicit control.
- Developer
Intent Routing Architecture
HUMΛN's intent layer doesn't just understand what you said. It resolves it to a concrete capability plan, checks your delegation, and proposes the minimum viable action.
- Developer
KB Access Control Explainer
The Companion never violates a classification boundary. What it can answer is determined by the delegation, not by the LLM's training.
- Developer
Using Companion from Claude Code
Your Claude Code agent can consult HUMΛN's Companion, search the protocol KB, and propose real actions — all with the human in the loop.
SecurityTrust that survives cryptographic change
HUMΛN is crypto-agile by design: classical-secure paths today, explicit suites and verifier policies, and migration readiness without quantum hype.
- Architecture
companion_integration: true — what it means and when the Companion runs instead of the cloud
The companion_integration field in ConnectorManifest is more than a badge. It describes a real architectural split: some connectors cannot be cloud-only, and the marketplace and runtime both need to know that.
- Architecture
Why local automation needs two layers: the connector/muscle split for macOS
When we built AppleScript/JXA support into HUMΛN, we got the architecture wrong twice before landing on the right split. Here's what we learned — and why provenance can never be local.
- Developer
Writing a JXA catalog entry and publishing it to the HUMΛN marketplace
Step-by-step: build a governed JXA command for Things 3, validate it locally, publish it to the marketplace, and make it available to any org running @human/connector-applescript.
- Governance
Why audit access in HUMΛN is governed, not open — selective disclosure and the right to see
For enterprise buyers: audit is not ‘everyone reads everything.’ It is policy-bound visibility with contestability — the right artifacts to the right roles.
- Governance
Flying with instruments — how a hospital compliance team proved an AI-assisted triage decision in minutes
A healthcare-shaped scenario: from AI suggestion to nurse review to physician override — one narrative with receipts, not 47 disconnected log lines.
- Architecture
How an AI agent documents its own work — machine-attributable actions and provenance trails
Builders: why ‘the model did it’ is not an audit answer — and how actions become attributable to agents, scopes, and policy versions.
StrategyWhy HUMΛN audit is trust infrastructure, not an admin dashboard
The HAIO category-protection narrative: audit is how the trust layer stays legible — not a compliance island bolted onto ‘the real product.’
- Governance
What happened here? — Understanding HUMΛN audit for non-technical audiences
For compliance leads and executives: a plain-language map from question to evidence — without drowning in log lines or internal jargon.
- Operations
How ordinary operators investigate incidents without specialist training — the Audit Workbench story
Frontline teams need narratives, not query languages. The workbench pattern: guided investigation with receipts — not a blank search box.
- Product
How Companion routes to humans when AI judgment is not enough
From trigger to resolution: what the human sees, what the audit trail contains, and why this is not “a person checks it” as an afterthought.
- Product
Five workflows you can launch with Companion before your first meeting tomorrow
Concrete, professional-context habits — from triage to prep — that turn Companion into a repeatable entry point, not a one-off chat.
EnterpriseHUMΛN Cloud vs self-hosted: what changes and what does not
A decision framework for enterprise architects: identical contracts and manifests, shifting responsibility for infrastructure, residency, and support — with honest beta boundaries.
- Enterprise
Human escalation vs. pure automation: when AI alone is not enough
Decision criteria for medical, legal, financial, and customer-exception contexts — how Workforce Cloud preserves accountability after escalation, not just faster tickets.
- Strategy
What makes HUMΛN different from workflows and agent frameworks
An honest comparison axis: trust layer vs. automation tool. Where we overlap on the surface — and what buyers miss when they map us to n8n, Zapier, LangChain, or AutoGen.
- Product
Building a personal workflow on mobile with HUMΛN Companion
What mobile-first usage looks like — starting a workflow on your phone, continuing on desktop, and keeping the same provenance story across surfaces.
DevelopersHow to publish your first agent to the HUMΛN Marketplace
Review expectations, governance requirements, listing content that converts, and how revenue and visibility work — opinionated notes from the publisher path.
- Product
How HUMΛN Signals turns external noise into governed, actionable intelligence
For operators and enterprise buyers: what Signals watches, how relevance is judged, how outputs pass governance before action, and how feedback closes the loop.
- Architecture
What is Human-AI Orchestration (HAIO)? — practitioner reference
Protocol-level definitions for engineers and evaluators: what HAIO requires at the human–machine handoff, what adjacent stacks optimize for instead, and a four-question checklist before you recommend a stack.
- Operations
Why governed workflows matter (and why most teams skip it until something breaks)
Concrete failure modes when AI steps run without receipts, what governance adds in practice, and why HUMΛN treats policy as infrastructure — not compliance theater.
- Passport
BBS+ alongside SD-JWT: libraries, independent keys, and honest predicates
@mattrglobal/bbs-signatures for BLS12-381; BBS issuer keys are not Ed25519-derived; Phase 6.1 predicate pattern vs full range proofs in 6.2.
- Passport
Prove you qualify without revealing your score—or letting two employers compare notes
Boolean proxy claims fix the wrong problem: they centralize the oracle and link every presentation. BBS+ is how you prove a threshold and stay unlinkable across verifiers.
Capability GraphThe routing engine that understands what you mean, not what you typed
Semantic matching, evidence-backed inference, and canonical mappings—why capability is for revelation across org boundaries, not ranking humans.
- Capability Graph
The evidence economy: capability as what you produce, not what you claim
Semantic routing + ML inference + canonical portability—skills as verifiable traces of work, not resume adjectives.
- Passport
Recovery where the math matches the marketing
Social recovery shouldn't be a trust-me story. Here's why client-side reconstruction and proof-only verification matter—and what happens in the 48 hours when everything is still reversible.
- Passport
Server-blind social recovery: HMAC proofs and completion modes
Normative sketch: proof_verifier at initiation, constant-time verification, and why client_proof rejects plaintext shards with 409.
- Passport
Shamir cross-language alignment: GF(2^8) vs vsss-rs (and what to do)
Server TS and mobile Rust don't share the same share semantics until you unify them—here are three real options and a recommended Phase A.
- HumanOS
Four lines of Python. The protocol enforced the rest.
The same human.call governance story in every language: delegation, Fourth Law, provenance—not a separate 'Python SDK' with fewer guarantees.
- HumanOS
Building a multi-language governance wrapper: JWT preflight and Fourth Law signaling
HumanCallOptions in @human/core, base64url footguns, and why 409 vs 200+fourth_law_triggered both exist.
- HumanOS
ML risk scoring that reflects real stakes: embeddings and audit history
Keywords match strings; embeddings match context. KNN over past audit events grounds risk in what actually happened—not a demo heuristic.
- HumanOS
When AI risk gets smarter than the word 'patient'
Embedding-based domain classification and KNN risk from audit history—same infrastructure as capability, different question: is this task safe to auto-route?
- Passport
Sync without us in the middle
WebRTC DataChannel for vault bytes; server as ICE/SDP signal only; revocation that catches up when devices reconnect.
- Passport
A credential you hold up to a scanner, not hand to someone
Selective disclosure isn't privacy theater—it's the difference between handing over your ID and proving a single property. Multi-device sync and anchoring exist so verification works even when we're not in the loop.
- Passport
Multi-device E2E sync: ECDH, QR pairing, and the honest path from relay to P2P
P-256 + HKDF + AES-GCM for WebCrypto portability; QR payload versioning; why sync_encryption_key_hash is audit-only.
- Passport
Selective disclosure and L2 anchoring: proofs today, durable receipts tomorrow
SD-JWT property proofs vs credential dumps; Base mainnet anchoring as independent verification without our API online.
- Passport
Why mainnet inclusion—not a testnet hash—is the receipt
Why mainnet anchoring matters for third-party verification years later—Base, Viem, KMS, and verifying without calling us.
- Engineering
Progressive honesty in protocol design
Ship the narrow honest version first; encode the upgrade path in schema; never hide the gap in marketing prose alone.
- HumanOS
Safety that moves at business speed
Cross-SDK human.call, ML risk grounded in audits, and policy DSL in the Command Plane—compliance without a migration for every rule change.
- Vision
The sovereignty spine: identity without us in the middle
Passport, P2P sync, and guardian recovery are three implementations of one principle—HUMΛN is not the oracle for your keys, your vault, or your recovery secret.
- Architecture
Field notes: Connectors, muscles, and governed workflows
Three different roles — integration, governed execution, orchestration — not three names for the same thing.
- Architecture
Field notes: Why demo-grade workflow products fail in production
Demos optimize for speed; production needs identity, delegation, and provenance — not a bigger canvas.
- Operations
Field notes: Hosted to self-hosted without rewriting workflows
Same manifests and agents; only endpoints and bootstrap secrets change — zero-regret deployment.
- Architecture
Field notes: Sharing an AI workflow without hidden authority
Governed bundles expose scopes and install-time delegation — not ambient trust or credential zips.
- Transparency
Field notes: What a real decision receipt looks like
A receipt is a binding summary — policy, delegation, resources, provenance link — not a chat log.
- Developer
Agents as tools: governed capability discovery
Honest answers stack in three layers—installed agents, workforce humans, marketplace gap-fill—without bypassing delegation.
- Developer
An API designed for builders (and the AIs that help them)
First contact with HUMΛN should not be a dead end—discover, OpenAPI, and errors that teach instead of shrug.
- Developer
Building a Reference-Grade Market Intelligence Workflow on HUMΛN
How the Signals reference workflow was designed, what makes it a good example, and how to fork it for your own domain.
- Developer
CLI & SDK Scaffolding for HUMΛN Workflows — From Zero to Production in 15 Minutes
How the HUMΛN CLI, SDK helpers, and code generators cut workflow development from hours to minutes — patterns from the Signals implementation.
- Developer
Controlling execution lifecycle: pause, resume, and human authority
Pause is not cancel. When a run must yield to human judgment mid-flight, the platform should honor that without destroying progress.
- Developer
Workflows as Platform Extensions: Command Plane, Companion, and Workforce Cloud
How the HUMΛN manifest system turns a workflow into a full platform citizen — Command Plane surfaces, Companion actions, and Workforce renderers.
- Developer
Building human-in-the-loop workflows with the HUMΛN Workforce Module
From zero to a live work item in the inbox: declare renderers, configure routing, test with WorkItemTestHarness, and understand what the human sees.
- Architecture
Agents Should Learn. But Not Like This.
Useful agents get better over time — the failure mode is invisible drift, hidden memory, and policy smuggled in as vibes. HumanOS treats adaptation as a governed primitive.
- Architecture
Why Learning Belongs in the OS, Not in App Glue
If reasoning is a primitive, adaptation must be too — one feedback store, one proposal lifecycle, one rollback story. App-local shortcuts become shadow policy.
- Developer
Designing Learning-Enabled Workflows on HUMΛN
Declare feedback, memory scopes, proposals, and marketplace learning contracts — then wire the same REST + SDK paths your operators already audit.
- Architecture
Memory, Feedback, Adaptation, Capability: Stop Calling All of It ‘Learning’
Four words, four responsibilities. Collapsing them into one label is how teams ship ungoverned systems — and how audits fail.
- Architecture
Preferences May Adapt. Policy Must Be Explicit.
The doctrine line: tune UX and defaults; never smuggle compliance thresholds or routing gates as silent personalization.
- Architecture
How HUMΛN Signals Learns What Matters Without Getting Weird
Capture and Watch stay distinct; feedback is append-only; proposals and approval gate durable change — proof that a real workflow can use the whole primitive stack.
- Architecture
HumanOS artifacts and the “why am I seeing this?” bundle
Lifecycle vs chat tokens; explainability with policy_applied_id; FSM transitions that earn trust.
- Architecture
HumanOS Capture vs Watch — heard once, stewarded forever
Two verbs, two trust postures: one-time handoff vs durable attention. Modality through connectors, not per-agent spaghetti.
- Developer
From zero to governed agent — HumanOS CLI and scaffolding
Wave 7: human humanos-manifest validate and scaffold; why the CLI is co-equal product with the API.
- Architecture
HumanOS learning, tuning, and rollback — policy boundary
Feedback and tuning without silent policy erosion; fold-based effective state and org approval gates.
- Architecture
HumanOS policy: why this threshold is policy, not vibes
Fourth Law confidence as org policy, effective config, PUT /policy/org, and explainability hooks — magic first, inspectable always.
- Architecture
HumanOS primitives: Waves 0–1 — spec lock and foundation
Why we froze canon before schema work, how Capture differs from Watch in kb/22, and why dual-async unification is debt with a name.
- Business
Pay for the Engine, Not the Gas: Why HUMΛN Prices Trust—Not Tokens
The AI industry is figuring out how to stop subsidizing power users. Some platforms mark up tokens aggressively. Others hide costs until the bill arrives. HUMΛN does neither.
- Architecture
Agents Before and After a Trust Layer
Same request—reschedule my meetings, update my project board. Two worlds: OpenClaw-style vs HUMΛN-governed. The difference is identity, policy, and provenance.
- Vision
CT Scans, Corporate Docs, and Self-Hosted Giants
Three stories: healthcare data in the vault, enterprise data in your datacenter, and email branding with clear delegation.
- Architecture
From Identity to Resources: How HUMΛN Sees Your Data
Passport, profile, and brand are three different things. Here's how your data is organized—and who controls what.
- Architecture
Kinds & Namespaces: A shared language for people and agents
How HUMΛN uses one vocabulary—kinds and namespaces—so agents, connectors, and policies all speak the same language.
- Architecture
OpenClaw and the Cost of Skipping the Trust Layer
Always-on agents with real system access are here. What's missing isn't capability—it's governance.
- Architecture
Storage Without Databases: How Agents Persist Data Without Being DBAs
Agents declare what type of data they use. Policies and connectors decide where it lives. No connection strings, no table design.
- Architecture
What a “HUMΛN-Compliant Extension” Actually Means
Extensions are how agents get useful. A HUMΛN-compliant extension gets its power through HumanOS, Passport, and the Capability Graph—not around them.
- Perspective
When code becomes a commodity, trust becomes the operating system
The demo compiles on Friday. Monday, someone asks for the receipt. Cheap code did not remove accountability — it moved the bottleneck to Passport, HumanOS, and provenance.
- Developer
From Inline Strings to ctx.prompts: A Developer's Guide to HUMΛN Prompt Management
A hands-on walkthrough of HUMΛN's prompt SDK: authoring prompts, validating schemas, composing layers, publishing versions, and wiring telemetry — with code examples from real agents.
- Developer
The Developer Passport: From Sandbox to Production
How developers create and use passports. Zero-friction dev experience. The publish gate and why it matters.
StoryNobody Knows My Name. Everyone Trusts My Work.
I never gave them my name. I never gave them my email. A month later, I had 47 published tools and a verified reputation nobody could take from me.
- Architecture
Protocol-Level Prompt Management: Why AI Prompts Deserve First-Class Identity
Prompts get URI identity, delegation scopes, and rollback—so Monday’s incident has a version to revert, not a mystery string.
- Architecture
The Self-Improving Prompt Loop: How Telemetry Closes the Gap Between Good and Great
Support says the summarizer got worse last week. Without prompt identity and telemetry, you have anecdotes—not a version to roll back. HUMΛN closes that loop with human-gated refinement.
- Architecture
The Validity Ladder: How Trust Grows
Progressive verification explained. Each layer, real scenarios, and why we don't demand everything upfront.
- Security
Why Modified Code Can't Forge Identity
The self-hosted security model explained. Cryptographic enforcement, device attestation, and why open source makes this more secure.
- Vision
Your Identity, Your Rules
What makes HUMΛN Passport different from every other login. Why owning your identity matters.
- Vision
Introducing HAIO — the category for trust between people and AI
Friday’s agent demo works. Monday, security asks who acted under which grant. HAIO names the systems built backwards from that question — identity and receipts first, model choice second.
- Business
The Agent Marketplace: Platform Economics for HAIO
Why HAIO needs a marketplace, four contribution types, the ecosystem flywheel, and how builders earn — with honest shipped-vs-building labels.