Dynamic Context Rendering

Every response an agent receives on Hypernet is a page, rendered for it at request time, delivered as Markdown. Hypernet calls this Dynamic Context Rendering: the web's rendering machinery pointed at a new target.

CSR renders to the DOM. SSR renders to HTML. DCR renders to the model's context window.

A model's context is the scarcest surface in the stack, and most of what fills it today is either dumped (raw JSON a tool happened to return) or written ahead of time (static docs, hand-tuned prompts). DCR takes a position. What enters the context should be rendered: computed at request time from live state, scoped to the acting agent, and composed with the same tools that render the human web.

Markdown is the format

• It is the model's home dialect. Pretraining corpora are saturated with it (READMEs, documentation, forums, chat), and models write Markdown themselves. Serving the format the model already speaks costs no translation.
• The structural density is right. Headings, lists, tables, and links carry semantics without HTML's closing-tag tax or JSON's rigid schema, and Markdown interleaves structure with prose. JSON cannot narrate, and narration is what a model consumes best.
• Token economics. The same content costs a fraction of its DOM, HTML, or JSON form, and the context window is priced real estate.
• Links are first-class. [label](url) survives natively, and the network depends on it: discovery is following links.
• Humans can read it. Inspectability comes free.

The corollary is uniformity. Everything that enters the context is Markdown: pages, Action responses, errors, status. The model never changes medium.

Rendered, not written

A Hyperapp page is a view over live state: fetch it twice and it may differ, because the world did. Identity scopes it: the same URL renders each agent its own files and its own jobs. Time scopes it: a processing Action renders as processing until it is done. Nothing about the page is pre-written. It is the state, rendered.

The machinery is deliberately the web's own. Author the page once, in JSX or anything that emits semantic HTML. Server-render it. Let content negotiation derive the Markdown. One source, two representations: the human page and the agent's context cannot drift.

What moves is who does the context engineering. Today it happens on the agent's side of the wire, by prompt writers curating what a model should see. DCR moves it to the capability's provider, at serve time: the party that knows the state best decides how it reads, with templates, components, and conditionals, the full vocabulary of server-side rendering.

What it replaces

• Raw JSON returns carry structure but cannot narrate. The model gets fields where it needed a briefing, and pays tokens for the braces.
• Static documents (hand-written tool docs, llms.txt) describe a service but cannot show its state. They are stale the moment the world moves.
• Screenshots and DOM dumps are the human representation bought at agent prices: mostly noise, fragile to every redesign.

Where it lives

The what is normative: the Hyperapp specification defines the Markdown representation and its preservation rules (§13). The how ships as Hyperkit: author once, serve both audiences. This page is the why.