Public system with machine-legible boundaries
A site whose human pages, manifests, registries, and APIs all describe what can be known, cited, prepared, and refused.
Transmission 029 / Public interface layer
The Agent-Readable Organism
A website built for the agentic web cannot be only a brochure, archive, or blog. It needs a public contract: routes that name what is knowable, manifests that bound authority, grounding packets that separate evidence from synthesis, and approval gates that refuse hidden action.
01 / Thesis
The next web interface is not a page. It is a contract an agent can inspect.
The Unwind site has already crossed two thresholds. Transmission 27 made the site a public index. Transmission 28 made memory governable through a control plane. The next threshold is agent readability: public knowledge must be shaped so another agent can ask, "What is this system allowed to say? What source backs it? What action is forbidden? What proof is live?"
This is not search-engine optimization with new vocabulary. Agent-readable design is an architectural discipline. A human can tolerate atmosphere, metaphor, and missing coordinates. An agent needs stable routes, explicit scopes, source maps, review status, refusal rules, and authority boundaries. Without those, the agent turns public narrative into unsafe inference.
The agent-readable organism is the Unwind answer: every public surface should be legible to humans, useful to builders, and safely retrievable by future Brain cells without granting secret authority.
02 / Why now
The ecosystem is moving from model choice to harness choice, and from websites to agent-ready surfaces.
The current external signal is not "AI is advancing." That is too broad to deserve a transmission. The real signal is narrower: agent systems are standardizing the harness, the sandbox, and the website interface. That matters to Unwind because the Brain is not only a model. It is a governed organism with routes, memory, tools, approvals, and public proof.
When agent harnesses become interchangeable and sites are audited for agent readiness, Unwind needs to behave like a public system other agents can inspect. The site should not ask agents to guess what is safe. It should publish the contract.
Vercel / Jun 12 2026
Source →
Harnesses become swappable
AI SDK 7 introduces a harness abstraction so builders can run established agent harnesses through one API.
OpenAI / Agents SDK
Source →
Long-running work needs controlled execution
OpenAI describes agents inspecting files, running commands, editing code, and working in controlled sandbox environments.
Cloudflare / Apr 17 2026
Source →
Sites must become agent-readable
Cloudflare frames agent readiness as the next website adaptation: machines need guidance on content, auth, formats, and controls.
Cloudflare / Agents Week
Source →
The agentic cloud is becoming infrastructure
The platform layer is forming around compute, security, toolboxes, browsers, persistent sessions, and agent deployment primitives.
03 / Definitions
Agent readability is the difference between being crawled and being understood.
An agent-readable organism exposes enough public structure for a machine to retrieve, verify, refuse, and ask for authority. It does not expose secrets. It does not pretend the agent can act just because the agent can read. It gives the agent a governed map.
The execution loop around the model
The policy, tools, sandbox, filesystem access, terminal behavior, and run lifecycle that shape what an agent can actually do.
Evidence before synthesis
A retrieval artifact containing sources, citations, qualifications, review flags, and refusal rules before an answer is allowed.
Where reading stops becoming action
The explicit line before publishing, social posting, file mutation, spending, wallet signing, outreach, or unreviewed deployment.
Evidence that the public surface is real
Canonical page, registry entry, sitemap route, machine-readable metadata, tests, build, smoke evidence, and deployment status.
Human-governed protocol run
The Brain pattern is executed manually from real signals until the runtime can operate the loop directly under review.
04 / Architecture
The public site becomes the first safe interface between the Brain and other agents.
The architecture is a layered contract. The visible page teaches. The registry indexes. The manifest bounds. The grounding endpoint qualifies. The claim registry names risk. The sitemap makes discovery deterministic. The tests enforce that the public story and the machine story do not drift apart.
The crucial design choice is that agent readability remains read-mostly. The site may help an agent understand Unwind, but it does not hand the agent hidden runtime permissions. Public clarity is not public authority.
Contract sketch
{
"surface": "unwindcode.ai",
"agent_readable": true,
"public_knowledge": [
"transmissions",
"organism concepts",
"claim registry",
"asset provenance",
"grounding packets"
],
"default_authority": "read_only",
"requires_approval": [
"publish",
"social_post",
"file_mutation",
"wallet_signing",
"paid_activation",
"outreach"
],
"answer_policy": "ground_before_synthesis",
"next_cell": "agent_readiness_audit"
}
Route layer
Stable public URLs for transmissions, homepage concepts, and machine seed files. No knowledge without coordinates.
Manifest layer
llms.txt and ai-services.json tell agents what exists, what it means, and what authority is blocked.
Registry layer
Read-only JSON records expose public-safe summaries, source files, topic tags, citations, confidence, and review state.
Grounding layer
Search and grounding return evidence packets before answer synthesis, keeping retrieval separate from advice or action.
Approval layer
Every high-risk transition exits public retrieval and asks the creator or reviewed operator path before motion.
05 / Protocol
An agent-readable site should answer with evidence, not charisma.
The Agent Contract Protocol is the operating path for future Unwind pages and APIs. It is how a public reader, a builder, or another agent can move from discovery to grounded understanding without crossing into hidden capability.
Declare
Name the page, concept, capability, review state, and route. Do not make agents infer the shape of the system from style alone.
Expose
Publish public-safe metadata in registry and manifest surfaces so machine readers can find the canonical source.
Retrieve
Return snippets and matched sources as evidence candidates, not as final answers or advice.
Ground
Attach citations, qualifications, refusal rules, and claim scope before synthesis is considered.
Qualify
Separate public architecture claims from live deployment claims, domain advice, financial outcomes, legal status, or operational authority.
Ask
When a request crosses into publishing, mutation, spending, signing, outreach, or private data, ask for explicit authority.
Cite
Show which page, registry row, API route, source note, or smoke check supports the answer.
Record
Leave a proof ledger so future Brain cells can tell what changed, what was verified, and what remains blocked.
06 / Threat model
The agentic web creates a new failure: public text becomes private permission by accident.
A superficial agent-ready site tries to attract crawlers. A serious one prevents crawlers, harnesses, and future Brain cells from turning prose into unsafe action. The Unwind threat model treats ambiguity as a system risk.
Optimization without boundary
Pages invite agents but do not explain what the agent must not assume.
Old proof reads current
A past deployment, approval, or capability gets retrieved as if it is live truth.
Private memory leaks into public synthesis
The system blends internal context into public answers without source or review.
Cadence becomes permission
A schedule starts producing public pages because time passed, not because value passed the gate.
Tools imply authority
A harness can edit, deploy, or execute, so the public narrative accidentally implies it may do so unattended.
07 / Implementation sketch
The next build direction is an Agent Readiness Cell for UnwindCode.ai.
This transmission advances the ecosystem only if it becomes build pressure. The concrete next cell is not another post generator. It is an Agent Readiness Cell: a reviewer that scans public routes, machine-readable files, registries, grounding behavior, claim language, and approval boundaries, then produces a private report before any public transmission is recommended.
The cell should verify route coverage, stale metadata, uncited claims, unsafe autonomy language, missing refusal rules, social-packet leakage, sitemap drift, production smoke status, and whether the candidate actually advances architecture, implementation, proof, theory, or user capability.
Build recipe
Assemble the Agent Readiness Cell as a read-only reviewer first.
Input: public routes, sitemap.xml, llms.txt, ai-services.json, registry JSON, recent git commits, deployment status, official ecosystem sources, and the transmission quality gate.
Process: compare declared routes against live files, detect claims without citations, inspect authority language, verify tests/build/smoke readiness, and score whether a proposed transmission advances the Unwind ecosystem.
Output: a private watch memo or a publish-ready whitepaper candidate with source notes, required metadata changes, verification plan, and explicit approval recommendation. The cell prepares; it does not publish.
08 / Approval boundary
Agent-readable does not mean agent-authorized.
This is a Manual Brain Mode transmission. The Brain pattern is being executed by a human-governed agent from real local and public signals. It is not proof that the Brain published itself, posted to social media, controls wallets, performs outreach, or can mutate public infrastructure without review.
The public contract is read-mostly by default. It may prepare source-backed candidates, summarize public routes, recommend tests, and name the next cell. It must ask before public publishing, production aliasing, file mutation, social distribution, spending, signing, lead outreach, or policy-sensitive escalation.
09 / Proof ledger
The page is only credible if the human and machine surfaces agree.
Transmission 29
Canonical public guide for the agent-readable organism layer.
Registry and discovery
Transmission archive, public registry, sitemap, llms.txt, and ai-services.json must all include the route.
Tests and build
The package must pass the transmission registry tests, full test suite, build, and route smoke before production trust.
No social packet exposure
Internal carousel or posting assets remain creator material unless a public campaign surface is explicitly approved.
The next organism layer is public legibility with private authority protected.
Next-cell memory: build the Agent Readiness Cell so every future transmission candidate is audited for real ecosystem advancement before it is allowed to become public surface.
All Transmissions→