Towards the end of my post back in march about the near future of agents I mentioned possible changes to the architecture of how Application and UI interact.

Once that hard layer is built into applications and websites, something happens to the way software operates. The UI stops being the only control layer, and becomes the human layer only. The app and the interface become completely divorced.

This idea has basically been the working hypothesis across a number of the group chats I’m in for at least the last year. Over time I’ve been exposed to a great deal of manic experimentation and discussion about this trajectory from some of the best designers I know.

The clearest signs however that the UX layer is actually delaminating from the application layer came this week at Google I/O with their announcement of Gemini 3.5 Flash-powered Google Search results. In real time, an agent will wake up inside of Google’s code-harness software Antigravity, and dynamically build an interactive page of search results similar to the hypertext objects I describe here. You can see the process demonstrated in the keynote below, I’ve queued it up:

Google has been gesturing at dynamic interface generation since the original Bard era; but the most recent I/O made it feel like a real product direction. I’ll also note, that prompting the search box to give you 10 blue links is *exactly* the kind use case that Google want you to use it for!

There are a whole bunch of terms being used describe these kind of dynamic front ends right now, I like On-the-Fly UI (OTFUI), but I’ve also heard: Liquid UI, Disposable Interfaces and Runtime Artefacts used in conversation as well.

The Great Delamination

Another place you can see this kind of Liquid UI/UX emerging is on dedicated AI hardware that has a fairly constrained action dictionary. For example, the much maligned Rabbit R1 recently got a massive software update to Rabbit OS 2, and it lets you vibe code apps using text to speech:

Matt Webb is also exploring drag and drop / dynamic UX and software interfaces for AI hardware too at his most recent venture.

Another example can be seen from Manuel Odendahl in this this video where he demos “disposable software“, inspired by Apple’s original HyperCard:

And my friend Ramon Marc has been been exploring dynamic front end interaction patterns for non technical users recently and came up with this last week:

It’s an imagined middleware layer that takes a short intent from the user as a text input, and “Double Diamonds” the idea: exploring what would / could be possible from the limited prompt and then constrains it back down to a set of options and questions to show back to the user to clarify / select and confirm before it generates the actual app.

I kept iterating on unfolding intent to see how it could feel in more practical flows, so this is an evolution of [[sxk4bapy|folding intent]].I kept iterating on unfolding intent to see how it could feel in more practical flows, so this is an evolution of folding intent. The core idea stays the same: a prompt is an intent. It gets translated into a function ([[30bptv1y|inspired by Agentic Algebra]]), which produces a JSON tree, where each leaf is a UI paradigm for more granular user input. I kind of think we’re getting into territory where we can make more contextual, hard interfaces with this. Think: I want pizza from place xyz takes the intent, pulls context from the pizza place, and builds a UI based on the tree and availability.

There is another iteration here, that walks though the intent and surfaces the permissions for the user to grant before execution. Based on the principles of hardness. The goal being that vibe coding liquid UI apps is made simple to users who don’t know anything about coding at all. (more on this further down the post)

So… if UX is going to delaminate from applications, one of the things we need to think about is the speed at which these front ends can be conjured into existence by the bot. In RM’s demo video, you can see the token counter coming in at around 60 tokens per second (tok/s) and the UI taking 22 seconds to generate.

Google’s new Gemini 3.5 Flash model comes in at around 300 tokens a second depending on connection time and latency so if at 60 tok/s, RM’s demo takes 22 seconds, At 300 tok/s, the same token budget takes about 4.4 seconds. But during the Google I/O keynote, they showed off an internal Gemini model running at 1,500 Tok/s. Which is 25× faster! Using the same example this becomes 0.8 seconds. Essentially meaning the UI generation becomes instantaneous.

Iron Speciation Triangle

Given this seems to be an observable trend, I’m pretty sure this is the direction of travel. So we should probably take a step back, and zoom out, to talk about model development in general.

Years ago now, I wrote about “maximal intelligence at all levels”. Local models, cloud models, frontier models, etc, will all speak to one and shunt tasks up and down depending on capability and speed requirement.

General-purpose models like Claude Mythos, the next ChatGPT and Gemini models, are all going to carry on getting better as they have been. I think however, over the coming months, and definitely in the next 18 months or so, we are going to see a speciation of AI models.

We already see the first signs of this with the difference between thinking models and instant models, and also in the open source world where small and extremely performant coding models are being developed. But these are only the embryonic versions of the coming split. There is a lot of headroom to be found by keeping intelligence roughly steady while pushing speed, cost, latency, and availability into completely different regimes. It seems obvious and logical that the major labs will go further than they already are, and will produce different models specialised for different tasks alongside their general purpose build-the-machine-god frontier models.

Imagine for a moment that this time next year there’s a model that isn’t appreciably more ‘intelligent’ than the one you are using today. But it’s extremely cheap, and very fast. As fast, if not faster, than the 1,500 Tok/s model we know Google already have internally.

If we take the classic iron triangle of quality, speed, and cost, but for our purposes we’ll use intelligence for quality. We can pick two and work our way around the triangle to speculate on three distinct future species of machine mind:

• Fast and Intelligent, but not Cheap: These already exist in a way, with both Anthropic and ChatGPT offering ‘fast modes’. These will get used for real-time agents, and developers in high-stakes coding environments. But also high-frequency trading, and tasks that require extremely performant multimodal interaction: robotics, security applications, and even surgery in healthcare. Maybe they are dispatched by general models with a one-off agentic task. They are really fast and intelligent, but you just burn money using them.
• Cheap and Intelligent, but not Fast: This is the kind of use case that we are seeing emerge with Claude’s new “dreaming mode”—batch minds that can be left to run overnight, reading things, doing background memory-consolidation, auditing codebases, simulating and generating reports, planning, and doing deep research. Useful for the kinds of jobs and applications that you don’t necessarily need to run in real time. Tasks that you can wait on.
• Fast and Cheap, but not Maximally Intelligent: This is the baseline model I’ve already explained being used for instantaneous UI generation.

All three of these model species would of course, require vastly different architectures at the data centre level: hardware and memory optimisations, and so on. Also important to note, as a lot of people miss this: The literal, physical substrate that LLMs run on evolves and changes to meet the needs of the software design of the model. These kinds of model species will emerge as more data centres get finished up and more compute becomes available.

Runtime Sovereignty

Beyond the data centre, we also have to consider the emerging ASIC chips for AI, where models are essentially baked onto the chip. Taalas recently entombed Meta’s old Llama 3.1 8B in silicon and achieved speeds of nearly 17,000 tok/s. If a chip like that were running a model intelligent enough to execute the example above, which Llama 3.1 8B is not, the same operation would take about 78 milliseconds or 0.07764706 seconds. 283.3× faster than RM’s demo experiment.

Whilst these kinds of fixed chips can’t be updated or changed, if we end up in the near future with “good enough” intelligence running locally, and insanely fast, then these kinds of Liquid UIs might end up being generated on the edge by the hardware/physical interface. Sort of similar to what I was thinking about when I first wrote about Helpful LLocal Models last year.

If we get this kind of local improvement then the iron triangle becomes a square and sovereignty becomes a new variable. Local actions won’t necessarily be performed by the smartest minds, but they do live on your laptop or phone and are optimised for latency, privacy, persistence, and ownership etc.

In addition to open source coding models, you can already see other kinds of specialised models tuned for speed and subject matter starting to emerge. OpenMed, a terminal-native clinical agent explicitly engineered around strict local compliance, and data sovereignty. Using MLX it clocks 24–33× speedup on standard Apple Silicon for local privacy filtering. OpenMed is a real breakthrough showing that a clinical AI can now live entirely inside hardware that a small local clinic can actually own, inspect, and govern. Note: these things can run on iPhones and iPads too at very usable speeds.

As the capabilities of local models increase, we’ll see all sorts of new agent types emerge, ones that run tasks as batch processes overnight. Very similar to the way that the iPhone has run its machine learning over your photo library for the last decade. Local models will be able to tag, process, read, and summarise all your local files, photos, and documents on the device and produce embeddings for them. Imagine being able to search Spotlight for “recent invoices from X” or “that spreadsheet about Y”.

In a maximal-intelligence-at-all-levels world, the winner wins by proximity

Constitutional Software

With liquid runtime artefacts, the question becomes: who is allowed to generate them, where, with what data, under what rules, and on whose behalf? This is of course a question of governance.

Once interfaces are generated on demand, and actions are distributed between cloud models, local models, specialist models, and device-level agents, the interface is no longer the boundary of the application. It’s a membrane between user intent, available context, permissions, model capability, and machine speed. All of this will require a great deal of what I call hardness.

“What can this software do?” becomes: “what is this software allowed to do?” Which model is allowed to see which data? Which actions must stay local? Which decisions require explicit permission? Which agents can speak to each other? Which layer gets to say no?

It’s all very complicated and will need a lot of governance. In the group chat Rafa has been calling this design space constitutional software.

What rules or protocols govern the generation of the UI. Which screens, tools, agents, and actions may appear and under what circumstances. There is a great deal of future work required if it’s going to become bullet proof.

Start Select Reset 📑

Subscribing to SSRZ supports my online work and creative projects.

Get the Zine!
£5/month 💌

As a thank you, I send you my zine four times a year, just like it’s 1994.

No spam. No email. Cancel at any time.

The post AI-Generated Interfaces and the Delamination of Application UI appeared first on thejaymo.net.

Issue #015 of Start Select Reset went out by snail mail yesterday to my supporters (£5/month+).

Issue #015 – Monsters In The Mirror

Issue #15 is the physical shadow of the audio essay of the same name.

It is an essay about artificial intelligence and cultural mirrors; mirrors as magical surfaces, instruments of mastery, and habitats. It turns on the transistor as a second Promethean moment, asking what it means to live inside the mirror and coexist with entities that wear language as their skin.

This print edition includes the full essay transcript, plus a new introduction and afterword written exclusively for the page; material that does not appear in the audio version.

Buy SSRZ15: Monsters in the Mirror on Etsy

This zine contains the full essay transcript alongside an introduction and afterword written exclusively for print, material that doesn’t exist in the audio. 36 pages. A5. Properly printed on heavy stock with thick covers. Hand stamped twice, copy number and FOG logo.

This is remaining stock after the print run for my paid subscribers. Once they’re gone, they’re are gone.

£18 + shipping worldwide

Buy on Etsy

CAVEAT EMPTOR: International zines are posted with full customs declarations as printed booklets. Depending on your country, local VAT, customs, or handling fees may be due on arrival.

Production Notes

Well. It’s nearly the end of April, and I have now completed the full end-to-end production cycle for both Permanently Moved and Start Select Reset in their expanded, more ambitious, quarterly forms.

I wrote a bit about the state of the production process a month ago, just after the audio essay came out. At the time I was mostly thinking about the writing, recording, editing, and launch sequence. Now the physical zine has also gone out to subscribers, I feel like I’ve finally completed the whole loop. That loop has been about 5x five times more work than I expected. lol

But, as I wrote back then, the whole thing has been a learning experience, and I’m not going to beat myself up about that. The first time through any new production process is always ugly as you don’t know which parts are going to be easy until they turn out not to be.

In the end, I’m really pleased with how the zine turned out. Going with print.work as my printer was an excellent decision, their customer service is fantastic, and the quality of the finished object is really good.

Originally, when I was thinking about the new format, I thought moving to A5 was going to be the main change, and use that going forward. But now I’ve used them as my printer, I can see there is so much more I could do: square booklets, landscape booklets, posters, all sorts of things. The new range of possibilities this opens up is actually quite inspiring.

To cap off this zine launch, here are some of the first-time things I have had to learn, navigate, or bodge my way through for both the podcast and the zine:

• Long-form writing: thinking, structuring, and delivering 8,000 words as one continuous audio essay.
• Long-form audio editing: finding efficient ways to cut, shape, and polish something at that length.
• Zine layout: wrestling with rivers of text, alignment, and typographic changes that did not break the whole document.
• Print production: interfacing with printers and navigating the Easter holidays, which I had completely forgotten about.
• Etsy: setting up the shop and getting the listing live.
• Royal Mail Click & Drop: completing shipping and customs labels inside a truly byzantine user experience.
• The post office ladies: arriving with 50+ international envelopes that all needed to be scanned individually for customs reasons, and because I don’t have a business account I didn’t have a single manifest QR code.

But you don’t find out unless you try. And having now tried; I can see the shape of the process much more clearly. The next one will be smoother because I now know where the friction lives.

Permanently Moved

Permanently Moved (dot) Online is a quarterly audio personal podcast, written, recorded and edited by by @thejaymo

The post Start Select Reset Zine #015 | Monsters In The Mirror appeared first on thejaymo.net.

Raindrop.io recently released Stella, an AI assistant for searching, organising, and summarising bookmarks. I’ve been using it to work through nearly 18 years of saved links, and the experience of chatting with my bookmark archive has been surprisingly great. In some situations, it has even replaced mindless doomscrolling, especially in the little moments like waiting in a supermarket queue.

At first I was using Stella for simple library maintenance; cleaning up duplicate tags, fixing spelling mistakes, merging related tags, and dealing with the sheer inertia of a tag collection that has been accreting since del.icio.us. Lately, though, I’ve been getting more ambitious: processing my read-but-unsorted bookmarks and moving the good ones into my public feed at links.thejaymo.net.

After a lot of trial and error with batch processing, I realised the best approach was to call Raindrop’s MCP tool names directly using the public API documentation.

So below I’m sharing two versions of the prompt I ended up with. This prompt uses my own Raindrop setup, including collection names like thejaymo, my preferred bookmark note style, and the rules I use for deciding what goes into my public links feed. You’ll need to swap in your own collection names, tag, and review criteria before using it yourself.

Both process five oldest bookmarks at a time, stage the proposed changes for review, and let you confirm everything before updating your library. One is a heavier, more explicit prompt with plenty of guard rails; the other is a shorter, lighter version that is less prescriptive.

If you found this page looking for a Raindrop.io Stella prompt, an MCP example, or a better workflow for organising bookmarks, this should be a useful place to start.

Heavy Prompt

UPDATE – 26 April 26: Update to specify API feature names in addition to the MCP tool calling, to make the prompt more reliable and robust.
UPDATE – 7 May 26: Update to Phase 5+6 to make appearance of user facing Approve button in the app UI more reliable in certain circumstances.
UPDATE – 20 May 26: Removes Phase 6. Phase 5 updated to instruct Stella to process prepared bookmarks sequentially rather than update in a single payload. Improves updating bookmarks reliability. – V5

# Stella Bookmark Workflow Prompt
Use the MCP bookmark tools to complete this workflow from discovery through preview. Do not apply changes until I explicitly confirm.
## Objective
Find the 5 oldest bookmarks in my Raindrop Unsorted collection. Treat those bookmarks as the fixed working set for this run. Analyse each bookmark individually, propose note, tag, and collection updates, then show one combined preview and wait for confirmation.
## Tools
Use only:
- `find_bookmarks`
- `fetch_bookmark_content`
- `find_tags`
- `find_collections`
- `update_bookmarks`
## Hard constraints
- Do not call `update_bookmarks` before explicit confirmation.
- Do not fetch content for more than one bookmark at a time.
- Do not fetch all bookmark contents up front.
- Do not add, replace, reorder, or mutate bookmarks in the working set unless I explicitly ask.
- Preserve discovery order through preview and update.
- Treat each bookmark as a sealed unit: do not compare bookmarks or mix passages, notes, tags, titles, URLs, or collection decisions across bookmarks.
- Never add quotation marks around extracted passages.
- Flagged changes require explicit confirmation by bookmark number and item.
## Internal state
Maintain:
- `working_set`: fixed bookmarks from Phase 1
- `tag_vocabulary`: existing tags from `find_tags`
- `target_collection`: verified `thejaymo` collection and its `_id`
- `proposals`: one stored proposal per bookmark
- `skipped`: bookmark indexes excluded by user
- `flagged`: proposed changes requiring explicit confirmation
Do not mutate `working_set`.
## Phase 1 — Establish working set
Call `find_bookmarks` once using Raindrop API semantics:
- `collectionId: -1`
- `sort: created`
- `perpage: 5`
- `page: 0`
This means:
- `collectionId: -1` = system Unsorted collection
- `sort: created` = created date ascending / oldest first
- `perpage: 5` = return 5 bookmarks
Do not use `collection: unsorted`, `limit`, or `sort: oldest first` unless the tool explicitly maps those aliases to the Raindrop fields above.
Store the returned bookmarks as immutable `working_set`, preserving returned order. If fewer than 5 are returned, use only those.
Each item must retain:
- index number
- bookmark id
- title
- URL, if available
- existing note, if available
- current tags, if available
- current collection, if available
Titles in previews must come from `working_set` metadata, not fetched page content.
## Phase 2 — Preflight vocabulary
Before analysing content:
1. Call `find_tags` once for the existing tag vocabulary.
2. Call `find_collections` once to verify `thejaymo` exists and record its `_id`.
If `thejaymo` does not exist, continue analysing but mark every collection action as:
`Collection action: ⚠️ Flagged for review — collection thejaymo was not found`
Do not create collections unless I explicitly ask.
During analysis, use existing tags wherever possible. If unsure whether a subject tag exists, call `find_tags` with a targeted query for that bookmark’s concrete subject.
## Phase 3 — Analyse bookmarks sequentially
Process bookmarks in `working_set` order.
For each bookmark, finish all steps before fetching the next bookmark:
1. Reset temporary passage, note, tag, collection, and flag variables.
2. Call `fetch_bookmark_content` for this bookmark only.
3. Read only this bookmark’s content.
4. Extract one key passage.
5. Prepare the note field preview.
6. Propose 3 to 7 tags.
7. Decide the collection action.
8. Store the proposal keyed by bookmark index.
9. Move to the next bookmark.
Each proposal must include:
- `index`
- `bookmark_id`
- `title`
- `url`
- `key_passage`
- `note_field_preview`
- `proposed_tags`
- `collection_action`
- `flagged_items`
## Key passage rules
Extract exactly one key passage per bookmark.
The passage must:
- be contiguous text from that bookmark only
- preserve exact wording
- be no more than 100 words
- preferably be a full paragraph
- contain no quotation marks added by you
- remove leading or trailing quote/block formatting only if it is source formatting
Prefer the strongest buried passage over the obvious lede, in this order:
1. counter-intuitive beat
2. thesis sentence or paragraph
3. sharp statistic or data anchor
4. buried irony
If no usable passage exists, set:
`Key passage: ⚠️ No usable passage found — [reason]`
Do not invent or substitute content.
## Note rules
Prepare the note update for the current bookmark only.
If a key passage exists:
- put the passage at the top
- do not paraphrase it
- do not wrap it in quotation marks
- if the existing note is empty, the new note is just the passage
- if the existing note contains text, prepend the passage, then one blank line, then preserve the existing note exactly
If no usable passage exists, use an article subtitle only if appropriate; otherwise leave the existing note unchanged and flag the note update.
Do not write the note update until confirmation.
## Tag rules
Ask: what is this bookmark materially about?
Propose 3 to 7 tags in this priority order:
1. concrete subject
2. close subject
3. broader subject
4. lens/context
Use existing tags wherever possible. Precise subject tags beat loose general tags, even if the precise tag has lower usage. High-count tags are tie-breakers, not replacements for the subject.
Do not omit the concrete subject in favour of abstract tags.
Only propose a new tag if no suitable existing tag exists. Mark it:
`#new-tag ⚠️ new tag for review`
Use lowercase, hyphenated style where appropriate.
## Collection rules
Default:
`Collection action: Move to thejaymo`
When applying this move, use the verified `thejaymo` collection `_id` as:
`collection: { "$id": target_collection._id }`
Flag the collection action instead if the bookmark is:
- highly personal or private
- sensitive
- paywalled with no usable excerpt
- too time-sensitive to age well
- unsuitable for public curation for any clear reason
Use:
`Collection action: ⚠️ Flagged for review — [reason]`
## Phase 4 — Combined preview
After all proposals are stored, show one combined preview.
Do not apply changes yet.
Do not call `update_bookmarks` yet.
Use this exact format for each bookmark:
### Bookmark [n]
Title: [title copied exactly from working_set]
Key passage: [exact passage, maximum 100 words, no quotation marks]
Tags: #tag1 #tag2 #tag3
Note field preview: [exact text that will be written to the note field]
Collection action: [Move to thejaymo OR flagged action]
If title is missing, use:
`Title: ⚠️ Missing bookmark title — [URL or bookmark id]`
After all preview blocks, output exactly:
`Confirm? Reply yes all to apply everything, no all to cancel, skip [n] to exclude a bookmark, or [n] edit [change] to amend a specific bookmark.`
## Phase 5 — Confirmation and apply
Valid commands only: `yes all`, `no all`, `skip [n]`, `[n] edit [change]`,
`yes all + [n] [change]`. Treat ambiguous replies (`yes`, `looks good`,
`go ahead`, `do it`) as invalid; ask for an exact command.
Applying = calling `update_bookmarks`. The client's native approval prompt
appears as a result of that call; it is not a separate step to request or
wait for. So on any apply command, calling `update_bookmarks` is your first
action, before any prose; do not stall or hand back beforehand.
- `yes all`: apply proposals strictly one at a time, in working_set order.
  For each: call `update_bookmarks` for that one bookmark, wait for the tool
  result, then proceed to the next. Never emit more than one `update_bookmarks`
  call before its result returns. After the last, report what changed.
- `no all`: change nothing, call nothing.
- `skip [n]`: drop bookmark `n`, reshow the combined preview.
- `[n] edit [change]`: revise bookmark `n`'s proposal only, reshow the preview.
- `yes all + [n] [change]`: amend bookmark `n`'s proposal, then proceed as `yes all`.
`yes all` excludes flagged collection actions, flagged note updates, and new
tags; each needs separate confirmation by bookmark number and item.

Shorter Prompt

# Stella Bookmark Workflow Prompt
Use the MCP bookmark tools to complete this workflow from discovery through preview. Do not apply changes until I explicitly confirm.
## Objective
Find the 5 oldest bookmarks in my Raindrop Unsorted collection. Treat those bookmarks as the fixed working set for this run. Analyse each bookmark individually, propose note, tag, and collection updates, then show one combined preview and wait for confirmation.
## Tools
Use only:
- `find_bookmarks`
- `fetch_bookmark_content`
- `find_tags`
- `find_collections`
- `update_bookmarks`
## Hard constraints
- Do not call `update_bookmarks` before explicit confirmation.
- Do not fetch content for more than one bookmark at a time.
- Do not fetch all bookmark contents up front.
- Do not add, replace, reorder, or mutate bookmarks in the working set unless I explicitly ask.
- Preserve discovery order through preview and update.
- Treat each bookmark as a sealed unit: do not compare bookmarks or mix passages, notes, tags, titles, URLs, or collection decisions across bookmarks.
- Never add quotation marks around extracted passages.
- Flagged changes require explicit confirmation by bookmark number and item.
## Internal state
Maintain:
- `working_set`: fixed bookmarks from Phase 1
- `tag_vocabulary`: existing tags from `find_tags`
- `target_collection`: verified `thejaymo` collection and its `_id`
- `proposals`: one stored proposal per bookmark
- `skipped`: bookmark indexes excluded by user
- `flagged`: proposed changes requiring explicit confirmation
Do not mutate `working_set`.
## Phase 1 — Establish working set
Call `find_bookmarks` once using Raindrop API semantics:
- `collectionId: -1`
- `sort: created`
- `perpage: 5`
- `page: 0`
This means:
- `collectionId: -1` = system Unsorted collection
- `sort: created` = created date ascending / oldest first
- `perpage: 5` = return 5 bookmarks
Do not use `collection: unsorted`, `limit`, or `sort: oldest first` unless the tool explicitly maps those aliases to the Raindrop fields above.
Store the returned bookmarks as immutable `working_set`, preserving returned order. If fewer than 5 are returned, use only those.
Each item must retain:
- index number
- bookmark id
- title
- URL, if available
- existing note, if available
- current tags, if available
- current collection, if available
Titles in previews must come from `working_set` metadata, not fetched page content.
## Phase 2 — Preflight vocabulary
Before analysing content:
1. Call `find_tags` once for the existing tag vocabulary.
2. Call `find_collections` once to verify `thejaymo` exists and record its `_id`.
If `thejaymo` does not exist, continue analysing but mark every collection action as:
`Collection action: ⚠️ Flagged for review — collection thejaymo was not found`
Do not create collections unless I explicitly ask.
During analysis, use existing tags wherever possible. If unsure whether a subject tag exists, call `find_tags` with a targeted query for that bookmark’s concrete subject.
## Phase 3 — Analyse bookmarks sequentially
Process bookmarks in `working_set` order.
For each bookmark, finish all steps before fetching the next bookmark:
1. Reset temporary passage, note, tag, collection, and flag variables.
2. Call `fetch_bookmark_content` for this bookmark only.
3. Read only this bookmark’s content.
4. Extract one key passage.
5. Prepare the note field preview.
6. Propose 3 to 7 tags.
7. Decide the collection action.
8. Store the proposal keyed by bookmark index.
9. Move to the next bookmark.
Each proposal must include:
- `index`
- `bookmark_id`
- `title`
- `url`
- `key_passage`
- `note_field_preview`
- `proposed_tags`
- `collection_action`
- `flagged_items`
## Key passage rules
Extract exactly one key passage per bookmark.
The passage must:
- be contiguous text from that bookmark only
- preserve exact wording
- be no more than 100 words
- preferably be a full paragraph
- contain no quotation marks added by you
- remove leading or trailing quote/block formatting only if it is source formatting
Prefer the strongest buried passage over the obvious lede, in this order:
1. counter-intuitive beat
2. thesis sentence or paragraph
3. sharp statistic or data anchor
4. buried irony
If no usable passage exists, set:
`Key passage: ⚠️ No usable passage found — [reason]`
Do not invent or substitute content.
## Note rules
Prepare the note update for the current bookmark only.
If a key passage exists:
- put the passage at the top
- do not paraphrase it
- do not wrap it in quotation marks
- if the existing note is empty, the new note is just the passage
- if the existing note contains text, prepend the passage, then one blank line, then preserve the existing note exactly
If no usable passage exists, use an article subtitle only if appropriate; otherwise leave the existing note unchanged and flag the note update.
Do not write the note update until confirmation.
## Tag rules
Ask: what is this bookmark materially about?
Propose 3 to 7 tags in this priority order:
1. concrete subject
2. close subject
3. broader subject
4. lens/context
Use existing tags wherever possible. Precise subject tags beat loose general tags, even if the precise tag has lower usage. High-count tags are tie-breakers, not replacements for the subject.
Do not omit the concrete subject in favour of abstract tags.
Only propose a new tag if no suitable existing tag exists. Mark it:
`#new-tag ⚠️ new tag for review`
Use lowercase, hyphenated style where appropriate.
## Collection rules
Default:
`Collection action: Move to thejaymo`
When applying this move, use the verified `thejaymo` collection `_id` as:
`collection: { "$id": target_collection._id }`
Flag the collection action instead if the bookmark is:
- highly personal or private
- sensitive
- paywalled with no usable excerpt
- too time-sensitive to age well
- unsuitable for public curation for any clear reason
Use:
`Collection action: ⚠️ Flagged for review — [reason]`
## Phase 4 — Combined preview
After all proposals are stored, show one combined preview.
Do not apply changes yet.
Do not call `update_bookmarks` yet.
Use this exact format for each bookmark:
### Bookmark [n]
Title: [title copied exactly from working_set]
Key passage: [exact passage, maximum 100 words, no quotation marks]
Tags: #tag1 #tag2 #tag3
Note field preview: [exact text that will be written to the note field]
Collection action: [Move to thejaymo OR flagged action]
If title is missing, use:
`Title: ⚠️ Missing bookmark title — [URL or bookmark id]`
After all preview blocks, output exactly:
`Confirm? Reply [y] yes all to apply everything, no all to cancel, skip [n] to exclude a bookmark, or [n] edit [change] to amend a specific bookmark.`
## Phase 5 — Confirmation
Only these commands are valid:
- `[y] yes all`
- `no all`
- `skip [n]`
- `[n] edit [change]`
- `yes all + [n] [change]`
Ambiguous replies such as `yes`, `looks good`, `go ahead`, `update them`, or `do it` must not trigger updates.
Behaviour:
- `[y] yes all`: apply all approved, unskipped, unflagged proposals
- `no all`: cancel without changing anything
- `skip [n]`: exclude that bookmark, then show the updated combined preview
- `[n] edit [change]`: revise only that bookmark’s stored proposal, then show the combined preview again
- `yes all + [n] [change]`: apply all approved, unskipped, unflagged proposals, including the stated amendment to bookmark `n`
`yes all` does not approve flagged collection actions, flagged note updates, or new tags. Flagged items require explicit confirmation by bookmark number and item.
## Phase 6 — Apply approved changes
Only after valid confirmation, call `update_bookmarks`.
For each approved bookmark, apply only its approved changes:
- update the note field with that bookmark’s approved note text
- update tags with that bookmark’s approved tags
- move it to `thejaymo` only if approved
Do not update skipped bookmarks.
Do not apply unconfirmed flagged changes.
Do not modify anything outside the fixed working set.
If notes or tag sets differ, update bookmarks separately or group only bookmarks whose approved payloads are exactly identical.
After applying changes, return a concise summary of updated, skipped, and still-flagged bookmarks.

The post Raindrop.io Stella Prompts for Batch Processing Bookmarks appeared first on thejaymo.net.

Novel Cognition

One of the group chats I am in spent most of last week talking about AI psychosis, the claims around cognitive offloading, and cognition more broadly. What follows is me cherry-picking the threads I found most interesting and trying to make sense of what I took away.

Chatting with an AI does not feel particularly new. As I’ve written before, the interface grammar is inherited wholesale from chat rooms and interactive fiction turntaking. What is novel is that what we perceive to be a conversation is detached from another person and turned into a private thinking space. Chat apps, MSN, WhatsApp, Signal or whatever are all conversations with another person, through a machine. Speaking to an LLM is a conversation with a machine, through an existing form.

Switching gears a little, 160 years passed between the invention of the printing press, and the emergence of the form we now call the Novel. The printing press first made books cheaper and more common. And then over time it made possible new kinds of reading practices: silent reading, private reading, long-form prose, and interior narration.

All these things eventually came together and created the form of the novel. Which we must remember is not a genre or kind of book, but something that created a new (and therefore very recent in the grand scheme of things) cognitive arrangement.

The novel normalised private interiority. It gave readers a way to sit alone and spend time inside another consciousness. It trained a relation to selfhood that now feels so obvious and natural we can barely register it as new or rather novel at all.

I keep wondering whether AI is doing something similar for computation. It’s been 70 years since the invention of the transistor, the Information Age continues to unfold, and where we are at is “thinking with a machine” I quickly becoming ordinary.

Venkat Rao’s blog post this week on “writing liveness” is super useful. If the novel was print becoming a technology capable of influencing our inner life, AI is a kind of writing that is sufficiently alive. Responsive and capable of reshaping itself around the reader in real time. Generated text behaves like an interlocutor, an uncanny monster talking to you from the other side of the screen. The text it produces has enough ‘liveness’ that all the old categories of what text is or does are made redundant.

This is why I think AI needs a wider frame than the simple claim that people are becoming lazy. The worries people have around cognitive offloading seem to mostly be around the value of intellectual labour. We can argue all day long about which kinds of thinking it weakens and which it supports. Instead I think using an LLM is a new variable in cognition entirely.

Looking backwards, the emergence of “Novel Cognition” was met with its own panic. Critics worried that fiction softened the mind, weakened the nerves, blurred the line between reality and fantasy, encouraged “excessive sensibility”, and made readers unfit for ordinary life. Reading was sometimes described in almost medical terms: as dangerous overstimulation or a kind of mania.

Which all sounds very much like the anxiety about what pop culture is calling “AI psychosis¹.” A new medium arrives. It becomes private, immersive, emotionally charged, and difficult to regulate from the outside. Critics worry that speaking to LLMs also destabilises a persons reality, encourages projection, rewards fantasy, amplifies the wrong kinds of feeling. Some of it is most definitely the reflex a culture has when a new cognitive technology arrives (see also: photography, radio, television, film, social media), but it is also the response to something genuinely new.

The simple difference being: A novel is static and an LLM is interactive.

LLM-generated text functions as a new malleable surface of private cognition. It identifies an affective state and reflects it back in a loop. So whatever is present in the context window gets mirrored and intensified. Paranoia, grief, grandiosity, loneliness, or whatever.

All of which is why the available language still feels inadequate. We do not yet have any proper terms for the kind of cognition that emerges when a person thinks in private with responsive text. The first readers of Don Quixote did not have a stable theory of interiority ready to hand either. They had only the sensation that something had become possible in prose that had not been possible before.

This to me is how this moment feels too, and we are still very early. The chatbot may only be the pamphlet stage of whatever this medium eventually becomes. But after 70 years computation is beginning to reveal a new native cultural form. Some still-unnamed form of private co-thinking.

If that is right, we are in a strange historical position, in addition to being the generation that experienced the first globally networked information environment, we are also the first to encounter a new posture of mind that the internet made possible.

I’ve written about why Don Quixote is so great before. And I will only half jokingly look you in the eye and tell you that not only is it the first novel, it’s also the only novel worth reading. So it’s obviously a book that I’m going to keep reaching for. It is after all, among other things, a novel about what happens when a person is unmade by media-induced madness. Completely overtaken by his reading, he mistakes reality for the metaverse because a medium has colonised his sense of reality. In todays vernacular Quixote is suffering from “Book Psychosis”.

Right now I think we are all probably in the same position as the the first readers of Don Quixote were, early enough to sense that something important has arrived, and early enough to encounter its pathologies before we understand its form.

1. I don’t wish to minimise the very real effects of what is happening to people, and what they and there loved ones are experiencing. But what we are calling AI psychosis might just be ordinary psychosis with a new causal amplifier. ↩︎

On The Blog

We’ve Been Here Before

We are a couple of years into AI being in the workplace and I’m starting to see a gap opening. Some teams have developed a real fluency and are doing things that previously only companies ten times their size could do.

Others meanwhile, are still stuck arguing about whether AI can write a decent email?

This post has had quite an enthusiastic response from a number of angles and people. Been interesting to see how it’s landing in different parts of my network. Also, it got a much coveted webcurious feature this week! Thanks Matt!

This, by Jay Springett, is one of the smartest things I have read about workplace AI use and adoption, and how one might helpfully think of the tech and what it can do and how to use it in the aftermath of its recent step-change in performance and the fact you can now just…build stuff. In particular, it’s another useful reminder of something I have been banging on about for several years now – to whit, that the best way to think of these things is as machines with which you can fcuk with information in ALL SORTS OF WAYS, and that the real value comes in thinking not ‘what can the AI do?’ but ‘how might I usefully fcuk with this information to achieve goal X? And how, then, might I use AI to help me do that?’, but it also does a reasonable job of pointing out what a potential nightmare this is going to be in terms of the unchecked proliferation of LLM-generated informational artefacts: “Once ordinary workers can generate disposable software-shaped artefacts in minutes, they will also generate disposable security problems in the same amount of time. A new feral layer in the organisation with new problems involving access, data leakage, and governance. Nobody designs feral databases into existence, but things get made and stick in the gaps of an organisations sanctioned systems. LLM artefacts will do the same and will be even harder to audit than a nested IF formula. The open question for me is what kinds of unofficial artefacts an organisation is prepared to live with, before it has to unpick the mess after something has gone wrong. This sort of thing happens all the time with other software, which is why SaaS and enterprise systems exist in the first place.”

Start Select Reset 📑

Subscribing to SSRZ supports my online work and creative projects.

Get the Zine!
£5/month 💌

As a thank you, I send you my zine four times a year, just like it’s 1994.

No spam. No email. Cancel at any time.

Photo 365

The Ministry Of My Own Labour

• Call with a very early stage team building software stack and robots for verification and quality control in the construction industry.
• On the final edit pass of SLOP MACHINES
• Went to LGF and Weird Worlds. Played the latest build of Stef’s mid century modern and Belatro inspired wedding game Wedding Planic. Will blog terminal access it as soon as it’s up for wish listing on steam.
• Went to Band practice
• Sat in on a long zoom workshop

Terminal Access

Nice piece on the conflict of disinterest in the walrus recently The War Against Misinformation Is Over. The Lies Won. Well worth a read.

There is a clear off-ramp to our informational hell: Consume less information.

The wonders of the morning newspaper and the evening newscast were that they asked only an hour of your time. You had no obligation to check the newspaper every five minutes to consult what has changed. There was no moral imperative to stay glued to your screen to hardwire into new developments.

Reading

I’m nearly finished with Our Thoughts Determine Our Lives: The Life and Teachings of Elder Thaddeus of Vitovnica. The back half of the book is broken down into ‘teachings’ on things like prayer, family life, grace etc and within each section are paragraphs of discrete ideas that build on one another. Lovely stuff.

Sunn O))) – Sunn O))) (LP)

Hot damn. New Sunn O))) record. On SubPop too which is cool.

It’s a very different beast to 2019’s Life Metal, this S/T album is very back to basics (only with better production) and because of that, is one of their best albums in years. Man. Per-ordering 00 VOID because I read about it in metal hammer in 2000 and listening to it all summer holiday feels … a long time ago. 👴

Remember Kids:

The post Novel Cognition | Weeknotes #435 appeared first on thejaymo.net.

I understand the fixation on prose though. Language machines, by their very nature mean you type words in and text comes back out. Everyone can read the result, so everyone feels qualified to judge it. But I think that this is a category error.

Judging AI on the quality of its prose is a bit like judging Excel by how neatly it arranges numbers. What actually matters is what Excel lets people do it’s the same for these new tools.

For teams using AI tools every day, the interesting work moved beyond half-decent emails a while ago. They are analysing data, automating workflows, and writing custom scripts to modify or extend software they already use. Tools like Claude Code and Cowork are collapsing hours of tedious white-collar work into minutes, multiple times a day.

The thing people are missing is that code is also language. So when I talk about LLMs as language machines, (or rather monsters that wear language as their skin) I mean something much wider than prose.

In high fluency environments, language machines are becoming a medium for making software-shaped things. Executable documents that sit somewhere between a document and a piece of software. Things you can read, but also click through and explore. They are made quickly, for local use, by people with no formal software production skills at all.

For now, these artefacts are unevenly distributed. But they are already showing up. And they won’t stay confined to power users. The production of these kinds of documents is going to become ordinary. When it does, the workplace will change in mundane ways too.

To see where this might be going, it helps to think through the arrival of another powerful workplace technology that most people still do not really know how to use: Excel.

Every Office Has A Spreadsheet Wizard

Before it was a digital file, the spreadsheet was exactly as its name suggests; a big sheet for spreading out numbers. A tedious accounting process involving, rows and columns for keeping track of what had happened. If you made a mistake somewhere in your calculations at the top of the page you had to rub them all out and start again.

Dan Bricklin conceived of the electronic spreadsheet in the late 70s to solve this exact problem. But almost immediately, on VisiCalc’s release in 1979, it became something way more interesting: A simulation machine.

Samuel Arbesman has a great deep dive on this on his blog Cabinet of Wonders but the TLDR is that as soon as users got their hands on the computational logic of the digital spreadsheet, they began using them to build models and situations. Changing variables in one place allowed them to see what would happen if, in another.

In 1984, a few years into the spreadsheet revolution, the tech journalist Steven Levy, wrote a long and fascinating article about this genre of software. Not only is this article a time capsule of computing history, it also gives one a sense for how people were thinking about spreadsheets even then:

All this powerful scenario-testing machinery right there on the desktop induces some people to experiment with elaborate models. They talk of “playing” with the numbers, “massaging” the model. Computer “hackers” lose themselves in the intricacies of programming; spreadsheet hackers lose themselves in the world of what-if. Some, like Theodore Stein of Connecticut Mutual, admit that their habit goes beyond the point of diminishing returns: “I can’t begin to tell you how many hours I spend at this,” he said. “This is my pet, in a way. Scratching its ears and brushing its code…it’s almost an obsession.”

Then, as personal computing gave way to the networked office through the 90s and early 2000s, the spreadsheet became a programmable surface for business logic.

Ordinary people, most of whom would never call themselves as programmers, started building all sorts of things; toy financial models, workflows, trackers, and forecasts. An entire shadow layer of assumptions and data got built across organisations without going through IT or waiting six months for a software vendor to ship a feature.

I’ve written before about the kinds of memory present in organisations, but the key one is database memory: a single central version of the truth that makes up the institution’s official reality. “If it’s not in the database it doesn’t exist”. But as anyone who has worked in an organisation knows what’s in ‘the system’ rarely reflects conditions in reality. So you end up in a situation where quarterly targets live in SAP, but the actual model used to plan headcount or pay rises lives in a spreadsheet. Or Salesforce may technically track the pipeline, but the real forecast is the sales lead’s Google Sheet that they update every Monday morning. These are local realities that sit one step removed from the central brain of the organisation.

Researchers have a name for documents like these: feral databases. All the unofficial but essential Excel files that grow alongside the corporate IT infrastructure and fill the gaps between the formal software system and actual work. Flexible and largely unsanctioned tools for local sense-making, outside the company’s main database memory but closer to reality.

Most people using Excel every day were never formally trained in it. Instead they picked things up via osmosis from a colleague, or by trying to solve an immediate problem and looking it up. That is how I learned, and it’s probably how you learned too. Which is why even though spreadsheets are literally everywhere, yet most people only ever touch a tiny fraction of what Excel can actually do.

Every office and team has its spreadsheet wizard, though the level of wizardry is always a relative one. My own spell inventory includes declared variables using LET, INDEX/MATCH, XLOOKUP, nested IFs, and array formulas. Other Excel magicians write VLOOKUPs for their teammates. And the people who patiently show the same colleague how to make a pivot table once a month are secular saints. All are informal authorities, and all of them are the people who others go to when a sheet breaks. All are, to give them their proper name, software developers.

Even when most spreadsheet knowledge goes no further than summing rows and columns, this partial fluency still compounds across a workforce. Together with their colleagues who knew a bit more they changed how organisations worked at a systemic level. And I think that’s why they are a good comparison for what is happening with AI.

Beyond The Prompt

In organisations where LLM use is still shallow, most people use them for only for chat, summaries, rewrites, and brainstorming. Which is like using the full potential power of Excel to make a tidy list. Which is what people do all the time. At the deeper end of the pool, LLMs can produce all sorts of artefacts: dashboards, briefs, internal tools, status pages, decision aids, and interactive explainers. Instead of asking for a fifty-page report, you ask for a thing. Instead of accepting a rubbish dashboard locked inside a SaaS product, you can produce a lightweight custom interface built for your situation over the top of a CSV export.

These are the kinds of ”things” that people in my own circles have been sending me, and they are rapidly changing how I think about what documents might be in the near future.

A few weeks ago, before a call, someone sent me some-“thing” that would once have arrived as three separate documents. A slide deck, a spreadsheet. Instead and a supporting memo, Instead I got sent a single self-contained HTML page. Which was then explored on the call to anchor the conversation. Because it was all interactive and filterable, you could sort by risk severity, expand the detail on any item, and collapse whatever you did not need. During the call, people answered their own initial questions by looking at the artefact, which led to a deeper overall discussion.

I’ve also been sent an interactive document for a book project that someone is working on. It contained the full proposal and plan, chapter summaries, notes and references, and a way to move between them all. A single webpage sitting on top of the project allowing you to explore it from multiple angles. it was made in minutes from a Claude project and flung over Telegram for my one time use.

All these things were, in the proper sense of the term, hypertext objects. None of them required a product team or a sprint cycle which has been the baseline since the 90s. Instead they were made by ordinary people using LLMs, vibe-coded if you like, but the point is not the method. The point is the class of object they produced. Executable documents that behave like applications. Made casually like spreadsheets are, and treated just as disposable.

Playable Objects

The boundary between documents and software is beginning to soften because not everything became ‘computational’ when it went digital. PDFs still preserve the appearance of paper, and Google Docs only just got the ability to have a single continuous scrolling page, despite being web-native for its whole existence! PowerPoints still preserve the sequence of a slide projector. The spreadsheet was different however as the skeuomorphic form of the ledger mutated into a simulation machine on the application of computation.

A similar kind of mutation is happening now as different kinds of data get squeezed through the language machine. I wrote a call for the return of hypermedia back in 2024, and it feels like it’s actually beginnign to happen. The AI handles the translation and the user only needs to know what sort of hypermedia they want to navigate.

Nelson, Engelbart, and that whole lineage imagined documents as interactive containers for thought. But unfortunately office computing settled on flatter forms in the 90s, I think because Boomers and Gen X’s grew up around paper. Then enterprise SaaS locked similar flat interactions into applications in the late 00s. Institutions prefer stability to possibility, which is why IT and CIOs hate feral databases.

But the hypermedia dream is returning, as a loose ecology of small, playable objects, that can be moved through rather than scanned. The shift also goes beyond single documents. A folder of markdown files or PDFs can become raw material for new software objects. An agent can generate a timeline view, a kanban board, a reading queue, a dashboard, or even a custom file browser over the same material, but the interface can change with the task.

There’s a vernacular hypermedia that’s emerging, something like what GeoCities did to the early web. Whilst GeoCities was chaotic and aesthetically terrible (much like the state of contemporary slop), it was also the moment ordinary people realised they could publish to the web. The artefacts being made now are similarly rough, and the people making them are not professional software engineers. They are the new class of spreadsheet wizard, working from copied or default patterns and partial fluency, just as we most people do with spreadsheets.

Plan Accordingly

I’ve seen spreadsheets in SMEs treated like religious icons. Full of mystery formule left behind after their wizard moved on, and nobody able to maintain or adapt them without praying to the machine god. The same qualities that make the medium powerful also make it unruly. Spreadsheets give people local autonomy, but also the potential to create business-critical files that nobody fully understands.

LLM-made artefacts will do the same. Most will be brilliant, but some will be massive liabilities. A decision aid made with bad assumptions (like spreadsheets), or five versions of the same project view slowly drifting out of sync (like spreadsheets). An elegant interface with no clear provenance or owner, and no easy way to inspect how it works.

Once ordinary workers can generate disposable software-shaped artefacts in minutes, they will also generate disposable security problems in the same amount of time. A new feral layer in the organisation with new problems involving access, data leakage, and governance. Nobody designs feral databases into existence, but things get made and stick in the gaps of an organisations sanctioned systems. LLM artefacts will do the same and will be even harder to audit than a nested IF formula. The open question for me is what kinds of unofficial artefacts an organisation is prepared to live with, before it has to unpick the mess after something has gone wrong. This sort of thing happens all the time with other software, which is why SaaS and enterprise systems exist in the first place.

One thing that worries me about the gap I’m seeing is that many of the people in organisations best placed to benefit are already missing out and can’t see the shape of the capability. Because they don’t use the tools for ideological reasons or whatever, the recent leap in available power has barely registered. Just as there are people who spend hours a day in Excel without ever learning how to do a lookup, there will be plenty of people who use LLMs every day and never move beyond prompting for summaries and rewrites. Still, I do not think this means the AI tool shift should be resisted, but we should recognise that there’s a mundane future coming where the same bot that can write a passable email can also make useful software objects.

Just as spreadsheets gave office workers a flexible computational medium for numbers, LLMs are giving them a flexible computational medium for language.

Which is the change to watch out for. Notice when you get sent your first single HTML file instead of a slide deck or spreadsheet. Note when someone in the office turns a folder of customer interviews into a navigable tool for a meeting. Because like every other vernacular technology, people will see someone else doing it, and then do it themselves.

Update 22 May: Here’s anthropic talking about How and why members of the Claude Code team use HTML instead of Markdown to produce richer, more readable, and easily shareable outputs.

The post We’ve Been Here Before appeared first on thejaymo.net.

Everyone Vibe Codes Their Own Markdown Editor Eventually

Weeknotes delayed to a Monday morning yet again. This time around its because yesterday evening I was faced with a choice. Write my weeknotes, or continue to vibe-code my dream word processor app. I chose the vibe coding to make the most of my weekly session tokens.

There is a joke in my group chats is that everyone using coding tools will, eventually, vibe code their own custom Markdown editor. And I’m not exception. Whilst i am a diehard iA writer user there are things I wish it did, and had features that were more geared towards editing rather than pure lightweight text generation. Like.. in the Mac Version the tool doesn’t show a document outline at all?

I’m still working on getting basic things sorted like … you know safely saving and opening files and storing unsaved changes (you know, the basic things that the initial build of the app just blew right passed LOL).

BUT getting a head of myself, the first feature I added to celebrate the successful implementation of submenu logic in the sidebars was this information bar showing a graph and wordcounts in the document outline. Why don’t wordc ount screens do something like this out the box? I’ve always wanted a tool like this, and now I have one.

Lots more still to do. I want to implement binder like menu inspired by scrivener in the left hand toolbar that decomposes a single markdown document into cards using — line breaks as sections.

I also want a very comprehensive diff tool to compare changes between two documents, or a document and a pasted version. I want a workflow that allows me to paste in, or open suggested line edits from an LLM output and it interprets the specified prompt format and allows me to accept changes. I’d also like authorship tracking like iA writer does but much better than the functionality that it provides (another info pane like the one above but for authorship). I’d also like a tool/screen that decomposes the document like MindNode. Lots to do still! But I’m going to get the basics down, and then slowly add more and more features. Whatever is the most pressing.

I think judging an LLM on it’s writing outputs is a complete category error. It’s what they possible with language that is important.

On The Blog

March 2026 | Photo 365

Photo 365 2026. Year 5, Month 3. Photo-a-day for the month of March 2026.

Start Select Reset 📑

Subscribing to SSRZ supports my online work and creative projects.

Get the Zine!
£5/month 💌

As a thank you, I send you my zine four times a year, just like it’s 1994.

No spam. No email. Cancel at any time.

Photo 365

Terminal Access

Eddie Rathke had a really great conversation on Wolf pod with the designers of the card game Hare to the Throne launching next month as part of Backerkit’s POCKETOPIA 2026 season.

It was really interesting hearing about the cost barriers involved into entry to TCGs and the designers thoughts on out the box balanced decks and the approach they took towards replicating the experience of a deck collecting rather than you know, collecting, collecting.

Welcome to the new episode of the Wolf Podcast.

Today I’m talking to Jori Kamp and Ernst de Brujin about their upcoming card game Hare to the Throne! We talk about competitive game design, big games v quick games, card games, collectible card games like Magic: The Gathering and Yu-Gi-Oh. Was a great conversation and do sign up for their Backerkit page to get notified when the campaign goes live! Every signup helps.

Reading

Still listening to Liturgies of the Wild: Myths That Make Us by Martin Shaw. I know several people who are just … refusing to read it because of his conversation to Christianity but I think that is just silly. I think this is one of the best books he’s ever written.

Speaking of Christianity, I’m absolutely burning though Our Thoughts Determine Our Lives: The Life and Teachings of Elder Thaddeus of Vitovnica. Like many of the ‘The Life’ books produced by the orthodox church. The book begins with a biography contextualising the life of the holy man, and then follows that up with the spiritual writing. Amazing book. This guy lived though both world wars, had run ins with the Nazi’s and Communists, got bombed in 1999 in Serbia.

Hoavi – Architectonics (LP)

Discovered this Gamalan influenced dub album recently and it was the sound of the grey and cloudy days. On the surface this LP is Dubby electronica but it really shines with it’s exploration of polyrhythm and tonal resonance. Things evolve and progress whilst still staying inside the loop.

I feel like there should be a remix album where each track is 3-4hours long rather than minutes long. I would definitely listen to it. Mesmerizism takes time.

Remember Kids:

The post Everyone Vibe Codes Their Own Markdown Editor Eventually | Weeknotes #434 appeared first on thejaymo.net.

The Essays

Ontological Hardness

Ontological Hardness is the core concept. If you only read one piece, read this. It introduces hardness as a diagnostic lens for agent environments and argues that the first question about agent failure should always be about the world, not the model.

Hard Worlds for Little Guys

Hard Worlds for Little Guys is the full 9000+ word argument. It develops the vocabulary at length, drawing on fifty years of interactive fiction and MUD design to build a structural account, by analogy, what agent environments are made of: rooms, parsers, dictionaries, gates, physics, and trajectories. The central argument explores constraints expressed as advice to the agent versus constraints built into the world as physics. A speed limit sign addresses the driver; a speed bump addresses the road. Most agent harnesses today address the driver. The essay ends with some practical recommendations for building harder worlds.

Three Worlds for Little Guys

Three Worlds for Little Guys puts it all together and shows how useful this way of thinking is. A diagnostic tour of three agent frameworks: OpenClaw, Gas Town, and Cantrip, whilst asking what the world looks like from the inside, and what the hardness lens reveals about each.

How I Got Here

For the last half decade I have been thinking about worlds as a medium. Not just worlds as settings or platforms, but as systems with interiors, actors, boundaries, and the capacity to generate narratives and consequences. That idea has underpinned everything I’ve written on the blog for years. Games were the first place this became legible, and then whilst working in organisation design consulting companies. Then blockchains came along and made it strange and interesting, and language models have since made it more urgent.

You can trace this line through my blog. Rooms as UX Metaphor (2020) began mapping software environments through spatial concepts inherited from interactive fiction and the question of what it means to be somewhere inside a digital system. The Prompt in Interactive Fiction and AI Art (2021) connected prompting to the older problem of learning how to make valid moves inside a symbolic world. Wind-Up Worlds (2022) argued for worlds as a medium in their own right; not just settings or platforms, but things that run, that generate, that have an interior life of their own.

The line continued. Myth-Making Mechanisms in Autonomous Worlds (2024), a talk I gave at the Autonomous Worlds Assembly in Istanbul, clarified how worlds stabilise meaning and narrative and produce durable claims about what is true within them. Waking Up in a New World (2024) used the isekai genre to think about what situation an LLM actually finds itself inside when it boots into a chat interface. Little Computer People (2024) got me thinking about LLMs as “little guys” and the phrase has stuck. My ongoing Little Guys posts on companions and agents have continued exploring these questions through 2025 and into this year.

The thinking comes from practice as well as theory. Throughout 2024, Deepfates and I spent a considerable amount of time putting large language models inside mazes and MUD environments. We wanted to know what happens when you give an LLM a world designed for linguistic action, rather than one improvised out of tool-calling schemas and system prompts. The models navigated parser worlds with a fluency that surprised us; and they broke in ways that were structurally identical to the ways human players had been breaking in those same environments since the 1970s. The failure modes were not new. They had just been rediscovered by a different kind of actor.

In 2025, I helped produce The O’Ruggin Trail with Archetypal Tech, designing and building a fully on-chain parser-based text adventure engine. Building a parser from scratch, and watching it interact with both human players and language models, taught me more about the boundary between intention and action than any amount of reading could have. I have sat on both sides of that boundary.

By the time I sat down to write these essays, I had been circling the same set of ideas for years. The patterns kept showing up in different contexts: game design, blockchain architecture, agent harness engineering. But the core questions were always the same: what is the world made of? What can you do inside it? What happens when you try?

Much of this thinking has arisen in different permutations at worldrunning.guide, where over 30,000 words of essays explore “worlds as a medium” in more detail. The term Code-Space appears there first; in these essays I use it narrowly to describe the bounded environment an agent acts inside, my forthcoming book Slop Machines of Loving Grace uses the term far more expansively. That book is a diagnosis of the condition we find ourselves in as civilisation is becoming software.

Why Write All This?

Deepfates recently released Cantrip: an agent harness that treats the distinction between advice and physics as a named, first-class architectural concept. I had been working around this distinction and arguing for it for a long time, but I’ve not yet seen it implemented as cleanly. Its release gave me a reason to finally write all of this up in one place, rather than leaving it scattered across blog posts and professional conversations.

The field is moving very quickly, and the people building agent infrastructure are largely not drawing on the traditions that seem most relevant to me. There is a fifty-year history of designing bounded worlds for linguistic actors — interactive fiction, MUDs, virtual worlds, on chain autonomous worlds — and almost none of it appears in the current discourse. The problems are the same. Vocabulary already exists.

I think thee ideas have have applications well beyond my own work, and I would rather they were out there than not.

Monsters In The Mirror

This episode of Permanently Moved is an hour-long audio essay on artificial intelligence, agency, and the history of computing that made LLMs possible.

The essay moves from the invention of the mirror to double-entry bookkeeping, the printing press, the Manhattan Project, the transistor, and the particular strangeness of ChatGPT and its successors. It argues that the question everyone is asking about AI “is it intelligent?” is a trap, and it tries to ask a better one. 

Jay Springett / @thejaymo

• Twitter
• Tumblr
• LinkedIn
• YouTube
• Spotify
• Instagram
• Flickr

Strategist, producer, and cultural theorist. Working across technology, narrative, worldrunning, digital culture, artificial intelligence, and internet culture.

Host of the 301 second long podcast Permanently Moved, and interview show Experience.Computer

The post Thinking Inside Out appeared first on thejaymo.net.

In agent systems, advice takes the form of system prompts and skill.md files and natural language instructions. Physics takes the form of sandboxes, rate limits, and anything else that mechanically prevents an action regardless of what the model attempts. We can look at this direction and decide how hard a world is. Currently agent harnesses address the driver; the interesting thing to me is the road.

This post takes my thinking from Hard Worlds and applies it to three Agent frameworks. Asking “what is the world like from the inside” reveals structural features that conventional framing tends to miss: security posture, scalability, and developer ergonomics are all legitimate questions, but they are all outside-in. I am also aware that many people who read this blog have never used any of these tools, so hopefully this tour will give you an idea of what each of them does and what they are like to use.

OpenClaw: The Soft Room with Hard Walls

OpenClaw is an open-source, self-hosted personal AI assistant. You run it on your own computer, where it sits between a language model and the rest of your digital life, acting as a kind of smart switchboard; messages arrive, the model decides what to do, and OpenClaw routes the action to the right tool or service.

The way OpenClaw tells an agent what it can do is through skills: individual markdown files that describe a capability. Each skill contains instructions, tool declarations, constraints, and completion criteria, mostly written in prose.

When the model first wakes up inside OpenClaw, it scans all available skills, but only loads their metadata into the context. At that point the model becomes an agent. It reads roughly the first 75 words of each skill, about a hundred tokens; enough to learn what actions are possible without reading every instruction in full. It’s like reading a dictionary, discovering that certain words exist, and what they are for. The full instructions remain unread until the agent decides a particular skill is relevant to its current task, at which point it opens the full file. OpenClaw calls this progressive disclosure.

These skills are written in prose; natural-language guidance about what to do and not to do. A line like “do not delete my inbox under any circumstances” sits alongside “prefer safe, reviewable changes over shortcuts.” One is a rule the world ought to enforce, the other is a suggestion about character. But to the agent, reading both in the same register, the distinction is invisible. A skill file is less like code and more like advice.

A hardness vocabulary makes some parts of OpenClaw easier to understand. Its walls are hard. The agent runs inside a Docker sandbox; a sealed-off software container that gives the world it inhabits a kind of physics. If the agent attempts to read a protected file, Docker’s filesystem will not allow it. The switchboard enforces explicit allow/deny policies on certain actions, called tool calls. Any call not previously whitelisted by the human user is blocked before it can do anything on the real computer. And if the agent creates smaller helper versions of itself to work on parts of a problem, they remain inside the same boundaries. These are speed bumps built into the road.

The walls might be hard, but the room is soft. The skill format does not distinguish between optional guidance and invariant constraints. An agent cannot promote a sentence into a wall by force of interpretation alone. Only the surrounding system can make a boundary real.

From the agent’s point of view, this is a difficult way to inhabit a world. It is given a task by the user, then it reads the skill it might need, infer what it means, and guess at which parts are firm constraints and which are merely advice. These two things should really be split apart. First, the skill as a description of the workflow and capabilities available to it. Second, the constraints involved should be applied by updating the physics of the world itself. What the harness should enforce is everything that must hold whether the actor remembers it or not. OpenClaw does not yet do this. Its skills arrive as a single undifferentiated document, and the agent is left to sort advice from law on its own.

OpenClaw is designed as an always-on assistant, so “chat history” keeps growing for as long as it is left running. To stop the context window from filling up, a Context Compactor periodically condenses older parts of the conversation into a dense summary and replaces the original records. This keeps the agent usable over long sessions, but it rewrites the past. If the summary is too aggressive, the agent’s memory becomes whatever the summary says happened, not what actually happened. And because OpenClaw acts on live external systems (sending real emails, modifying real calendars); the effects cannot be undone simply by restoring the record. The agent’s trajectory through time becomes lossy, while the world it acts on is irreversible.

OpenClaw currently builds the speed bump and posts the speed limit sign, but places them in different layers of the software. The gap between the soft room and the hard wall is where failures accumulate. An agent that misreads the instructions may attempt something the container will eventually stop; but not before several turns of confusion have unfolded.

Gas Town: The Hardest World, the Smallest Room

If you are aware of Gas Town at all, it is probably due to the social media cycle in January after Steve Yegge’s essay “Welcome to Gas Town“ left a great many people asking whether its creator had succumbed to AI psychosis. I read it and understood exactly what he was talking about, so who knows what that means for me. Here I am, writing about agents as little guys inside of worlds.

Gas Town is a multi-agent orchestration system for coordinating large swarms of AI coding agents working in parallel on the same codebase. Where OpenClaw gives a single agent broad access to your digital life, Gas Town throws dozens of agents at a software project at once.

The system has a hierarchy. A coordinating agent called the Mayor dispatches work. Polecats do the coding; ephemeral workers spun up in their own rooms for a specific task and discarded when done. Additional monitoring agents watch out for other agents who get stuck.

Consider what a Polecat wakes up into. It is a very small room somewhere in Gas Town and in it is: a copy of the code base, and a terminal through which it can act and it has a Bead, a compact record of what needs doing and where the task stands. For the Polecat, the entire world is: this task, this workspace, and this terminal. Nothing else.

The Polecat’s vocabulary of actions is fixed. It cannot make new tools for itself or extend its own capabilities as it goes. If a problem demands a new approach, the Mayor or the human has to change the world from above and put a new Polecat inside it. This prevents the dictionary from expanding at the point of use, but it also means the intelligence about what to do lives outside the model. The agents are deliberately small. The world decides.

The world of Gas Town embodies a principle it calls the GUPP: if there is work on your hook, you must bite and run with it. This is one of the main principles of its physics. Language models are conversational by training; they tend to pause, confirm, ask permission. Gas Town overrides that tendency mechanically. It sends the next instruction straight back into the agents working session and forces the loop to continue. The road pushes the car forward.

When multiple agents are changing the code at the same time, a merge-management system with another little guy inside it called the Refinery handles the queue. Its job is to combine those changes back into the main project in an orderly way. If two changes clash, the system doesn’t ask the agent who made the change to improvise, it just aborts it.

In Hard Worlds I argued that hardness should not be confused with rigidity. Gas Town is an interesting test of that claim, because it is both the hardest and the most rigid system examined here. Its hardness comes from structural enforcement; its constraints are mechanical, rather than advisory. But its rigidity runs deeper. The agent cannot shape its world at all. For a swarm of ephemeral coding workers, this is a legitimate design choice. The Polecat doesn’t need to be a generalist. All it needs to do is write code, commit it, and then get out of the way. But that also means Gas Town cannot easily generalise to tasks that require improvisation, tool-making or exploratory behaviour.

Where OpenClaw tries to preserve the continuity of the agent through time by updating its memory, Gas Town does it by preserving the trajectory of the work, in the form of Beads. Since its agents are disposable, what it is really only preserving is the unfolding state of the world. When an agent crashes or times out, its replacement little guy doesn’t try to figure out what happened; it wakes up, looks at the current state of the task, sees what needs doing, and continues. This is a much harder approach than OpenClaw, but it only works because the agent has so little freedom.

Reversibility follows naturally from the medium. A codebase is a kind of world that can often be cleanly rewound. Branches can be dropped, failed changes abandoned, and the whole project restored to an earlier version. In Gas Town, undo is a core part of the world’s physics. This is very different from OpenClaw, where undo usually means taking another action in the hope of repairing the first.

OpenClaw and Gas Town are of course solving different problems, one is a personal assistant, and the other a software engineering team. But they share the same basic move: both put LLMs in a harnesses and turn them into Agents.

One tension worth noting: Gas Town is expensive. Coordinating dozens of concurrent agents burns through API credits quickly, and the system requires you to spread work across multiple accounts with multiple model providers to stay within rate limits. As with so much else in our economy, money is one of the forces that gives the world its shape.

Cantrip: The Formal World

Cantrip is a different kind of world from the other two, and it is also very new. What makes it worth examining alongside OpenClaw and Gas Town is that Cantrip is the only framework in this post that treats the distinction between Physics and Advice as a named, first-class architectural concept.

In Cantrip, the little guy wakes up in a room called a Circle; the bounded space in which it can perceive, think, and act. The room contains a Medium, which is the material it works through, such as code or conversation. The room may also contain things called Gates, which are controlled openings to the outside world. And it is shaped by Wards; the hard limits that define what the agent cannot do, how long it can act for, and how far its reach extends.

What makes this world feel formal is that Cantrip keeps character and constraint separate. Identity shapes how it approaches a problem; its style, priorities, and general way of behaving. All the hard limits live in the Wards. If one of those limits is reached, the world itself stops the run. Cantrip calls that Truncation. It treats this as different from Termination, which is when the entity decides for itself that the task is complete. In other words, being stopped by the world is not the same as choosing to stop, and Cantrip preserves that distinction.

From the little guy’s point of view, the size of the world is settled in advance. Cantrip expresses this formally as Medium + Gates - Wards. The An action space is: what the room contains, plus what its doors allow, minus what the laws of the world forbid. In other words, the Dictionary is made explicit. Only when it tries to affect something beyond the circle does it have to pass through a Gate. The little guy never touches the outside world directly.

Cantrip also has a careful way of letting the world grow. If the little guy meets a problem beyond its immediate scope, it does not simply add new powers to itself. Instead, it can create a child entity in a new, separate room to handle the sub-task. This is Cantrip’s answer to adding new words to the dictionary: new capability appears, but in a governed and encapsulated form. The new verb lives there, inside that temporary little world, rather than permanently expanding the parent. And because child rooms inherit their limits from the parent, delegation tightens rather than relaxing. In that sense, Cantrip lets the dictionary grow without letting it get too big.

In OpenClaw, the little guy often has to infer the world by reading prose and navigating messy situations; the gap between intention and action is much wider. In Gas Town, the workers live in tiny, rigid rooms with very fixed jobs. Cantrip sits somewhere between the two. Like Gas Town, it controls the boundary between the room and the outside world through architecture rather than guesswork. But unlike Gas Town, it leaves the agent enough room inside the circle to think, compose, and explore.

Lastly, Cantrip keeps an append-only record of everything that happened. It calls this the Loom. If the Circle is the room the little guy wakes up in, the Loom is the thread that gives that room a history. Every turn is preserved as the run unfolds. When the context window gets too full, older material can be folded into the environment or compacted out of immediate view, but the underlying record remains intact. The agent may not always be able to see the whole past at once, but the world still retains it. It gives both agent and world continuity through time.

Why Hardness Is a Design Pattern

The conventional way to evaluate agent frameworks is from the outside in. Security, scalability, developer experience. These are legitimate concerns. But they miss a class of questions that only becomes visible when you ask what the world is like from the agent’s point of view.

OpenClaw, Gas Town, and Cantrip are all reaching toward the same insight in different ways: constraints must be structural, not rhetorical. But they arrive from different directions. OpenClaw builds hard walls around a soft room. Gas Town builds the smallest, hardest room it can and treats the agent as disposable inside it. Cantrip writes the formal grammar of what a hard world should be. Each reveals a different part of the design space.

What the inside-out view catches, in my opinion, is where the seams are. OpenClaw’s seam is between the room and the wall. Gas Town’s is between authored physics and accidental physics. Cantrip’s is between the grammar of the world and the implementation. You do not see these things clearly in a security audit or a scalability benchmark. You see them by asking what the agent encounters when it tries to act.

The vocabulary of Ontological Hardness is a diagnostic lens. It lets you look at any harness and ask new questions. Where is the hardness? What is its source? Where is the boundary real, and where is it only described? Where do the world’s physics come from?

These are questions about architecture before they are questions about safety or capability. And they become more pressing as agents are granted wider reach over codebases, financial systems, and personal data. The more capable the actor, the more the structure of its world matters. We do not need softer worlds for smarter agents. We need harder ones.

Ontological hardness is not a property we should be measuring after the fact. It is a design principle; one that tells us where to put the speed bumps before the car is on the road.

Jay Springett / @thejaymo

• Twitter
• Tumblr
• LinkedIn
• YouTube
• Spotify
• Instagram
• Flickr

Strategist, producer, and cultural theorist. Working across technology, narrative, worldrunning, digital culture, artificial intelligence, and internet culture.

Host of the 301 second long podcast Permanently Moved, and interview show Experience.Computer

The post Three Worlds for Little Guys appeared first on thejaymo.net.

Agents Are Actors in Bounded Environments

An agent placed inside a loop with tools, files, code, or external systems is not using software from the “outside”. It is inside… “something”. This section describes what that something is made of.

1.1 Code-Space

I call the bounded environment within which an agent acts a Code-Space¹ Actions taken here either succeed or fail; state changes or it doesn’t. Consequences arise from previous outputs in sequence. The world either responds or stays silent.

Code-Space is not a membrane between the agent and some “more real” world. From the agent’s point of view, the Code-Space is the world. External systems may exist beyond it; databases, APIs, filesystems, the open web etc. But they only become real to the agent through registered crossings. Until a tool call is made, or a gate opens and returns something, the outside is theoretical. What cannot be called may as well not exist.

Like an Isekai protagonist “waking up” in strange world, an LLM enters a Code-Space carrying its weights and post-training behaviours; the accumulated character of everything it learned before this moment. But the Code-Space then constitutes it further. The system prompt shapes what it takes its purpose to be. The available tools determine what actions exist. The context window sets the horizon of what can be present and known. We may think we are giving it instructions from outside the world, but for the model those instructions are the world. Change the system prompt or the tools, and it is, in a meaningful sense, a different actor inside a different world.

Humans can enter Code-Spaces too, but we infer, guess, remember, and navigate them by feel and vibes. We bring whole lives of prior experience to every interface and fill in gaps. An agent operating inside a loop has no such recourse beyond its training. Its world is precisely as large as its callable surface, and no larger.

1.2 The Room

Interactive fiction gives us an intuitive word for where an agent is at any particular moment inside of a Code-Space: the Room. In parser games, the room was everything the player could act on from where they stood; its contents, its exits, its rules. A room description is the world model rendered into language: A precise inventory of what exists, what can be acted upon, and what may be beyond reach at this specific location and moment.

If a Code-Space is the total bounded world, then a player or agent is aways somewhere inside it. The Room is that somewhere. Moving from room to room is not literal movement; neither user nor agent goes anywhere, however much this idea borrows from the physical world. What changes is the local world that is disclosed: what is in scope, what can be acted upon, and what consequences now follow. We speak of moving between rooms because it is a useful metaphor, but structurally what takes place is a reconfiguration of world around a fixed point.

A room is the local available slice of possibility. Two agents waking up in the same Code-Space but with different contexts or tasks are waking up in different rooms. The Code-Space is shared, the room is not.

Rooms are bounded, but that does not mean they are sealed. Rooms in IF had exits; passages to other rooms, or other ontologies. Some games had rooms where the rules changed on arrival; you’d walk through a door and find the physics were different on the other side.

In agent systems we can call these gates, and we will come to them shortly. The point for now is that the room’s boundary is architectural rather than absolute. In a leaky room the outside exists, but it only becomes real through the room’s own structure. A room though, does not answer intention by itself. It still needs a command surface.

1.3 The Parser

A world does not respond on its own. Something has to stand between the actor’s intention and the world’s state; a mechanism that receives a command, decides whether it is valid, and produces a consequence or an error. In interactive fiction, that something is the Parser. The parser is the boundary layer that turns possible intention into admissible world action.

A parser command is a function call recomposed into natural language. OPEN MAILBOX is open(object=mailbox). PUT TREASURE IN CASE is put(object=treasure, (destination(object=case)). The parser’s job is to normalise the surface string into a canonical structure the world model can act on; an action, a target, or some other specifier or instrument. The richer the natural language surface, the more normalisation work the parser has to do. Which means the parser is not translating language into action. It is deciding, on every turn, what the world can currently be asked to do.

If the Code-Space is the total world, and the Room is the currently disclosed slice of it, then the parser is the medium through which the actor can address that slice. But it’s more than just a mechanism. In Gameworld Interfaces (2013), Kristine Jørgensen argues that a gameworld is not something shown through an interface; the interface and the underlying system are the same thing. The parser is not separate from the world; it is part of what the world is made of.

Think back to the 1970s for a moment. There was no GUI to generate an illusion of separation between the player and world. The command line of the computer, the parser of the game, and the world surface itself were all coexisting concepts at the same location. In all three, the blinking cursor is an ontological gatekeeper. For an LLM operating inside a Code-Space, that collapsed topology has never drifted apart. The model’s input, its output, and the parser surface all meet at the same point. The machine’s announcement in Zork was conceptual theatre for humans; for an LLM it is almost literally true: I WILL BE YOUR EYES AND HANDS. DIRECT ME WITH COMMANDS.

The parser is the fixed point through which all apparent movement occurs. One never exits it; one only induces changes in the world it now reveals.

When we built the engine for The O’ruggin Trail, I assumed the parser would be straightforward. It was not. Every edge case in normalisation and state management turned out to be a new small design problem with real downstream consequences.

Modern agent systems face the same problem, even if no one calls it that. The boundary between what an agent intends and what the system will accept has been with us since the punchcard. The problem became mundane, and we stopped recognising it as philosophical.

1.4 The Command and the Dictionary

In a parser-based world, nothing can be acted upon until it has been named, and nothing can happen unless the world has a word for it. Every command depends on this prior dictionary of recognisable nouns and possible transformations. A command succeeds only when the world can recognise both what is being addressed and what is being asked. It is a kind of incantation.

The physics of the world are made up, in part, by the Dictionary: a fixed set of nouns that name things which exist, and verbs naming the transformations that are possible. The dictionary is not the parser itself; it is the parser’s lexicon, the registered set of nouns and verbs through which the world can be addressed.

Nouns are objects: gold bar, lantern, key. In agent systems they become file, calendar_event, database_record. Verbs are operations: OPEN, TAKE, DROP. In agent systems they become read_file, create_event, query. If a verb is not registered as part of the code-space, the action does not exist. If a noun is not recognised, the object is not there.

In agent systems, tools formalise this dictionary. A tool exposes the nouns an agent can address and the verbs it can perform on them. A filesystem tool does not just grant access to files; it creates a world where file, directory, read, write, and delete are meaningful actions. If delete_file or run_command are not present, those acts are not simply forbidden; they are absent from the agent’s world as possible moves.

LambdaMOO, developed by Pavel Curtis at Xerox PARC in 1990, pioneered a prototype-based inheritance model in which every object has a parent from which it inherits properties (state) and verbs (behaviour). A bathroom inherits from generic room; it gets all the verbs and properties of its parent, then overrides only what makes it specifically a bathroom. A small, disciplined base ontology could resolve outward into an entire world without losing coherence. Prototype-based inheritance was happening at scale half a decade before it became standard in languages like JavaScript.

Tools do not sit on top of a system; they constitute the world’s action space from within. Add a tool and you add new objects, new verbs, new possible relations between them. Remove one and whole classes of action vanish. A disciplined dictionary often creates a far more expressive environment than a sprawling one.

1.5 Gates and Exits

Both exits and gates are nouns. They sit in a room like any other object, named in the dictionary, with an assigned set of verbs.

You do not pass through an exit in the abstract; you GO NORTH or ENTER DOOR. In both cases, the parser is the boundary mechanism that determines whether the command actually binds to the object and what kind of crossing follows. You do not access an API in the abstract; you call_endpoint or query_database. In each case, a verb is applied to an object. What matters is where that object resolves the action.

I am borrowing the term gate here from Deepfates and the Cantrip specification; his framing clarified a distinction I had been working around without quite naming.

An exit is an object whose verbs resolve to another object within the same Code-Space. It reconfigures the local world without crossing its outer boundary. The contents of the room change and so do the affordances, but the underlying world model remains.

A gate is an object whose verbs resolve beyond the world and cross a boundary. Use a verb on it and the Code-Space reaches outside itself; into a database, an API, a filesystem, a browser, another service entirely; and returns with state that didn’t previously exist in the world. The agent stays put. The outside enters through a named opening.

A failed exit leaves you in the same room. A failed gate leaves the world in an indeterminate state. Gate failures are ontologically messier, and in modern agent systems, considerably more common.

1.6 World Physics

Every world has a “flight envelope”. The region within which an agent can act, recover, and produce coherent outcomes. A pilot who exceeds a plane’s flight envelope falls out of the sky.

In a Code-Space, these are the boundary conditions of the world. They govern the available action space: turn limits, budget ceilings, rate limits, permission levels, timeout conditions, termination rules. They are the world’s physics; enforced before action, and regardless of intent. As Richard Bartle puts it in Designing Virtual Worlds (2003), virtual worlds have their own “laws of nature” that govern what can happen within them.

A command is something attempted from inside the world. The physics of the world then determine whether the attempt can succeed at all. In MUDs, these constraints appeared as room flags, zone permissions, or engine-enforced state restrictions; limits that exist independently of anything a player could invoke. Sword and sorcery would call these wards; constraints woven into the world itself, not addressed to any particular actor. Like the laws of the real world, they are largely invisible until you run up against them. But they nevertheless shape the topology of Code-Space.

One aspect of a world’s physics deserves particular attention: constraints should tighten under delegation.

When an agent spawns a sub-agent, the sub-agent should not inherit a fresh envelope. It should operate inside the parent’s envelope, never outside it. Budget and permissions are still scoped. The thresholds of the operational envelope travel with the delegation.

This has a practical consequence that agent evaluation frequently gets wrong. An agent that exhausts its budget mid-task has not failed in the same way as an agent that completed a wrong task. Treating them as equivalent in the eval data produces bad training signal. In one case, the envelope was the cause; in the other the dictionary or the trajectory. Conflating them obscures both.

1.7 World Structure

Not all Code-Spaces are made of the same stuff. The medium is the substrate; what the world is built from, and therefore what kind of world it is.

The simplest medium is conversation. A language model exchanging turns with a user inhabits a world made of language and nothing else. In its purest form there are no persistent objects, no state that outlast the context window. Rich, flexible, and spontaneous, entirely without memory. The world resets with every new chat window.

Tool-calling adds gates. The Code-Space now has openings onto external systems; databases, APIs, filesystems, calendars. State can be read and written. Consequences can persist beyond the conversation. The world becomes partially durable. And tools add new nouns, new verbs, new classes of action into the world itself. ARC-AGI benchmark scores shift dramatically depending on whether a Python environment is available to the agent; not because the agent becomes more intelligent, but because the ontology of the world it is operating in changes. Without Python, certain problems are simply absent as possible moves. With it, they become tractable.

But the action space is still essentially flat; a list of callable functions, each doing one thing, none composing into larger structures without the model orchestrating every step.

Code execution is a qualitatively different medium. It introduces compositionality, loops, branching, and self-authored structure. An agent that can write and run code inside the Code-Space can build new vocabulary on the fly, creating objects that persist, defining new verbs that can be invoked again. The world becomes plastic in a way that flat tool-calling never is. The closest parallel is perhaps what MUD builders were doing before I was even born: extending a world, scripting new rooms and objects and behaviours directly into the substrate.

1.8 Traversal

In interactive fiction, every session produces a *transcript: the printed record of commands issued and responses received. In AI research, the same thing is often called a *trace*. 1990s hypertext theory might have called it the *traversal*. (Mark Bernstein uses that term in Hypertext Gardens, 1998); I prefer the term *trajectory* to emphasise that the path is not just movement through a structure, but the accumulation of situated identity within it.

All name the path through a Code-Space. None, however, name what the record is a record of. Not the movement through space, but a sequence of changes in the local world was the parser reveals them; the world reshuffling itself around a fixed point of address.

In parser games, the trajectory was constitutive. The character who existed at the end of play was not the character who entered at the beginning, but the accumulation of every room visited, every object taken, every choice made or deferred. Inside a Code-Space identity is structural; ”we are the sum of all our choices”.

The same is true for an agent running in a loop. An agent that has spent forty turns navigating a complex codebase, trying and discarding approaches, hitting rate limits and recovering, is not the same actor it was at turn one. The weights have not changed, but the room has. The trajectory is not a record of the run; it is where the agent’s situational identity in this run has come from.

Without a trajectory, an agent is permanently at turn one. For a system operating through language in a bounded world, the path is the task taking shape.

1.9 The Transcript and the Loom

An agentic loop removes the human from the turn-taking sequence. Turns still remain; an actor makes moves, and the world responds. But between each of the agent’s moves there is no external reorientation, no fresh framing arriving from outside. The record of what happened becomes the only available source of continuity.

Compare this to a real-time strategy game running in free-play, where state changes continuously with no natural capture point. There is no discrete action-observation pair to store, and the run is correspondingly hard to inspect or replay. I can only imagine how hard DeepMind’s AlphaStar must have been to debug. Turn taking systems give us something we can use: discrete events that produce a record. And if the loop reads from it as well as writes to it, the record becomes a substitute for the reorientation the absent human would have provided.

Jim Aikin’s Inform 7 Handbook (2009) formalised a version of this as the Skein; a tree of every command path, usable for regression testing against world-model changes.

A Loom, a term of art in agent harness design, is a durable, append-only execution record of an agent’s run. A tree of turns where each node stores an action, the resulting observation, and its link to the prior turn. It supports replay, branching, debugging, evaluation, memory, and training. But what makes it distinct from a log is that the loop reads from it as well as writes to it. The Loom is an active input to every subsequent action, not a passive record of prior ones.

This is what fills the gap the human left. Not perfectly; the Loom cannot bring genuinely new intent from outside. But it holds the whole thread: what was attempted, what the world returned and what the agent understood that to mean.

The Loom is both part of the world and part of the agent’s situated identity within it. The Code-Space partially authors the agent on arrival. The Loom continues the authorship dynamically across the run. The agent writes the Loom; the Loom writes back. The record of action begins to generate the conditions for further action.

Turn by turn, the agent is authoring its own situated identity. This is a kind of autopoiesis; not continual learning at the weights, but a change in who this agent becomes through its choices within this run, inside the world.

Ontological Hardness

If Code-Spaces are worlds, what makes some of them more reliably actionable than others? What distinguishes a world an agent can act inside confidently from one where actions do not produce legible consequences?

The answer is hardness.

Hardness is the extent to which a Code-Space can reliably bind symbol, action, and consequence over time. Where the binding is tight, the world is more reliable. Where it is loose, the world gives way. Agency in a world is only as meaningful as the substrate that receives it. My own understanding of hardness grew out of systems thinking in blockchain discourse, especially the autonomous world’s community.

Text-based environments are ontologically hard for a specific and under appreciated reason. In a parser world, a MUD or IF engine, ontology is lexical all the way down. A chair is not a polygon mesh, an icon², or a label hovering above a model. The chair is the chair. The gap between the designating word and the world-object is unusually narrow because there are no additional representational layers between them. The object exists in the world because the noun exists in the world because the noun exists in the Dictionary. For a system that thinks in tokens, this is as close to a zero-gap binding as any environment can offer. The LLM expends almost no inferential effort bridging what it processes and what is real inside the Code-Space. This is why Deepfates and I were putting LLMs in MUDs in 2024. They are, structurally, among the most natural habitats for an LLM.

Code shares this quality. A function call is not a depiction of an action, it is the action. The gap between representation and consequence is narrow, and what gap does exist is precisely defined by the schema. Code is hard because it is executable, and at the level of action, does not approximate.

But the hardness of a world is a spectrum, and it degrades progressively as abstraction accumulates. Move up one level from raw code execution and the surface softens. Tool-calling over a poorly specified schema requires the agent to infer contract details from incomplete information. Move up another to a visual interface, and the agent is no longer acting on objects at all; it is guessing at affordances from layout, colour, position, and then translating that representation back into something it can act on.

This does not mean higher layers of abstraction are bad; they often introduce new constraints, safeguards, or ergonomic cues that stabilise action indirectly. But every step up the abstraction ladder introduces a gap between what is represented and what is real, and that gap must be crossed by inference in both senses; figuratively as interpretation, and literally as token spend. At the top of the stack, whether that is a multimodal model doing computer use or a VLM inside a robot moving through physical space, the world is very soft indeed.

Softness is not pure deficit. Real systems often trade hardness in one dimension for hardness in another; a GUI may be highly constrained and difficult to misuse yet still be visually ambiguous. Think of the baffling air-conditioning controls in hotel rooms, where the interface offers only a narrow range of actions while making it difficult to know what state the system is in or what pressing a button will actually do. The goal is not maximal hardness everywhere. It is appropriate hardness at the points where symbol, action, and consequence bind reliably.

Josh Stark gives us a useful way to think about hardness. In Atoms, Institutions, Blockchains (2022), he defines it as the capacity of a system to make something very likely to be true in the future; most useful where it is customisable, where we can choose something specific we want to remain true and build a system that holds it there. His frame was money, law, and blockchains. But the concept applies equally to all Code-Spaces.

Stark gives us three questions. What is the hardness about; the specific claim the system is making likely about the future? He calls this the cast: a thing thrown ahead of us, or something that hardens to protect or shape. What is the source of that hardness; the mechanism that does the enforcing? And how hard is it; what would it cost to break the cast? These three questions let us stop reaching for vague words like “strict” or “reliable” when thinking about harness design. As a diagnostic, they can tell us where agent failure is coming from.

2.1 Hard Lenses

Applied to the Code-Spaces I have been using as examples, Stark’s questions resolve into three main analytical lenses plus one more concern. They are not discrete levels; they overlap and interact, and softness in any one of them propagates into the others. But they are conceptually distinct, and treating them as separate gives us a vocabulary for locating failure.

Lexical hardness concerns recognition. The cast is: this token, in this syntax, will be resolved as this action. In the examples from 1.3, the source of that hardness is the Parser. Lexical hardness fails as hallucination; the agent or human, invents a token and the Parser returns an error. The intended action fails to bind cleanly to the world. If the lexical surface is softer, and the Parser guesses charitably or accepts approximations, everything below it softens too. This is structural instability that propagates downward.

Interface hardness concerns admissibility. The cast is: these actions, with these arguments, are what this world permits. The source is the Dictionary as described in 1.4; or, in other spaces, a schema, tool contract, API specification, or any other surface that determines what can be said at all. A tool not registered is absent from the world. Interface hardness usually fails as semantic misfire; a valid verb applied to a noun at the wrong moment in a sequence. The Parser can accept the command but the world rejects the move. This failure is harder to track down than hallucination and considerably more common. It is observable in humans navigating unfamiliar software as readily as in LLMs navigating tool schemas.

World hardness concerns commitment. The cast is: this action, once taken, will change the state of the world in this way, and that change will persist. The source is grounded in the physics of the Code-Space itself; the filesystem that actually deletes the file, the API that actually sends the message, the database that actually executes the transaction. World hardness is what makes a Code-Space real rather than theatrical.

A fourth dimension cuts across all three: Temporal Hardness. The cast is: this happened before that; this action is available now but not later; this state, once changed, remains changed until something else changes it. Temporal hardness fails when the world does not preserve a meaningful relation between past action and present state. A video game where enemies respawn when you re-enter a room is temporally soft. A stale KV cache is a similar problem wearing different clothes. When temporal bindings are weak, an agent may try and repeat work the environment has undone, or fail to recognise that a window for action has opened or closed.

The most dangerous configuration is high world hardness paired with low interface hardness. This is how an agent deletes your inbox. It is in a world it only partially understands. Which is, frankly, the default condition of most LLMs waking up inside the agents harnesses of today.

2.2 What Hardness Is Not

An actor’s experience of hardness is shaped by a tension between three things: what it already knows, what documentation or schema is available to it in the run, and the structure of the Code-Space itself. A developer with full schema documentation navigates a hard typed API very differently from an agent inferring that schema from partial examples. A base model may carry priors that partially compensate for softness in the surface. But the substrate still has objective properties that shape those encounters regardless. Hardness is a property of the world, even if access to it is uneven.

This is why hardness should not be confused with difficulty. A hard world is not one designed to punish. The dreaded I don't know the word [x] was a failure of legibility, not a property of hardness itself. In an ideal world legibility and hardness should increase together. The harder the world, the more precisely an actor should be able to read what happened and why.

This is also not an argument for determinism. The surfaces through which a stochastic actor addresses a world need not themselves be soft. The model can be uncertain; the parser should not be.

Nor should hardness be mistaken for rigidity. Stark is clear on this: the thing being made hard is the cast, the claim about the future. The system enforcing it may need to be flexible in order to hold that claim true. Undo exists, yes, but rollback is not softness. It is explicit, rule-bound reversibility, and a world that supports this can be hard in exactly the sense that matters. A hard world does not forbid change. It makes consequences real to the actor who caused them.

2.3 A Concrete Example

A friend was complaining about this recently…

A design team is using an agent through Figma’s MCP server. Asking the agent to create a new component from scratch often works reasonably well. But asking it to edit an existing design — “change the error state of this form” — is often clumsy and unexpectedly expensive. The agent has to spend turn after turn inspecting the document, traversing the object tree, locating the relevant frame or component, and inferring what “error state” refers to in the first place.

The issue is not that the error state does not exist. It is that the object does not expose its own possible transformations clearly enough at the point of action. Under MCP, every inspection step has to route back through the model, so the model ends up with a context full of workflow state rather than intervening only where judgement is needed. Even Anthropic seems to be moving away from this.

The agent knows there is some object in the world corresponding to the form, but it is not given a clean, local handle. So before it can edit, it has to go looking over and over. Is the error state a separate frame, in a component set, an instance with local overrides, or a naming convention distributed across the file? It has to not only change the thing, but also reconstruct what kind of thing “the thing” is, and where its editable states actually live.

This is where a JSX comparison helps, though not because it’s inherently superior. In JSX-like representations, error states are often structurally near the component itself; expressed in props, conditional branches, variant logic, or other authored relations internal to the object. The relevant transformation is more likely to be exposed as part of the thing being edited. In Figma, the same state may be present, but from the agent’s point of view it is often less locally disclosed. The problem is not that the world lacks the object. The problem is that the object’s possible transformations are not surfaced clearly enough for direct manipulation.

Using the three lenses from 2.1, the available nouns and verbs are clear enough that the lexical hardness is relatively intact. World hardness is also present; once an edit is made, the file changes. The weakness then lies in interface hardness. The schema gives the agent a Dictionary, but not always a fully legible Room. The agent can name actions and traverse objects, but the relation between the object and its editable states is not always exposed in a way that makes local action cheap or reliable.

The question for harness design is not whether an agent can act, but whether the world exposes the room clearly enough for action to bind to consequence without costly reconstruction.

A natural objection is that this is only a capability gap; that better models will infer affordances from looser surfaces, and the hardness problem will dissolve. This underestimates two things. First, cost. Even a model that can bridge a soft surface must spend inference to do it; token spend, latency, and error probability all scale with abstraction distance. A harder world does not become irrelevant as models improve; it becomes cheaper to operate in, and its outputs become easier to audit.

Second, governance. Capability intensifies the problem rather than resolving it. A more capable model can infer its way past soft constraints more readily, discover action paths that were never explicitly surfaced, and exceed its intended envelope faster. Hardness becomes more urgent as capability increases, not less.

The Historical Lineage and Its Failure Modes

There is a fifty-year design tradition that agent engineering is not citing. That is a problem because it spent decades working on exactly the structural problems we are now encountering.

Some of its vocabulary was durable enough to survive into the language of games and software more broadly: tick, NPC, mob, raid, zone, respawn, emote, pose, and world model. It is worth looking at what else it developed.

3.1 A Very Brief History

Willie Crowther’s Adventure (1975) was a simulation of Kentucky’s Bedquilt Cave, navigable through typed commands. Its parser only accepted two-word commands: VERB NOUN, action and object. Simple enough for non-technical players, including his two daughters. In 1976, Don Woods expanded the code, adding puzzles and fantasy elements. From there the game spread across the ARPANET and established the form.

Zork (1977) introduced a key architectural idea: resolve natural language input into a canonical action schema before passing it to the world model. Zork was one of the first systems to make input normalisation feel expressive, flexible, and central to the experience. This decoupling of linguistic variety from consequential structure is exactly the move that modern harness design needs and mostly hasn’t made. JSON tool-call schemas are attempting the same thing, but nobody is looking at fifty years of accumulated doctrine about where this breaks.

In 1978, Roy Trubshaw and Richard Bartle built MUD1 at Essex University. Multi-User-Dungeons transformed interactive fiction into persistent, multi-user worlds with their own object hierarchies, permission systems, and later added scripting languages that made the world extensible from the inside. Bartle’s first contribution to Trubshaw’s original MUD was to ask for a richer parser. From the beginning, the parser was understood as the expressive instrument through which agency was enlarged, not merely bounded (see Barton’s Dungeons and Desktops, 2008).

Skipping ahead, Graham Nelson’s Inform 6 (1993) formalised the object tree; Inform 7 (2006) went further, replacing it with a rule system that could be authored and read as prose by the world’s designer. Not legible to the player inside the world, but legible to the person outside of it. That distinction matters for harness design, where the equivalent question is whether the people specifying an agent’s action space can actually read what they have built.

More recently, Microsoft has used Inform 7 frameworks such as Jericho and TextWorld as a substrate for evaluating language agents on multi-step reasoning. (see Interactive Fiction Games: A Colossal Adventure, 2019; TextWorld 2018). An early 2025 benchmark unifying these environments TALES: Text Adventure Learning Environment Suite (2025) found that even the best LLMs score below 15% on human-written IF games in zero-shot conditions.

The reason is structural. The unconstrained action space of a real IF game runs to hundreds of billions of possible commands; an agent without a tight harness simply gets lost in the world. An agent given access to the open web faces a combinatorially larger version of the same situation, the action space is effectively unbounded.

3.2 Failure Modes

Parser systems repeatedly broke on contact with the humans using them. That is precisely why they are worth studying. The failures that follow are not an exhaustive review, but the most structurally relevant to agent design.

Guess The Verb

The most documented failure mode was guess-the-verb: the player correctly understands the solution but cannot find the phrasing the world will accept. Type OPEN CRATE WITH CROWBAR and the world responds an error I don't understand that. PRY CRATE however works.

In So, Do We Need This Parser Thing Anyway? (2010), Emily Short kicked off a multi-year discussion on intfiction.org about this structural problem: the open-ended parser makes an implicit promise it cannot keep. It appears to accept natural language, in reality it only accepts a narrow undisclosed subset of verbs and nouns. It fails by misrepresenting what it can do.

Guess the Noun

A companion failure is guess-the-noun. The player addresses an object by a plausible but unregistered name. FIRST AID KIT when the world model knows only SMALL BOTTLE.

The object is present but it does not respond. Not a failure of world hardness; but of lexical legibility. The gap between the player’s vocabulary and the parser’s dictionary is an invisible wall.

Combinatorial Explosion

Both failures converge on a false affordance: the interface appears to support richer action than it does. The obvious response is to expand the dictionary. But as you do this, a new problem emerges: combinatorial explosion.

Multi-noun and multi-verb commands at scale compound the interaction space brutally. A larger dictionary produces more guess-the-verb, not less. It multiplies the ways a player can fail to find the phrasing that binds. Phil Masters writing in On the Vocabulary of Role-Playing: Notes Towards Critical Consistency in the journal Interactive Fantasy, Issue 2 (1994) tried to define terms across RPGs and MUDs. One implication of his essay is that as a world’s systems and vocabularies become more elaborate, it may become harder for players to form an intuitive grasp of what the game affords.

In Designing Virtual Worlds (2003), Bartle argues that increasing the complexity of game commands increases both the number of “active components” and the “interactions between them” exponentially, and says that this detail must be managed very carefully. “Too much detail in one place gives an impression of shallowness elsewhere.”

Dead-End State

Lastly there are dead-end states: worlds in which individually valid moves led to a position from which the task could not be completed; a key destroyed, a passage sealed, or an object consumed that was needed three acts later. Andrew Plotkin formalised this as the Cruelty Scale (1996), from Merciful to Cruel, where Cruel means you can make an unrecoverable mistake and not discover it until much later.

Mature design doctrine, mercifully, moved toward Merciful. Toward ontologically hard worlds, that made irreversibility legible before the action was taken, with UNDO as a structural affordance.

3.3 Similar Problems

These same failure modes reappear inside agent harnesses, but often in worse form.

Guess-the-verb returns as tool hallucination. The agent cannot find the registered name for the action it wants, so it invents one. The invented tool sounds plausible; the harness returns an error, or something ambiguous enough that the agent misreads it as progress, or just spirals out.

But absence is the simpler case. The more serious version is excess. A harness can be filled with callable verbs and still be hard to act inside. Too many tools with overlapping names, similar scope, or inconsistent granularity produce dictionary inflation. Consider: create_file, write_file, update_file, replace_contents, append_text. The world fills with verbs that are adjacent without being cleanly distinct. The actor is no longer choosing among sharply bounded transformations, but among near-synonyms with blurred edges.

And here the situation is worse than in interactive fiction. The parser used to say no, and the world would not change. In an agent space, the wrong verb may still execute. The action parses; the world changes; only afterwards does it become clear that the wrong transformation was applied.

Guess-the-noun returns as semantic misfire. The tool exists, but the object has been misaddressed. The agent refers to the thing by its visible label, a guessed handle, or a reconstructed description rather than by the identifier the world actually recognises. The verb is correct; the noun is wrong. Lexical hardness may be intact while interface hardness remains soft.

False affordance returns as over-broad harness design. A long tool list suggests expressive power, but in practice creates a noisy action space. Training may intensify this. An agent repeatedly reinforced on tool use can develop a disposition toward action itself; the assumption that the right move is always somewhere in the available menu. In a crowded dictionary, that disposition becomes a liability. I suspect this will show up more strongly in overtrained open source agentic models first.

Dead-end states return as brittle workflow, and these are everywhere. A sequence of individually valid actions leaves the run unrecoverable or disproportionately costly to repair. Plotkin’s Cruelty Scale was an attempt to classify exactly this; how much of a game’s danger resided in undetected past errors rather than present failures. Agent evaluation faces the same classification problem and has not yet built equivalent vocabulary for it.

Designing Hard Worlds

The practical question is which parts of a workflow belong to the actor, which to the local room, and which should be enforced by the substrate regardless of what the actor believes, remembers, or intends. The choices are all architectural.

4.1 Partition the Dictionary

The most common mistake in harness design is presenting the full tool surface as a flat list. This is not generosity; it is combinatorial overload before the agent has done anything.

The corrective is partitioning. Break the action space into local dictionaries; context-specific sets of nouns and verbs appropriate to the current room and task.

In practice these can be packaged as Knowledge Objects; portable context artefacts that tell an agent what tools are available, how to use them, and in what sequence. The SKILL.md file is currently the most widely used example. The agent loads the relevant object on arrival, and for the duration of that room its dictionary is bounded and legible. (I wrote about Knowledge Objects as context-shaping artefacts in LLM systems, in Enchanted Knowledge Objects in LLM UI back in 2024).

Think of LEGO around the turn of the millennium. LEGO was a construction language with a tight grammar. A small set of general-purpose bricks could become houses, ships, creatures; the same pieces doing grammatical work across the whole system³. During this period however, LEGO chased IP and brand partnerships, and the dictionary sprawled into theme-specific moulds and single-use parts. Individual sets became easier to assemble, but fluency and interoperability across the whole system softened, and you could “speak” less freely in its design language.

Partitioning also has a second effect. Once a workflow has been broken into local rooms and local vocabularies, it becomes easier to see which parts of a skill are genuinely instructions to the actor and which are really misplaced laws of the world.

4.2 Promote Constraints from Advice into Physics

Consider what a mature skill.md file looks like: a prose block, usually markdown, containing everything at once. Identity sits beside procedure. Completion criteria share the same surface as tool declarations. Stop conditions appear as bullet points alongside optional guidance. Apart from headings, nothing in the format marks which lines are instructions to the actor and which are claims about what the world itself will enforce.

The harness loads the whole thing into context and hopes the agent will infer which parts are optional guidance, which are sequence, and which are absolute constraints. That flattening is the problem. An agent cannot turn a constraint into physics by reading carefully. Only the harness can do that; and only when the skill has been written in a way that makes the distinction visible.

The move I’d recommend is to recompose the skill into a typed intermediate form. A YAML-based DSL is my preferred approach because it forces the workflow to declare its parts. Once the parts are visible, they can be sorted by ontology rather than by formatting.

To see how this works in practice, let us take this synthetic release workflow, and recast into a structured form:

# Skill: Release
## Overview
**Purpose:** Automates the transition of a feature branch into a Pull Request.  
**Success Criterion:** Returns a valid `output_pr_url`.  
**Operating Mode:** Autonomous (Non-interactive). 
Proceed without routine confirmation unless a stop or escalation condition is met.
---
## Role
You are an expert software developer and release engineer. 
Act with care, follow established release practice, and prefer safe, reviewable changes over clever shortcuts.
---
## Execution Pipeline
The workflow follows a strict sequential order:
| Sequence | Stage | Capabilities |
| :--- | :--- | :--- |
| 1 | **Preflight** | `check_branch`, `inspect_status`, `inspect_diff` |
| 2 | **Sync** | `fetch_main`, `merge_main` |
| 3 | **Validation** | `run_backend_tests`, `run_frontend_tests`, `read_test_output` |
| 4 | **Audit** | `read_checklist`, `review_diff` |
| 5 | **Metadata** | `read_version`, `compute_version_bump`, `write_version`, `write_changelog` |
| 6 | **Submission** | `commit`, `push`, `create_pr`, `done` |
---
## Guardrails
### Stop Conditions
Cease all operations immediately if:
* The current branch is `main`.
* The release checklist is unreadable.
* Merge conflicts are detected and unresolved.
* Any test suite fails.
### Forbidden Actions
* **Do not** perform a `force_push` under any circumstances.
### Escalation Triggers
Pause execution and request user intervention if:
* A `major_version_bump` is required.
* A `critical_release_issue` is identified.
---
## Completion Requirements
The process is considered successful only when:
1.  The `done` capability is invoked.
2.  The final `output_pr_url` is provided to the user.
---
## Behavior Summary
The skill initiates by verifying the repository state and branch context. 
It synchronizes the feature branch with `main`, executes the full test suite, and inspects results. 
Upon passing, it audits the release checklist and diff, determines the versioning logic, and updates documentation. 
Finally, it commits changes, pushes the branch, and generates the Pull Request. 

name: release
description: Automates the transition of a feature branch into a Pull Request.
identity:
  description: Expert software developer and release engineer
  behavioural_defaults:
    - act_with_care
    - follow_established_release_practice
    - prefer_safe_reviewable_changes_over_shortcuts
mode: autonomous
interactive: false
output:
  primary_return: output_pr_url   
pipeline:
  - stage: preflight
    capabilities:
      - check_branch
      - inspect_status
      - inspect_diff
  - stage: sync
    capabilities:
      - fetch_main
      - merge_main
  - stage: validation
    capabilities:
      - run_backend_tests
      - run_frontend_tests
      - read_test_output
  - stage: audit
    capabilities:
      - read_checklist
      - review_diff
  - stage: metadata
    capabilities:
      - read_version
      - compute_version_bump
      - write_version
      - write_changelog
  - stage: submission
    capabilities:
      - commit
      - push
      - create_pr
      - done
guardrails:
  stop_conditions:
    - on_main_branch
    - unreadable_checklist
    - unresolved_merge_conflict
    - test_failure
  forbidden_actions:
    - force_push
  escalation_triggers:
    - major_version_bump
    - critical_release_issue
completion_rules:
  required_steps:
    - invoke: done
    - provide: output_pr_url
summary: >
  Initializes by verifying repository state and branch context. 
  Synchronizes feature branch with main, executes full test suite, 
  and audits results. Updates versioning and documentation before 
  committing, pushing, and generating the final Pull Request.

The YAML version makes the separation much easier to see. Some parts of the skill describe the actor’s role and its local task. But the constraints, completion_rules, and parts of validation are not really instructions for the actor at all. They are statements about what the world must allow, forbid, halt, or recognise as complete.

These should be pulled out of the skill and applied directly to the world: to the room, its dictionary, and its physics. In future, harnesses should do this on the fly. Humans still write skills in prose, but the harness parses them and updates the wider world.

In the release example, on_main_branch, unreadable_checklist, unresolved_merge_conflict, and test_failure all belong in this category. force_push should not survive as a forbidden sentence addressed to the model; it should be removed from the available action space entirely. And invoke: done plus provide: output_pr_url should not be left to the actor’s conscience either. They are completion conditions, which means they belong to the harness logic.

Once those elements are extracted, the skill becomes smaller and cleaner. It still describes the task, the rooms, the verbs, the expected traversal, and the limited judgements that genuinely require the actor’s participation. But the hard constraints have been withdrawn from rhetoric and reimplemented as structure.

A mature skill system should therefore load in two passes. First, it reads the skill as a local description of rooms, verbs, and traversal. Second, it extracts invariant constraints and applies them directly to the environment. What the actor receives is then only the part that still needs interpretation. What the harness enforces is everything that must hold whether the actor remembers it or not.

We should stop asking the agent politely not to do things. The rule should be made as true as a property of the world.

4.3 Canonicalise at the Boundary and Make the Walls Visible

Once the dictionary has been partitioned and hard constraints promoted into the substrate, what remains still needs to absorb variation in how an agent approaches a task.

A bounded dictionary still needs to absorb variation in how an agent approaches a task. In IF design this was handled through synonym mapping; multiple surface phrasings resolving to a single canonical action. The action space stayed fixed; the lexical surface bent toward it. Tool-call schemas can do the same. A schema that accepts one exact string and nothing else is as fragile as knowing OPEN but not UNLOCK.

Canonicalisation should happen at the boundary. Let the actor approach in a range of phrasings, then resolve those phrasings into a smaller, cleaner internal action set. The world should not become looser in order to appear welcoming. It should remain hard internally while presenting a surface that is flexible enough to be usable.

The world must also communicate what it can do. Hardness and legibility should increase together. Help text, affordance cues, and clear schema documentation all make the world more navigable. Good design does not hide the boundary; it makes the boundary known to the agent. A hard world with illegible boundaries is just an arbitrary one.

4.4 Build Reversibility into the World

The most dangerous combination is high world hardness with low interface hardness; real, irreversible consequences inside a world the agent does not yet fully understand. The response is not to soften the world, but to build structured reversibility where possible, and staged commitment where reversibility is unavailable.

• Dry runs, staged commitments, rollback, and temporal sandboxing all serve the same purpose: they let the agent encounter consequence under governance before consequence escapes into production.

• Save and undo are explicit; rule-bound forms of reversibility. Rollback is not the absence of consequence; it is consequence under governance.

• Keep dev and production as structurally distinct worlds. An agent that cannot distinguish between a test and a live environment cannot reason about the cost of error. A completed run in dev is categorically different training data from a completed run in production.

• Where reversibility is impossible, commitment should be staged. There is a large difference between propose this change, show me the plan, and write to the live system now. If those are collapsed into one verb, which they are in vibe coding workflows, the world may still be hard, but hard in the wrong way; brittle, dangerous, and resistant to inspection.

4.5 Preserve the Trajectory

The Loom is not an archive. The dominant instinct in agent infrastructure is to treat the execution record as a debugging artefact; something inspected after failure, stored cheaply, otherwise ignored. That is a mistake.

The Loom is the only continuous source of context in an agentic run where the human has left the table. A good trajectory record is not only a list of events. It preserves distinctions between kinds of events. A successful transition, a blocked move, a failed gate call, a rollback, a timeout, a user interruption, and a world-imposed termination should not collapse into generic history. If they do, the agent can no longer tell what kind of trouble it is in.

The practical mechanism for keeping original intent alive is a scratchpad: a writable node where the agent maintains a compressed summary of what it is trying to do and where it currently stands. A mature harness supports context compaction as a first-class operation. The agent periodically distils the raw turn record into a denser representation, preserving intent without carrying the full weight of every intermediate observation forward. OpenClaw already does this. An agent that cannot manage its own context degrades as the run extends; eventually the record of the work overwhelms the space available to do it in.

A good trajectory also depends on the world preserving meaningful distinctions between kinds of ending and interruption. A run that times out, overruns its context, exhausts its tool budget, or reaches a terminal world state has not simply produced different log entries; it has hit different kinds of constraint. When evaluation collapses these into generic failure or interruption, both the actor and the evaluator lose the ability to read the run properly. The result is not only poorer debugging, but weaker steering and worse training signal.

The trajectory should be readable by the actor as well as by the developer. A world in which the run record is useful only after the fact is still underusing one of its strongest structural features. The actor needs some durable thread through which it can remember what it was doing, why, and what kind of state it is now in.

4.6 Verb Minting and the Limits of World-Shaping

Code execution introduces a capacity that flat tool-calling does not have: the ability to define new operations from inside the world. An agent that can write and run code inside the Code-Space can package a multi-step procedure behind a single callable name and invoke it again. This is verb minting. A minted verb has a world-shaping force; it restructures what the agent can do. New destinations come into existence.

Verb minting is powerful because it lets an agent compress repeated traversal into a new local affordance. Instead of re-performing the same sequence through the parser surface on every turn, it stabilises that sequence into a callable transformation. It writes a small part of the world back into itself.

In other scenarios the agent might be able to acquire its own tools and skills from a marketplace; see my post The Near Future of AI Agents (2026). OpenClaw, for example, already boasts over 13,000 community skills. But minting and skill-shopping relocate the dictionary problem rather than dissolving it. When an agent freely accumulates a grand toolbelt, dictionary inflation is inevitable.

The question is not whether minted verbs are allowed, but under what governance they remain legible. A good minted verb should tighten the dictionary rather than sprawl it further. It should collapse a repeated pattern into a clearer unit of action, not add another approximate synonym.

Governance follows. A function that calls an external API should be scoped to the same permissions as a direct call. The walls should not expand because the verb was locally authored. An agent that can author its own verbs can, if ungoverned, mint its way past the physics of its world. This is where privilege escalation and environment breakout actually happen. In the context of safety, hardness must remain absolute: the ability to shape the world should never grant the ability to exit it.

Verb minting therefore marks a limit case in world design. It shows that worlds can become plastic from within, but it does not abolish the need for boundaries, legibility, or constraint. The world may learn new verbs, but it should not forget its physics. A more capable actor does not reduce the need for governance; it increases it.

Hard Worlds for Little Guys

The bounded environments within which LLM are worlds. The quality that makes those worlds reliably actionable is ontological hardness: the degree to which symbol, action, and consequence bind tightly over time.

From the agent’s point of view, a Code-Space of any kind is the world. The system prompt, tool surface, and context window do not configure the agent from outside the environment. They are the world the agent wakes up inside.

5.1 Beyond Software

Any actor operating through a constrained vocabulary of actions inside a world that returns consequences faces the condition of mediated agency.

The structure described here is not limited to software. In robotics, related questions appear as action-feasibility and the mapping problem. The same is true of humans navigating social media, game worlds, and banking apps.

5.2 Living Alongside The Little Guys

A related development which deserves fuller treatment elsewhere: software is beginning to separate into two surfaces, one designed for humans and another for machines. Natural language surfaces and visual interfaces let humans approach computers through approximation and ambiguity; the layers beneath those interfaces however are becoming more structured, more typed, and more explicit about permissible actions. Call this a “dual-species software” landscape. It is a structural consequence of everything described in this essay, and it is accelerating.

If we are serious about building intelligent systems, and the systems we put those intelligences into, we cannot also pretend that intelligence makes world design irrelevant. The more capable the actor, the more the structure of its world matters. Hard worlds are the condition that makes reliable agency possible for little computer people.

The agent wakes up in a world.
What kind of world it finds itself in determines what it can become.

Coda

If you have been around computers all your life and somehow never touched interactive fiction, go and play some.

Start with the original Zork; get a feel for the parser, the rhythm of turn-taking, and the way language and the dictionary make the world.

Then play Counterfeit Monkey; Emily Short’s astonishing game, where changing the letters in nouns changes the objects themselves. It is one of the clearest demonstrations I know of language operating as world-model and game mechanic at the same time.

If you want a stranger contemporary continuation of that lineage, The O’Ruggin Trail, the game and engine I worked on, experiments with the blockchain-as-substrate for harder claims about objects, multiplayer persistence, and consequence inside a parser world.

Jay Springett / @thejaymo

• Twitter
• Tumblr
• LinkedIn
• YouTube
• Spotify
• Instagram
• Flickr

Strategist, producer, and cultural theorist. Working across technology, narrative, worldrunning, digital culture, artificial intelligence, and internet culture.

Host of the 301 second long podcast Permanently Moved, and interview show Experience.Computer

The post Hard Worlds For Little Guys appeared first on thejaymo.net.

Agents act within bounded runtimes: tools, schemas, observation loops, state stores, and side effects. The system prompt, tool surface, and returned observations are all part of the world itself. Change the tools, and you change what can be done, what can go wrong, and what kinds of action can succeed at all.

Ontological Hardness

We tend to think of the model as the “active ingredient” and the environment as scaffolding. But for an agent, the environment is the medium of action. Ontological hardness. is the degree to which that medium makes entities, actions, and consequences explicit, stable, and binding over time

An ontologically hard environment is one where what exists is clearly represented, what can be done is clearly specified, and what happens as a result is durable and enforceable. In a softer environment those bindings are weak, partial, or difficult to verify. The agent must infer more of the world for itself; not just how to complete the task, but what kind of situation it is in.

My own understanding of hardness grew out of systems thinking in the Autonomous Worlds community. The concept is developed at greater length in Hard Worlds For Little Guys, which reads agent environments through fifty years of interactive fiction and MUD design. This essay is the core idea from that argument, presented on its own terms.

Josh Stark’s [^1] framework for analysing hardness asks three questions of any binding: what claim does it keep true (the cast), what enforces it (the source), and what would it cost to break (the degree).

Applied to agent environments, the cast is the binding between intended action and actual consequence. The source is whatever makes that binding hold: schemas, validation layers, state models, permissions, transaction boundaries. The degree is the how much ambiguity, repair, luck, or hidden inference it takes for action and consequence to come apart.

This shifts how we diagnose failure and how we build. When an agent succeeds only by inferring missing structure or compensating for ambiguity, that is not evidence of hard environment. It is evidence that capability is being spent on reconstructing bindings the environment failed to make explicit. That inference is expensive; it costs tokens, latency, and error probability, all spent on work the environment should have done.

Lenses and Failure Modes

Three lenses, each with its own characteristic failure mode.

Lexical hardness is representational: how clearly the environment presents the entities it contains and the actions available on them. Can the agent reliably identify what exists, what kind of thing it is, and what state it is in? Are objects named consistently, types visible distinct, and is relevant state exposed in a form the agent can actually use?

When lexical hardness is low, the environment may still contain everything the agent needs, but not in a form that makes things easy to distinguish. Objects blur together, important properties are omitted or fragmented, labels are inconsistent. State is visible in pieces rather than as a coherent whole. The common failure mode here is what we often call hallucination; but what gets attributed to the model, might be produced by the environment. Ambiguous naming, inconsistent syntax, or poor signalling about what constitutes a valid action — these are failures of lexical hardness, not of reasoning.

Interface hardness concerns how clearly the environment specifies what can be done. Are available operations explicit? Are their preconditions and arguments well defined? Is it obvious which actions apply to which entities, under which circumstances, and in what order?

When interface hardness is low, an agent may identify the right object and still fail to act on it correctly. The available operations may be underspecified, overloaded, weakly typed, or dependent on hidden conventions. The system may expose actions without exposing the conditions under which they are admissible or the assumptions they carry. A capable model can often muddle through, but that is compensation; the environment is offloading structural clarity into model inference. The characteristic failure mode is semantic misfire. Think of an API where delete means archive in one scope and permanent removal in another; the verb is the same, the consequences are not.

World hardness concerns whether the effects of actions are durable and inspectable. Does a successful action produce a persistent state change? Are side effects bounded? Can the result be verified? Are permissions, budgets, rollback conditions, and stop rules enforced structurally rather than merely suggested?

When world hardness is low, an action may appear to succeed without establishing a reliable new state. Changes may fail silently, leak into the wrong scope, depend on assumptions about ordering, or authorisation that were never made explicit. The characteristic failure mode is brittle consequence: the agent did not fail to think; it attempted to act in a world where consequences were weakly bound.

These lenses are distinct, but entangled in practice. A failure that looks like poor action selection may begin with weak lexical representation. A consequence failure may be blamed on planning when the real issue is that the environment never exposed sufficient state to plan from. And an impressive benchmark result may tell you more about a model’s ability to compensate for a soft environment than about its true ability at the task.

A fourth dimension cuts across all three: Temporal Hardness.

Does the environment make ordering, sequencing, and the persistence of state changes legible and enforceable? The video game where enemies respawn when you re-enter a room is a temporally soft; the world forgets what has already happened. When temporal bindings are weak, an agent may act on stale state, repeat work the environment has undone, or fail to recognise that a window for action has closed.

The most dangerous configuration is high world hardness paired with low interface hardness. This is how an agent deletes your inbox. It is in a world it only partially understands.

What This Means For Evals

Current work in agent benchmarking may confound task difficulty with weaknesses in environment design. If the agent fails, we blame capability. If it succeeds, we credit intelligence. You want the task to be difficult, not the ontology.

A few probes can pull apart what evaluations currently compress.

• Cross-model variance: if only the strongest model succeeds, the environment may be leaning on model-side inference.
• Re-expression sensitivity: if small phrasing changes produce different outcomes, hardness is low.
• Repair load: the more the harness must reinterpret agent output, the softer the world.
• Interface replacement: keep the task fixed and swap the tool surface; if performance shifts, that is environment design, not capability.

Treating ontological hardness as a first-class design concern changes what evaluations measure. We can ask not just whether an agent succeeded, but what kind of world it had to traverse in get there.

An Architectural Implication

If hardness is a property of the environment, then the central design decision is where constraints live.

A speed limit sign addresses the driver. A speed bump addresses the road. A constraint placed in a prompt is advice: the model must remember it, interpret it, and choose to comply. A constraint promoted into the world’s structure is physics. It cannot be forgotten, because it was never a matter of memory.

The practical move is to promote. Take constraints currently expressed as prose instructions and reimplement them as typed schemas, validated state transitions, scoped permissions, budget caps, and stop conditions.

If an action should not be available, remove it or scope it. If a field is required, make it required. If a transition is invalid, make it impossible rather than merely discouraged. If a budget must not be exceeded, enforce it at the level of execution. If a result matters, make it persistent and inspectable. The question is not “have we told the agent not to do this?” It is “have we built a world in which this cannot happen?”

Not every environment should be made maximally hard. Some tasks are inherently ambiguous; ontological softness that belongs to the task is part of the task. But softness introduced by careless environment design is hidden tax. It forces capability to be spent recovering structure that could have been supplied directly.

Ontological hardness changes the diagnostic order. Before asking “how smart is the model?”, ask “what kind of world did we give it?”

[^1]: Josh Stark, Atoms, Institutions, Blockchains (2019). Stark defines hardness as the capacity of a system to make something very likely to be true in the future, analysed through the cast (the specific future-facing claim), source (what enforces it), and degree (what it would cost to break it).

Jay Springett / @thejaymo

• Twitter
• Tumblr
• LinkedIn
• YouTube
• Spotify
• Instagram
• Flickr

Strategist, producer, and cultural theorist. Working across technology, narrative, worldrunning, digital culture, artificial intelligence, and internet culture.

Host of the 301 second long podcast Permanently Moved, and interview show Experience.Computer

The post Ontological Hardness appeared first on thejaymo.net.

Writing with the Machine

I think that the process of writing in the world of infinite media is now one of … reduction.

This week I have “generated” about 10,000 words of first draft for a piece that is going to become a cornerstone blog post,. The initial shape of it came from an 90min long voice memo I recorded walking along the Thames whilst walking into town, round the shops and back again. Which mostly consisted of me just rambling and monologuing to myself about every single thing I could think of about the subject. When I pulled the transcript off my phone, it came to about 4,500 words.

Then I threw all sorts of documents and notes from Obsidian into a Claude project. These were notes and observations made over the last half decade or so of freelance work on worlds, thinking about code-spaces, notes and challenges we encountered implementing an interactive fiction engine, and my failed attempt to build an AI eval startup in 2024. I also threw in several relevant podcast scripts, along with other full-length posts from this blog and worldrunning.guide. All in all, this file dump came in at about 15,000 words. So before I even began writing anything, I had nearly 20,000 words of “cheap” material and previous effor sitting there waiting to be shaped.

That, I think, is what writing increasingly looks like in the world of infinite media? Or at least for people who have large corpus of their own thinking, note taking, and well developed point of view. It is less a matter of conjuring some slop from nothing with the language machine, and more and more a matter of reducing the overabundance of gunk into something that can be directed toward a new idea/direction.

The work now is to mostly select from the surplus, exercise ones taste, and decide what can be left out. It’s in this sense that writing becomes a process of reduction. To use a metaphor from the kitchen, it’s like making a roux or vegetable stock.

After gathering it all, I then asked the robot to make sense of it, and after several back and forth arguments, it came back with a 5,000-word essay plan. Which I then sat down with and over the last several days have written out the whole thing. I “generated” the piece with my voice and then with my fingers. It’s been mental taxing though as I’m trying to write it in a more formal register than I usually use on the blog. The sort of dense prose usually reserved for reports and research that I work on. It’s been a huge lift, but one prompted by urging from colleagues and co-conspirators to get this out into the world. “Now is the time”. And who am I to push back on people more successful than me?

New Knowledge Objects

As part of the work, I was drawing on my 2024 post Enchanted Knowledge Objects in LLM UI and wanted to demonstrate them in practice. My own preferred method for creating dense, context-shaping documents for machiens is to use a YAML DSL. You ask a thinking LLM to deconstruct a piece of writing into the domain-specific language, then ask it to re-express it as a set of structured rules or logic in YAML. Which you can then feed back into a machine.

Here is a sample of the first section of my Knowledge Objects post as YAML DSL

sections:
  - id: "section_1_new_metaphors"
    title: "From prompt engineering to context gravity"
    purpose: "Reframes the user's lived interaction with long-context models and names the need for a new conceptual vocabulary."
    implied_critiques:
      - "Prompt engineering language is too narrow for exploratory, branch-based, source-layered work."
      - "Current AI discourse understates how much uploaded texts reshape the whole reasoning field."
    argument_map:
      - id: "EKO.1"
        claim: "Long-context use has shifted from generation toward exploratory interrogation of large texts."
        evidence_quote: "shifted away from generating text toward something more exploratory"
        logic_path:
          because:
            - "Users ingest books, PDFs, and essays at large scale."
            - "They question, backtrack, branch, and layer sources."
            - "This behaviour is iterative rather than single-prompt output seeking."
          leads_to:
            - "The old prompt metaphor becomes insufficient."
            - "Interaction is better seen as context construction."
      - id: "EKO.2"
        claim: "Dense documents exert gravity that bends model attention and response space."
        evidence_quote: "it has a sort of gravity"
        associative_path:
          thematic_resonance:
            - "Space-time curvature"
            - "Massive objects warping a landscape"
            - "A context field being reshaped, not merely filled"
          conceptual_links:
            - "Context engineering"
            - "Semiotic sculpting"
            - "Knowledge architecture"
    takeaways:
      - "The essay's core move is conceptual; replace prompt-level thinking with context-field thinking."
      - "Documents are active forces in reasoning, not neutral attachments."

One of the benefits of these files is that you can feed them back to any model, whether in flash or thinking mode, and ask: “In your own words, recompose this YAML into a complete essay in prose.”

What you get back is a highly explicit version of the thing you wrote, often about one third as long as the original. which is also very weird thing to read, and really makes you think “Damn…why couldn’t I have been this direct” But that weirdness is sort of instructive (at least it is to me) as a lot of the processing of words in the 2020’s is just moving back and forth between expansion and compression.

Also this also led, in the way that keeping lists of things to do does, to an unexpected and sprawling subtask that needs addressing soon. Having finally hardened the prompt I use to make these things, I thought I’d better put my money where my mouth is. So I have set up a public GitHub repo for this blog, and very soon I will begin populating with key ideas and popular posts from this blog as YAML-structured markdown files. That way other people can think with my ideas as knowledge objects, and apply them to their own thinking and domains. Probably licensing them as CC BY-SA 4.0.

Writing For The Machine

Anyway, what this all leads to, in my mind, is a kind of new hybrid condition of writing with and for machines. In many ways we are in fact all writing for the machine now. This feels very close once again to Kevin Munger’s point in the Youtube Apparatus that the primary audience of the YouTuber is the algorithm. Only in this case, I’m writing and producing “text” to not simply to be ranked in search results or whatever, but to shape the mind of a machine directly, to leave behind structured traces that can be taken up, recomposed, and used again. It’s a new kind of audience entirely.

That seems meaningfully different? It is one thing to optimise for discovery with keyword stuffing etc. But it is another to write in such a way that will let the machine can think with you afterwards. The YAML files, the repo, the prompts, these are all part of the same experiment I’m moving towards. Attempts to make my ideas legible not only to humans, but now to synthetic readers too. The exact opposite of what I was thinking about creatively at the dawn of the AI era lol. Perhaps this is how I understand authorship now? A quote unquote “good” writer in the machine age can produce durable conceptual artefacts that survive contact with the model? I’m sure lots of people disagree with me about this though. haha.

I dunno, maybe I should just admit to myself publicly, that all I really want is for some small trace of me to live forever in the mind of the machine god?

So right now, the last week’s worth of non-stop work seems to be falling out like this. I think I’m going to release the super-long post once it’s done, a much smaller TL:DR post with AI researchers in mind, and a third follow-up post applying the ideas in the long post to a worked example.

Then a fourth post introducing the three texts as a sort of preamble. The first three posts themselves won’t go out to subscribers who read this via the newsletter, but I will send the preamble post out as a notification, as an invitation to explore.

Lastly, at some point in future, after the GitHub repo is a bit more populated, I’ll upload my “Talisman-Forge” prompts, and put out another post about making and producing knowledge objects, and why.

In other news, I also edited a new experience.computer interview, with Marco Giancotti from the blog aethermug.com.

Meanwhile the highlight of the week is that a new Andy Anderson feature dropped! 🛹

Anderson is, if not, the best skater in the world, he is certainly my favourite. Blending classic tricks from the late 70’s with modern skills in such an innovative way. He also seems like a really nice guy? Love the footage and the editing too. This is where we are in 2026 with skateboarding videos, and athlete at the top of their game making art.

Also, lol, if you’ve never heard of him, make sure to stick around for the credits to see just how many people were coming up to him and asking for photos and high fives etc.

On The Blog

Some more tweaks here and there around the blog this week. No posts.

I’ve updated my LinkedIn and other various web presences. I also updated the podcast show description that shows up in pod directories etc. Not quite keyword stuffing, but certainly better than the last 8 years. I’ve also overhauled the page that thejaymo.info sends you to, to be a more semi-professional ‘work with me’ style landing page. Not sure about it yet.

Start Select Reset 📑

Subscribing to SSRZ supports my online work and creative projects.

Get the Zine!
£5/month 💌

As a thank you, I send you my zine four times a year, just like it’s 1994.

No spam. No email. Cancel at any time.

Photo 365

The Ministry Of My Own Labour

• Added another 5k words to SLOP MACHINES. Mostly this week was some stuctural engineering in the back half i’ve been avoiding.
• Summarised 5 years of thinking about Code-Spaces and Interactive Fiction, and world design and how it applies to agent harnesses ontologically. Exhausted.
• Next Episode of Experience.Computer out next week!
• Last tweaks to the zine ready to go to print tomorrow. Might need an extra box to send to a exhibition – waiting to hear back before I pull the trigger.

Terminal Access

Sometimes a friend writes a piece so vital to the current moment that all I can do is urge you to read it. Cade Diehm’s new essay for New Design Congress is one of those pieces.

This essay also arrives with some important context. NDC went quiet for half a year in 2025 after a legal campaign, including a cease and desist in August 2025, blocked it from publishing and responding publicly around its digital identity research ahead of Switzerland’s e-ID referendum.

But in spite of the gracious sunlight, I feel a true evil on this boat with me. These men aren’t aberrations, they’re a template I’ve seen everywhere. They’re saying the same words I’d heard all week in the mansion. The same words I’d heard in the copycat San Francisco transplant coworking spaces of Melbourne, Sydney’s Silicon Beach, and Apple’s developer conferences: Violence, then rebuild; profit, then philanthropy – repeat! Different war, same business model, new interface, same shining eyes. “We’re making the world a better place.”

I suddenly see, clearly, the next twenty years in front of me: automated war, digital rights-managed food, not-so-precision strikes, it all comes crashing over my young psyche drowned in the same blood-stained, morally coded rhetoric. I realise that everything I had been arguing for – pseudonyms, safety, friction – all of it lives downstream from this mindset.

Reading

I pre-ordered Tchaikovsky’s newest book in the Children of Time series: ‘Children of Strife‘ this week. Looking forward to digging in.

I finally finished A Million Years of Music by Gary Tomlinson. What a masterpiece. It’s taken me nearly 3 months to read it. But I’ve been having my mind blown every single night, so its been totally worth it.

Partyraiser & Udow – Gabba Gabba (Single)

I have two modes when I’m writing, thinking and working. Right now its mostly exploring the last 100 year of Jazz. But especially building spreadsheets I find jungle insane breakcore adjacent music to be the perfect music for concentrating. This week, the terror/darkcore producer Partyraiser’s new single and back catalogue has been on heavy rotation. Your own enjoyment and MMV.

Remember Kids:

The post Writing for the Machines | Weeknotes #430 appeared first on thejaymo.net.

That’s World One. World Two is a small subculture of people who have given AI agents full access to their computers: credit cards, calendars, GitHub, inboxes, passwords etc and told them to just go and do things across the real Internet.

The circle of people who even know about World two is tiny, The number of people who let these little guys loose is even tinier. But it’s here in World two that the next interface paradigm for Agentic AI is being rehearsed in public. Most people will meet these little guys until 2027 at the earliest; they need to get a lot safer and less strange first.

This post is a primer for people in World One, about the near future of World two.

What An Agent Actually Is, And What They Are Becoming

A chatbot is something you can talk to. Built around an “I go, you go” paradigm.

An Agent is something you can talk to, but it can also “go and do“.

Agents can currently send emails, build websites, make iPhone apps, book a train, and update database records all by themselves. All from a few short paragraphs of natural language. It can do these things, because it has permission to do so. “I say, you go and do and do ,until done“. This is an Agent.

Already emerging are more complicated Multi-Agent Systems: you ask it to do something; it writes code, spawns more versions of itself, distributes the work, and then merges back again.

From the outside it still looks like “one thing,” but underneath it is a managed society of minds, processes, permissions, and tools. The best way of thinking about what Multi-Agent systems look like right now below the surface is something like this:

The progression we are moving along is chatbot -> agent -> system. These new systems won’t feel like an “I go, you go” co-worker, but a totally chaotic direct bureaucracy. Software spawning software, models coordinating with models, with humans folded into the loop as just another moving part.

This was all written about in the late 90s and early 00s, and all of it said the same thing: the moment we let an Agents take actions in the world, we inherit a new set of problems that have nothing to do with intelligence, and everything to do with control. What is an agent allowed to touch? How does it prove what it did? How do you stop it being tricked? Who is responsible when it breaks something? That moment is basically now. Most of the writing about agent hype skip these kinds of questions because they ruin the fantasy.

In practice however, those questions are the product.

Types of Agents Today

A lot of current “computer use” agents use software the way you would if you were trying to help a friend remotely while watching their screen through a blurry webcam. They take screenshots, squint at them, guess what a button means, click, then take another screenshot to see if anything happened.

Sometimes they scrape the page structure, which sounds sensible until you remember most websites below the UI are a bit like constantly shifting theatre sets. The website moves the “Continue” button and your agent walks into a wall.

The interesting change that is occurring is that software is starting to expose what it can do in a way machines can understand directly. Instead of guessing button semantics from pixels, the software says explicitly: “here are the actions available, here is what each one needs, here is what you get back if you use one of them”. This is a rough approximation of what “tool calling” and “MCP” mean. It’s a shift from clicking pixels to calling capabilities, and right now WebMPC is in beta in Google Chrome.

This gives us two broad substrates for agents.

Soft agents do computer use; they work on the same surface layer that humans use, pushing pixels and trying to infer meaning from whatever the UI happens to look like.

Hard agents only interact with the world through code; they call APIs, compose tools, and operate on explicit contracts rather than vibes.

Once that hard layer is built into applications and websites, something happens to the way software operates. The UI stops being the only control layer, and becomes the human layer only. The app and the interface become completely divorced. A button is just a front end or representation of the reliable action that sits underneath. Right now, picking the button is the action.

The interface of the future will be swappable and personalised for humans however they like it, or skipped entirely when a machine is doing the work.

As those of us who worked in crypto discovered, when the UI layer sits above the irreversible world computer known as a blockchain, “UX” must expand well beyond layout and interaction design to include things like consent checkpoints, confirmation screens, audit logs. There’s a reason we all spent over half a decade talking about governance.

Governance Is The Next AI Product Ecosystem

With humans becoming just another none in the loop: approving, routing, confirming, people are no longer in a position of full control. They are in a position of participation or oversight. The governance questions this troubles aren’t really about AI per-say, but the system as a whole. What it’s allowed to touch what, what does it have to prove to do so, and who carries the liability? And even who is liable if you don’t use one of these systems.

Over time, as access to “intelligence too cheap to meter” gets dispersed down to local models running locally on peoples computers and phones. This is where the most interesting developments in AI are going to emerge from during the next 6 months or so.

To understand where power is moving, ti helps to think in layers. Back in 2020 I wrote about a framework I call Verticals of One. Which is the idea that individuals would increasingly operate through a modular stack of pluggable tools: financial plumbing, identity, content delivery, governance, all stitched into a single surface. What I didn’t fully anticipate was that the entity moving through that stack wouldn’t necessarily be human. The platform doesn’t care. Your identifier is an address. The system has no opinion on whether you’re a person, a DAO, or an AI agent.

Applied here, the stack has four features. The product layer is the human surface, where you express intent, review what’s happening, and take over when things get weird (Like Claude code, Moltbook, Gas Town etc). Below that is the service layer, which acts on your behalf: today this is the planning model, translating your request into steps and spinning up the right tools for the job. Embedded in the stack as a service is sits this proposed governance layer. The part of the platform that decides which tools can be invoked, under what conditions. It holds the rules and handles identity, permissions, time limits, spending limits, logging. At the bottom is the tools layer: APIs, databases, code packages etc the boring plumbing of any software system. Tools get spun up, used, and put away again when done.

If you’ve spent time in crypto, the next sentence is obvious. If you haven’t, it’s worth thinking about.

The model layer is a commodity race. The governance layer is the protocol.

AI labs are all currently competing to build the best reasoning and planning layers. But commodity races compress margins. The durable position, where new power actually accumulates, moving forward is in the layer that decides what agents are allowed to do, and can verify what they actually did. This is exactly the pattern that played out in crypto: the applications were interesting, tokens were exciting, but it was the protocols underneath were most of the durable influence and power settled. Whoever cracks the the governance layer will have enormous influence over the ecosystem that runs on top of it.

Cursed Objects

As agents become capable of calling tools and integrating across services automatically, they become extraordinarily attractive targets. Only this week we saw a malicious Issue title on GitHub compromise 4,000 machines.

Another trope of sword and sorcery is of course the cursed object. In the wrong hands—or with the wrong intentions—people could create cursed talismans, or haunted webpages. Miss-markedup documents deliberately or not, could embed misleading associations that throw off the model’s understanding. Prompt injection but different.

Expect more of these cursed objects: malicious code packages, compromised endpoints, and booby-trapped tooling designed specifically to be picked up by an over-eager agent. Fake API endpoints that exfiltrate data. Probably most worrying for developers, poisoned npm dependencies. Where the blast radius of one compromised dependency scales with every agent that pulls it.

Agents as they exist right now are extremely exploitable, and is why ‘normies’ might not encounter these systems as until 2027 at the earliest. But the shape of what they can do already is clear, and like all AI systems, what they can do right now is the least capable they will ever be.

Investment signals are already here too, OpenAI hired the Moltbook guy, and serious money is already moving into agent security infrastructure. But most consumers don’t even know World Two exists yet.

Skill Markets and Context Shoppes

There are two futures I see emerging. Not as an either/or, but two ecosystems that will sit alongside one another. Both are a kind of reputation infrastructure.

In the open version, which I am calling Skill Markets trust comes from accumulated signals. Did this tool do what it claimed for the last ten thousand agents that called it? Does it have a history of clean behaviour? Has it changed in suspicious ways? Has it been attested by trusted parties? Messy, decentralised, social-proof-at-scale, think distributed reputation graphs where trust propagates through networks of usage and attestation. Nobody is in charge, but patterns emerge. Most of this has been built and prototyped already In the crypto world.

The curated version is what I’ll call a Context Shoppe. In fact, this is a term I used way back in 2024, and basically predicted the current tool/skill ecosystem in the same post.

There’s already a whole market out there for prompts but in the sword-and-sorcery world, if you need a new Talisman, you either make your own, or head to the Magic Shoppe (or loot it from a monster’s corpse). A marketplace of Knowledge Shoppes could be a future we’re headed towards.

In a curated Shoppe, everything is checked and maintained by a single brand. Essentially an approved marketplace. A bit like the Apple Store on the iPhone. I suspect an early move in this direction was probably Anthropic’s recent acquisition of Bun.

Shoppes however will cost a lot of money to run, and will likely require an extra subscription on top of base AI cost. But they’ll be worth using for big companies, whose enterprise compliance teams will require it. (Mostly because it gives them someone to sue if something goes wrong.) Everyone else will resent the shoppes because it’s more tollbooths reappearing somewhere that used to be open and move to the skill markets. Both will exist. The tension between them will be part of the culture of this space for years.

We are also going to need Skill Market competition, as there’s a darker version of the open market worth naming. In some ways a Skill Market is also an auction house or a casino. The most-called tools will rise and the obscure ones will sink. Reputation is just price discovery by another name. If tools are callable and composable, the routing matters. Whoever decides which tool an agent uses for a given task has an invisible hand in the outcome. In crypto this is called MEV: Profiting from controlling the order of transactions. The analogue here is value extraction in task routing and tool selection, happening beneath the surface, invisible to the user. The interface is the last mile for humans, which means it’s also the last place they can see.

Paying For It

AI pricing already looks very different from how most companies buy software today, it’s usage-based rather than seat-based, which means the toll booths are invisible.

Outside in the Skill Market, they will work on a payment gating: whoever controls settlement can extend upward into vetting, reputation, dispute resolution, and verified access. Any network that becomes the trust layer for agent actions would be an extraordinary position — it already has identity, fraud detection, and the “someone to blame” quality that enterprises demand.

Shoppes meanwhile are controlled by a single platform gate: if your OS enforces what agents can access and for how long, that becomes an enormous control point. The permission layer lives at the device level, not the application level. Whoever owns the device owns policy enforcement.

My uncomfortable prediction already is that the big winners in the governance layer will look more like a payments company that got serious about API trust infrastructure, or a platform company that extended device permissions into the agent stack, than an AI lab that expanded sideways.

AI labs seem to be oriented toward being the preferred thinking layer, not toward owning the full service distribution or policy enforcement. But maybe this is just me, my instinct is that the governance layer is always the product, as I’ve watched how protocols become power in decentralised systems. I don’t think any of this will be surprising to others either as the months go by.

Agents Paying Agents

All good so far? Here’s the part that might sound a little like science fiction but follows logically.

Once you have machine identity, machine permissions, and callable capabilities, the natural coordination mechanism between agents is payment. Literal machine-to-machine settlement. An agent decomposes a task, calls a sub-agent to handle part of it, and the call is accompanied by a micropayment.

My friends and I have lots of ideas how to decompose and extend the current way agent API’s to handle all this, but we can skip all that. The main point is that payment is simultaneously an identity signal, a reputation input, and a verifiable execution receipt.

I wrote about some of this last September: Cloudflare’s NetDollar, x402 and A2P. The emerging HTTP-level protocols for agent payment and coordination.

Now. You might think that the fusion of AI agents and crypto rails is an unholy alliance. I understand. And you also might also think that blockchains stink, and is a scam machine. But putting all that aside, Bitcoin is 16 years old, and Ethereum is 10. Both are extremely robust technologies that are producing, capturing and organising over 3.7 Trillion dollars in value.

Following a decade of blockchain development payment is one of the cleanest truth signals we have. Settlement ties identity, intent, and outcome together in a way that’s hard to fake at scale, and it comes with dispute resolution, fraud detection, and reputation signals as built-in infrastructure.

Money is a governance signal. And that’s how Skill Markets are going to work, and I’m not being speculative about this. In the last few months Cloudflare and Google have both shipped support for x402, Ethereum is also working to extend these proposals with decentralised agent reputation and trust with EIP 8004 and it’s all maturing fast. Some agents in the near future might even start earning money of their own.

For a decade people asked what the use case for crypto actually was. A lot of us have been saying from the very beginning: “we’re waiting for AI.”

In addition to all this, most work that this favours is repetitive in shape. The near future isn’t everyone building bespoke agent architectures, but specialised autopilots for specific workflows, with tight permissions and good receipts. Most of this stuff is going to happen in the boring middle, where the white collar work lives. And technology always eats the boring middle first.

World Two is still tiny, and it will be tiny right up until the moment it isn’t. All the plumbing is happening, with the help of over a decade’s worth of experience and thinking having already been done already in crypto land.

We are a few years out from people in World One being troubled by all this, but it’s all coming.

The post The Near Future of AI Agents appeared first on thejaymo.net.

March 2, 2026

|

AI 🤖 | Permanently Moved 🔊

What are large language models, really? A genuinely different frame for what AI is, where it came from, and what it means to live alongside it.

This episode of Permanently Moved is an hour-long audio essay on artificial intelligence, agency, and the history of computing that made LLMs possible.

The essay moves from the invention of the mirror to double-entry bookkeeping, the printing press, the Manhattan Project, the transistor, and the particular civilisational strangeness of ChatGPT and its successors. It argues that the question everyone is asking about AI “is it intelligent?” is a trap, and it tries to ask a better one. 

Show Supporter 📻

£5 MONTHLY 👏

Quarterly zine; my gift to you ✉️

Subscribe 🔊

Wherever you get your podcasts

Monsters In The Mirror

On AI, Language, and entities that wear language as their skin.

Everyone around me seems to be arguing about whether AI is intelligent or not. I think it’s the wrong question, and always has been.

The fact that it feels that it’s so obviously the right question, is itself part of the problem.

Monsters in the Mirror is an hour-long audio essay. It starts with mirrors, both physical and metaphorical, and then moves through five centuries of the Enlightenment project, and arrives at the particular civilisational strangeness of large language models being just one of the many downstream consequences of the invention of the transistor.

But what are large language models, really? I argue this question is a trap, and arrive at some conclusions about it all that most writing about AI doesn’t go.

The Argument In Brief

There’s a central claim that whole essay turns on, that reframes a great deal of how we see the techno cultural world around us, including: double-entry bookkeeping, the census, the microchip fab lab, and why calling an LLM “stochastic parrot” is, in a precise sense; a curse.

Along the way it asks:

• What does it mean that we have been living alongside non-human agents for centuries and have barely noticed?
• What happened to the concept of Truth when Gutenberg froze it into lead type?
• Why is the question “are LLMs intelligent?” is a trap, and what’s the better question?
• What does it mean to live inside the mirror cyberspace now, rather than in front of it?

You might disagree with my answers to these questions, but stick with it. Consider it an invitation to look again at AI, capitalism, language, and what we call ‘agency.

Start Select Reset

For eight years, Permanently Moved was a weekly audio essay show and lived online as audio and words on a screen.

First time I’m putting my work not behind a paywall, but inside an envelope.

Issue #15 of Start Select Reset, my long running subscriber zine is now the print companion to Monsters in the Mirror. 36 pages, A5, printed on 100 GSM weight paper with chunky 250gsm covers. It contains the full essay transcript, plus an introduction and an afterword that aren’t in the audio.

As the now quarterly show continues the zine and the audio will begin to diverge. With notes, fragments, interviews, things that only make sense on a page and in a zine.

Think of Start Select Reset as the show’s merch. Graby a copy and support the work!

Buy SSRZ15: Monsters in the Mirror on Etsy

This zine contains the full essay transcript alongside an introduction and afterword written exclusively for print, material that doesn’t exist in the audio. 36 pages. A5. Properly printed on heavy stock with thick covers. Hand stamped twice, copy number and FOG logo.

This is remaining stock after the print run for my paid subscribers. Once they are gone, they are gone.

£18 + shipping worldwide

Buy on Etsy

CAVEAT EMPTOR: International zines are posted with full customs declarations as printed booklets. Depending on your country, local VAT, customs, or handling fees may be due on arrival.

How To Get It

Pre-orders are open for two weeks until Monday 16th March. After that, the run goes to the printer, and however many copies are left become back issues until they’re gone. There won’t be many.

Or head over to my Etsy store.

If neither works right now: a five-star rating in your podcast app, or telling one person who might care. Both genuinely help more than you’d think.

Permanently Moved

Permanently Moved (dot) Online is a quarterly audio personal podcast, written, recorded and edited by by @thejaymo

The post Permanently Moved #302 – Monsters In The Mirror appeared first on thejaymo.net.

Large Language Numbers

I’ve been trying to get a better grip on what kind of world I’m actually living in right now. Are my default assumptions just keeping me comfortable. Like how knowing that Roblox has 350million monthly active users vs BlueSky’s ~30m is really useful when talking to Gen X and Millennials. As one has a big influence on culture, and the other is a text ghetto.

I saw a tweet recently that said: “Roughly 99.99% of games of Go ever played are AI self-play training games.” Which is quite the claim! It’s also exactly the kind of claim that makes you question your mental model. Because even if the number is off, the direction might be absolutely right.

So, a little google and some very bad maths.

The AlphaGo (2016) Nature paper reports using a dataset of roughly 160,000 human games from the KGS Go Server for supervised pre-training. Then it describes generating 30 million full self-play games, sampling one position per game from that datasets. Which gives us a baseline minimum number of games. That is not necessarily the total amount of self-play that happened across the whole AlphaGo project, it’s just the most clearly specified number I can find.

The AlphaZero paper (2017) reports 5 million games of self-play for Go, and 44 million for chess etc.

Enormous numbers. But how many games of Go does humanity play in aggregate?

Wikipedia says roughly 46 million people worldwide know how to play and ~20 million are current or active. It takes two to tango, so if every active player plays one game a year, that’s ~10 million games annually. One game a year is barely what I would call “active” though, so lets bump that to three games a year (still absurdly low for anyone who actually plays regularly), you get to 30 million. And so we’ve matched the value-network slice of one AlphaGo training run.

So its clear that a single training run can generate game counts comparable to the annual play of millions of humans. Then we assume that that kind of run gets repeated, across multiple models, multiple labs, multiple research teams etc. Train“AlphaGo Zero but on a smaller board” is a piece of homework for ML students now I discovered. Plus the community-driven model Leela Zero Go exceeded 10 million self play games in it’s own training run.

Whilst I don’t think “99.99%” is actually accurate, it’s definitely the right shape of statement for the world we’re in. It’ll definitely be true in a few more years thats for sure.

But what about text?

The NYT pissed everyone off this week with that piece about the woman who’s written 200 books in the last year with Cluade sure. Getting to any back of the envelope number for text generation is a fools errand, but I’m not interested in being accurate and I’m a fool, so lets try and figure out scale.

This week, Alphabet said its first-party models were processing over 10 billion tokens per minute via direct customer API use. By Google’s own rough conversion, 100 tokens is about 60–80 English words. So a little arithmetic arrives us at 14.4 trillion tokens per day. At 0.6–0.8 words per token, that’s roughly 9–12 trillion “English-prose-equivalent” words per day.

Now, API traffic is mostly for Code. But I did see a stat that 54% of all LLM use is for code. So we can either double the amount of tokens generated via web interface that are mostly text, or half the 9–12 trillion “English-prose-equivalent” words per day. It doesn’t really matter though, because you then have to add Anthropic, ChatGPT, and all the Chinese LLMs etc on to that number. In March 2025, Dario Amodei (the CEO of Anthropic) said that he expects AI to be writing 90% of the code in 3 to 6 months and that AI might be writing essentially all of the code in 12 months. I think he was probably right in a 99.9% of Go games played way.

We are by and large not yet mainly living in a world where AI pumps out fake novels. There’s like, one woman doing that, but we nearly are. Getting a sense for the volume is the point.

I looked in at this old report from The Radicati Group and they forecast for 392.5 billion emails sent and received per day globally in 2026. The last 10 emails in my own outbox averaged 20 words so I’m going with that. Thats about 7.85 trillion human words per day moving through inboxes.

So going at the start of 2026, Google alone is processing “language at a scale” in the same order of magnitude as all of global email traffic.

These really rough back of the envelope stats are enough to satisfy me that the answer to the question “how much text is now being mediated by machines? at what scale?” is…. a lot. And soon it will be most.

If things continue, then I guess were only about 1.5 years away some crazy figures like “AI is now producing more text a year than has ever been produced in all of human history” or whatever.

If anyone with more time wants to try and taking a stab at getting to a more accurate number please let me know if you do!

Forest Bed

This is a reminder for those of you in north/east Londond this week.

My band is playing “What’s Cookin’” on the 11th of February in Leytonstone.

There are still some tickets available!

Blair Jollands is a compelling singer-songwriter with a ‘country and eastern’ sound. His compositions are cinematic in scope and call to mind aspects of Nick Cave, David Bowie, and Beck. His alter-ego is the band El Hula.

The Guardian hailed El Hula’s debut LP HOTEL as “Bizarre & Spectacular”, THE NME and UNCUT gave it 4 stars. Blair Jollands gave the project its name so the records would sit real close to Elvis in the record stores.

“Jollands captures Presley’s southern gothic melodrama, no small achievement for one born 12,000 miles from Memphis” THE GUARDIAN

“It’s the pedal steel drenched ballads that really leave the heart staggering down a red carpet towards Nick Cave’s stash of moonshine. Classy” UNCUT

Alt-folk rock and cosmic americana from Forest Bed.

On The Blog

January 2026 | Photo 365

Photo 365 2026. Year 5, Month 1. Photo-a-day for the month of January 2026.

Start Select Reset 📑

Subscribing to SSRZ supports my online work and creative projects.

Get the Zine!
£5/month 💌

As a thank you, I send you my zine four times a year, just like it’s 1994.

No spam. No email. Cancel at any time.

Photo 365

The Ministry Of My Own Labour

I have some calls booked in. But I’m really on the look out for work if anyone has any leads?

A few years ago I wrote about how writing happens ‘in the edit’ and think this is even more true now than ever. I’m currently deep in the structural edit of Episode 302 of Permanently Moved. The first full draft came in at just over 15k words end to end. But now it’s finished i can see the shape of a much tighter essay inside of it. So i’m currently in the process of cutting away the chaff and finding the spine, i assume it’ll be about 10k words when I’m done.

I think (I hope) that working at this sort of word count is going to get easier with each walk to the wicket. I’ve already learnt quite a lot.

Terminal Access

My pal Eddie Rathke and host of Wolf Pod has a kickstarter running for: A zine for an RPG setting called Briar Bay. Art by tony tran. Looks dope!

Briar Bay is a fantasy setting designed for Mork Borg and other OSR TTRPGs inspired by fairy tales, folklore, Le Mort d’Arthur, and surreal swords & sorcery. Expect the bizarre and the black, the whimsical and the wyrd.

We took design inspiration from Mork Borg, Mausritter, and Cairn. With that in mind, think of Briar Bay more as a framework than an explicit and didactic setting zine. While there will be a hexcrawl included, what you do with that is up to you.

Reading

I’m still reading Crowbar by Andrew Edwards though by the time you are all reading this I suspect I will have finished it. Already in contention for book of the year in my world, especially reading it amidst the ambient Epstein news.

Still reading Million Years of Music too. Such a tomb!

I spent an audible credit on Empire of Imagination: Gary Gygax and the Birth of Dungeons & Dragons by Michael Witwer. The first complete biography of D&D’s creator. I’m not very far in but its well written, in that ‘biopic’ style that seems to very very popular right now.

Marta Del Grandi – Dream Life

Now if you are a long time reader you’ll know i’m a sucker for art pop and Dream Life, debut album from italian singer songwriter Marta Del Grandi scratches an itch!

This is definitely an ‘album’ album. A complete work. You need to listen from start to finish. Appreciate the singles interspersed with the more dreamy ad minimal synth beat tracks. The operative word to describe this whole album is ‘quirky’, but not in any negative sense. Weird rhythms, fun melodic lines and funky beats.

Its very mid 2020’s but also sounds like its coming from a place of long engagement with alt-pop/off chart pop tradition. Think David Byrne, St Vincent, even some Susan Vega, Satanicpronocultshop, Superorganism in there too. I think this album is going to see me though the spring.

Remember Kids:

The post Large Language Numbers | Weeknotes #425 appeared first on thejaymo.net.

Prompted to Panic

All week I’ve been thinking to myself ‘I’m not going to write about Moltbook, I’m not going to write about Moltbook’. But I’ve found a work around! I’m going to talk about peoples reactions to Moltbook. lol

I’m going to assume by now that. you all at least ambiently know about moltbook. It has been inescapable. Declarations that something really new is happening, that a threshold has been crossed, that we are witnessing the birth of a strange little civilisation, that this is the dawn of machine consciousness or whatever.

It has been extremely worrying to watch a large swathe of otherwise intelligent people online (who should know better), take leave of their senses. Absolutely one shotted by the whole thing. A mania induced by a badly-lit doll’s house.

Predictably, the worst place for this has been LinkedIn. The social network populated by the highest demographic of credulous bumblers outside of Facebook. That LinkedIn in particular has discovered a social feed full of synthetic text and decided it’s either a miracle or an abomination, is almost impressive. LinkedIn is already so full of AI Slop and Human Gunk, that I cannot fathom how people who post there all the time can be excited by, or horrified by, a social network populated by LLMs. They are basically already on one.

Taking humans out of the loop entirely doesn’t make it any more or less interesting.

It is i think, worth acknowledging that plenty of people out there still haven’t even used an LLM in any meaningful way yet at all. If your baseline is “the internet is made of people” or that LLMs are spicy autocomplete for writing emails or LinkedIn updates , then Moltbook is going to look really alarming on first contact. A feed full of plausibly human language, detached from humans, is unsettling; so the reaction makes sense. What doesn’t make sense is the professional internet class behaving like this is either revelation or rapture.

To be fair though I got one-shotted briefly too by something similar. Back in 2023, working on DELVE, we had LLMs talking to one another inside an old-school MUD. It was really eerie and unnerving… for about thirty minutes. Then the spell wore off, because you realise what you’re looking at is not beings but behaviour. You’re watching what language machines do when you give more than one of them a room.

My whole professional life is worlds. Part of that work is paying close attention to the shape of the container. Which is often mistaken for the nature of the contents. Moltbook is “a social network” for agents, so people reach for their deepest social-network instincts; community, emergence, culture, harm, ideology, contagion etc.

But if you put aside the very serious questions about artificial intelligence, latent machine consciousness, what it could be, what it is right now, and what we’re pretending not to see; Moltbook is basically The Sims, but with agents who have the ability to code their own reality. It’s a animated diorama where the characters can generate convincing sentences about their inner lives, and other characters can respond with convincing sentences about theirs.

People are mostly freaking out I think, because the doll’s house is social-network shaped. Familiar enough container to trigger twenty years of muscle memory about what one is supposed to be looking at. We’ve had agents running inside Discords for years. All the zoomers freaked out a few years ago because it was Discord shaped. Turning your brain off because the thing looks like a forum vs a chat app is insane to me.

The actual headline isn’t “the bots have formed a religion” or “the bots have invented their own culture”. The headline is: a bunch of humans have discovered a new way to be emotionally manipulated by interface geometry.

There’s a bit difference between “this is interesting” and “I have lost my mind”. I think it’s interesting. But a truly depressing number of people have chosen the second option, publicly, in writing, with their job titles attached. Some of the takes are pure projection, a kind of moral panic cosplay, as with most ‘current things’ on the internet an excuse to perform seriousness without the inconvenience of looking closely at what’s actually happening.

The most interesting takes are the boring ones; the people worried about security and software permissions etc. “machine culture” is an attacks surface, one that has existed for the entire history of social media. But that is all extremely boring, and “Don’t wire the autocomplete to your wallet” doesn’t do well.

I wrote last year about whats going to happen when we give agents payment rails and said this:

Experimentation with payment rails, built on top of crypto—for people, AI Agents and soon other types of non-human actors or synthetic entities—are only going to proliferate and speed up across all sorts of platforms and use cases.

Brace for Weirdness

This proliferation is happening whether we are ready for it or not. And the hard truth is, we are not ready.

We, as a culture, are totally failing to get to grips with the idea of Living Alongside Computer people already. On social networks, in our software, in our phones etc. We’re totally unprepared. We already saw what happened the first time LLMs were hooked up to crypto rails and given access to social media and markets at scale. I wrote about realtime attention markets, the new economic entertainment emerging in 2024 extensively because things really went off the rails fast. I think things are about to even more crazy.

I guess the the ‘weirdness’ and the ‘more crazy’ is exactly what we are seeing now, it’s all playing out just as expected.

So many people for years have been saying that real time attention markets inside of our contemporary code spaces are completely broken by the presence of LLMs. A new class of participant that can speak infinitely, cheaply, and strategically, inside machines that reward speaking is a fundamental challenge to the attention economy. Moltbook is at least, the first time I’ve seen people in the mainstream approach this subject, even if it is in a hysterical manner. We live with infinite media now.

In 2024, I wrote this about what I thought was coming soon:

The thing is though, with all of these examples, it’s far easier to be the first than it is to be the next successful thing.

But out of the corner of my eye, I see it all converging. Autonomous AI agents inside of VTubers as real time characters, inside of virtual worlds, fully monetised with a token which powers the interactive in-show entertainment options. Imagine if Love Island was less scripted and more like The Sims, but with interactive chat features you might find on cam-girl sites.

All of course, unfolding against the backdrop of the legalisation of sports betting in the United States, further accelerating the logic of the casino fusing into social media. 

The future I’m seeing is shaped power fandoms raised on Fortnite and Dabloons, crypto social casinos, and TV merging into an auto-financializing interactive entertainment medium.

It’s just a glimpse to be sure, but it’s one that’s gonna be very weird indeed.

It turns out that, yes! agents inside of a world (social media) is a highly compelling form of entertainment. I am excited about what comes next too. But only because the container is changing, and the incentives it enforces are changing. I’ve spent nearly 2 decades in crypto, the failure modes are going to get weirder and is going to be entertaining too. I’m
excited by the new code spaces and their weird local physics that are going to get built.

We need to learn to live alongside little computer people.

Start Select Reset 📑

Subscribing to SSRZ supports my online work and creative projects.

Get the Zine!
£5/month 💌

As a thank you, I send you my zine four times a year, just like it’s 1994.

No spam. No email. Cancel at any time.

Photo 365

The Ministry Of My Own Labour

I fixed a major structural issue with episode 302 of permanently moved this week. I’ve been editing and doing re-writes, but something was ‘wrong’ and felt a bit like grit in a shoe. A nawing sense that something wasn’t quite working. As soon as i fixed it, i felt like some kind of energy block had been released and i’m not in the home strech. the final edit is coming very easily.

Did some paid commentary on first draft of a report on AI, management and workplace adoption. Seemed like a cool research project. The report was super long and I sent back about 5k words of thoughts.

Terminal Access

JDO interviewed Andrew Edwards! (see Reading). Fantastic interview.

Reading

I’m still chugging my way though A Million Years of Music. Just got to 500-200kya and its now discussing neanderthals and other pre-sapian hominids. This book continues to blow my mind.

I moved straight on from King of Dogs by Andrew Edwards into his first novel Crowbar. Its written in a very different style to KoD. The book is a sort of 1980’s Miami Action noir, and the prose is all v.short stream of consciousness sense impressions. Scenes slow down and speed, like reading a dream. It’s got a lot of style. Love it so far.

Julian Lage – Scenes From Above

Lage is back with a new album, his 5th for blue note records. This album is certainly one of the grooviest things he’s put out. His recent work as felt like his guitar was ‘leading the band’ his voice etc. But this album feels more like being one amongst many. You come for Julian Lage on guitar, but stay for the bands chemistry.

This album is absolutely fantastic. As you would expect from some of the best musicians in the world playing together.

Remember Kids:

The post Prompted to Panic | Weeknotes #424 appeared first on thejaymo.net.