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.
DeveloperFeatured
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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.