Nearly Doable

As you might have seen, Issue #15 of my zine went out to subscribers last week. I can honestly report that sending physical things to people is bloody brilliant. Big thanks to everyone who’s been in touch about it.

When I first started making the zine back during the pandemic, I had some hope that this might be the direction of travel. Making and self-publishing proper physical artefacts that are connected to online work and creative projects, then sending them to people in the post.

After a long slog with the initial years of the zine, and making the podcast weeky, I can feel that ambition starting to become real. The whole enterprise hasn’t been “easy”, it is now almost doable. I can see the shape of the new format and how it plays out

I have been thinking a lot about pace and form since finishing 301 last year. I just don’t think people should need to post their creative work online every week for forever. Longer, more considered things, especially when they have a physical component, seem to be a much better shape. Combined the audio episode and the zine are asking for a different kind of attention. They suit the culture I want to live inside of, so I’m doing my bit to help make it happen for others.

Anyway. If sixteen-year-old me, or nine-year-old me for that matter, knew that at the age of forty I’d have a zine shipping around the world, with a proper print run and subscribers waiting for it to arrive in the post, he would be over the moon.

Anyways, there are still a few remaining copies of Issue #15 available on my Etsy.

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.

On The Blog

Raindrop.io Stella Prompts for Batch Processing Bookmarks

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.

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

• No work this week 😩 but I pushed a whole bunch of personal work and projects forward.
• Zine stuff obviously
• Sent invitation to new Experience.Computer guest. Positive reply. Currently organising recording date.
• Sorting out last of my life admin. Tax return soon though.

Terminal Access

WEDDING PLANIC!

My friend Stef just put her first solo dev indiegame up for wishlisting on Steam!

A roguelike, deck builder about managing a wild wedding party!

Nobody wants to throw a boring party. In Wedding Planic! you arrange a deck of neurotic wedding guests to generate high levels of Craic (which is basically Irish for fun) and Drama. 

Guests will flee, fight and f…lirt their way around the seating plan and it is your job to create good table combos and high scoring synergies to make sure that the party survives the night and goes down in history.

Each guest has a stack of repressed personality traits that can unlock new abilities as the Craic and Drama levels rise, making every playthrough unique and wonderfully chaotic!

Win by combining guests, top table cards and wedding favours to create synergetic combos that make the wedding pop off.

For fans of wedding planning and Balatro!? I played the current build last week, and it’s really coming along. Love to buy wedding favours to juice the craic at the tables! Also, I named this game over Discord DMs one afternoon last year, when we were still working together. My dadcore pun game is so strong. hahaha.

Also, I am available to name your game any time!

Reading

I finished the audio version of Liturgies of the Wild: Myths That Make Us by Martin Shaw. Absolutely fantatic. The man is a national treasure.

I went back to The Mirror of Simple Souls by Marguerite Porete 30% of the book is the introduction and now i’m actually into the main text I’m ripping though it!

Bassekou Kouyate – Miri (LP)

Just this week i discovred the work of Malian musican Bassekou Kouyate a Ngoni calabash player. Man this whole album has groove. I’m so into it. Can’t stop listening though his back catalogue.

Remember Kids:

The post Nearly Doable | Weeknotes #436 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.

# 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_asc` = 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.

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.

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.

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

The post March 2026 | Photo 365 appeared first on thejaymo.net.

Easter 26

The Chalk

I hope everybody had a lovely Easter weekend. I went back to the chalk and spent some time with my parents. We did some blustery walks along the coast, and also did an enjoyable, albeit bleak, visit to Richborough Castle. A Roman Fort that at one point, was the site of the biggest triumphal arch in the Roman Empire outside of Rome itself. I haven’t been up there since I was in primary school, so it was a very enjoyable visit and a good use of my freshly renewed English Heritage membership. The visitors centre there is full of cool stuff, and features a curated collection of finds from excavations at the site.

I did open my laptop while I was at home, as I had some computational tasks using my daily AI API credit allowance, I didn’t actually spend all that much time at my computer. As I just wanted to spend time hanging out with my parents: going for walks, participating in chaotic church raffles after the Easter service, going to the food fair, and doing odd jobs around the house involving lifting as my Dad’s recent hernia operation is still heals up.

Doom Eternal

The one thing I did do however, was play a lot of Doom Eternal on my Switch 2 whilst I was at home. I’ve owned it for years, but it was basically unplayable and extremely crashy. But it now runs like a dream on the new hardware. I dread to think how many hours I put into the game over the last five days, in the evenings and during the day, drinking cups of tea while mum and dad had the TV on. I’m nearly nearly done with it. I’m just working my way through the last level.

I have decided that Doom Eternal is a ‘good game’, it’s not quite as fun or innovative as Doom 2016. And I don’t find the gameplay loop as satisfying as the original reboot. Initially, I found the increased agility, double jumps, and rushing elements in the movement annoying, as it didn’t ‘feel’ like a Doom game to me. But now I’m however many hours in, I’ve accepted it as part of the affordances provided by the game world..

The game is also far less confusing in terms of wayfinding than the 2016 predecessor. I don’t find myself getting lost as essay. It’s not quite “yellow paint” guidance, but the green light storytelling is very useful for intuiting where you’re supposed to go. I also enjoy the interplay between the first lines of sight and the locations of the hidden secrets satisfying in terms of exploration. Anyway, I didn’t expect to write about my Easter weekend, and end up with a review of Doom Eternal, a six-year old game.

Yes, I spent a lot of time with Doom on my Switch at home, but it was the time I spent with my parents was the best bit of being home. It’s so nice to see them, hang out, and be a part of their world for a couple of days.

Slop Machines

I used both my train journeys from and back to London to work work on Slop Machines and more or less finished the first draft finished; excluding the final chapter. The last chapter on the Slop Machine itself will probably be another 10,000 words of so. But I want to do an editing pass first. I plan to go though the chapters sequentially from start to finish, and make notes as I go about what I’m going to say in the final chapter based on the preceding arguments that make up the bulk of the book.

It’s funny, even though I’ve just got to where I am with the first draft, at its peak, the document was about 75k words. Even before the edit i’ve cut so much stuff out of it already; multiple side quests that interest me, but aren’t necessarily relevant to the argument that I’m trying to build throughout the book. Anyway, I’m extremely pleased.

I’m only three months late with it than I had initially planned. But it is what it is. The original Points and Gestures talk with the same name was given back in December of 2024! And as a result I feel like the ground I’m covering in the text is already out of date. Well after I had initially had these thoughts. 

Monsters in the Mirror is, in fact, a prelude or prequel to Slop Machines. Covering a much wider span of time and history than the book does, which allowed me to get the wider frame of my thoughts in order, and that really helped and benefited the book itself.

Speaking of Monsters in the Mirror, because of the bank holidays, getting the zine issues back from the printer has been slightly delayed. But as soon as they arrive, I’ll be shipping them, hopefully this coming weekend.

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

• Finished the first draft of Slop Machines!
• did a great deal of personal and life admin, prepared for my tax return, and generally got my affairs in order.
• I had an interesting conversation over email about my “Hard Worlds For Little Guys” series.
• I also have several other outstanding emails and correspondence I need to respond to.
• In my capacity as an advisor, I worked half a day alongside someone to get to to the bottom of some weirdness between subscriber recurring revenue and the reconciliation between different data sources.

Terminal Access

IYB Robotson Is back in the host chair of his podcast, Neomania.

The newest episode is about DIY Food Futures and Synthetic Ecology with @cyber_plantae from Futurespore. I thoroughly enjoyed it. If you haven’t done so already, you can check out my appearance on show here!

Reading

I finished the audiobook of Children of Strife by Adrian Tchaikovsky on the tube. It’s Book #4 in the Children of Strife series. It’s fantastic. I think this whole series is some of the best of contemporary sci-fi. Really enjoyed it.

Last night I finished The Heart of Prayer by Rupert Spira. Another great entry in his The Essence of Meditation series.

Rounds – Four Tet

For some reasons, perhaps stuck down with the affliction or disease known as nostalgia I’ve ben listening to Rounds by Four Tet. It’s really hard to belive that it came out 23 years ago.

Remember Kids:

The post Easter 2026 | Weeknotes #433 appeared first on thejaymo.net.

Creative Loop

One band is a collective endeavour, two bands make a scene.

I’ve written and talked about all this before so i’m not going to repeat my self. Other than to say that one of the most formative times in my life, and my introduction to ‘the creative world’ was the hardcore punk scene in Margate in the late 90’s and early 00’s. If you wanted culture any culture at all, you had to do it together.

I recently watched this 15 year old lecture by Brian Eno, where he goes into his concept of Scenius in more detail than I have previously come across. So good.

I am aware that the meaning of the term ‘scene’ has been under constant re-negotiation since the Internet arrive, and what a scene ‘is’ and ‘isn’t’ is something people have very strong opinions about, and I’m going to steer clear.

However; years and years ago now, before AI entered mainstream consciousness, I remember having a conversation with Mat Dryhurst about DIY punk and Scenius etc, but the main topic of conversation was about what is like to be in one. And one of the things I took away from that evening in the pub is that ‘scenes’ are so generative because at their core, people produce work for themselves and show it to their friends. All a scene really is, is just people just prompting each other in a tight feedback loop.

With that in mind I want to mention two things that have come back this week as part of the loop.

World Soul Fruit Fight

I received an email this week from Duc de Berry / Billy Crosby creator of the sprawling personal site hoofofconcept.com with a link to a 3 part audio project called World Soul Fruit Fight.

The email opened “monsters in the mirror is my fav bit of media I’ve be consumed so far this year” and then went on to explain they had generated three tracks with Suno, based on outputs from my Slop Machines GTP link where you can chat with the current draft of my in progress book. The grounding for it also contains worldrunning.guide, and a bunch of other unpublished writing.

Track 3 is my favourite. It’s amazing.

Listening to them for the first time, as an experience, was a bit like being inside a hallucination or a dream. The referencing of my ideas and imagery so familiar to me from my creative work comes in an out. There’s a bit about buying a sunset, the screen as a mirror, and the mall of abandoned brands… all appear in track 3 alone. It’s a very weird, wild, and inspiring feeling.

If unlike me, you don’t want to listen to synthetic media, do head over to hoofofconcept.com and browse around. It’s very zanny. I love it.

Claude Skill Creator

I’ve been a bit overwhelmed by the response the to Hard Worlds posts I put out 2 weeks ago. A fork of Anthropic’s official skill creator now exists over on Github, which implements the ontology/theory derived from the knowledge object I supplied alongside the essay .

You can read the full write up on what happens when you use it against a mature skill file on twitter, but I’ve quoted the main results below. Overall, a massive success.

The SKILL.md is now a router that identifies what I’m asking for (drafting a thesis section? reviewing a risks edit? formatting the docx?) and loads only the relevant room file and exemplar. For this deal memo skill, context load per task dropped to 13-19K characters.

That’s a 74-87% reduction.The renderer (render_memo.py) takes a typed JSON intermediate – where each content block has a type like section_header, bullet, labeled_sub_bullet, risk_bullet – and produces the formatted Word document. The model’s job is to classify content into types and populate the text. The script handles fonts, spacing, tab stops, margins, bullet characters, page setup, and numbering and the model never touches python-docx.

The validators run automatically as part of the rendering pipeline. One checks the JSON structure before rendering (does the thesis have deal terms? are there enough risks? is CARR in the financials?). The other checks the text after rendering (e.g. no customer quotes in the body, risk labels under 4 words, CARR figures consistent across sections). I calibrated the structural validator against all 19 of my prior memos (a benefit of being at Battery for 10+ years!) measuring what’s always present, usually present, and sometimes present so the severity levels (fail vs. warn vs. info) reflect actual patterns rather than aspirational rules I came up with in conversation with skill-creator.

The result is that formatting bugs went to seemingly zero for this skill. v1 had a frustrating problem with competitor entries being standalone paragraphs – it was actually stated four times in different locations and still kept failing – and that issue is structurally impossible in v2 because competitor entries are a different content block type than section headers, and the renderer makes them sub-bullets by construction. The model can’t produce the wrong format because the wrong format doesn’t exist in the type system.

I do think this way of thinking about agent environment design has applications far beyond the creation of just skills though. But its early days yet, and the essay is still travelling out into cyberspace. Looking forward to seeing what happens next.

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

• FULLY finished the first draft of chapters 1-9 of SLOP MACHINES. 71k words. I think i’m going to do a big edit pass and and prepare myself for the closing chapter that way.
• Had a great call with Rich from Archetypal.
• Vibe coded my first proper app in AI Studio to get something done, and have been burning though free Gemini API quota every day since lol.
• Got a lot of gossip from pals in the UK game industry, sounds grim.
• Honestly there was drain chaos in my house this week and I lost ALL of Friday to it.

Terminal Access

Publishers weekly starred my friend Andrew Dana Hudson‘s newest novel Absence (our May 5th)

The thoroughness with which Hudson imagines how individuals and society would have to rewire themselves to contend with this bizarre phenomenon lends his tale impressive philosophical heft. The result is a poignant exploration of loss, grief, hope, and the fragility of existence that will resonate with readers beyond the fantasy and horror genres.

Reading

I finished reading The Heart of Prayer by Rupert Spira. It’s very interesting reframing of his first book Being Aware of Being Aware very helpful to see the same argument recast through the language and lens of ‘God’.

Children of Strife by Adrian Tchaikovsky audiobook is out! I’m burning though it! So good!

LULO ELEKTON (Genre)

Last week i wort about how I had been injecting the Indonesian house music into my ears? Well i fell a bit deeper down the rabbit hole and I present to you Lulo Elekton, the hottest night out in Southeast Sulawesi Indonesia.

I have decided that Techno clubs would be 1000% more tolerable nights out in my 40s if they combined Kaely, or Regency era country dancing. What are we doing here in the west? There’s zero cultural innovation happening! meanwhile in Indonesia this is all the rage! And it’s live music!!

Remember Kids:

The post Creative Loop | Weeknotes #432 appeared first on thejaymo.net.

Try Our Best

I must admit, I’ve been feeling a little doomy recently.

Like everybody else, I have no idea what is about to happen. But more importantly, I’ll admit that I have no idea what is going on either. But I do know how I feel, and in turn, I know how those feelings make me act. That has to count for something.

At the time of writing, we are about thirty hours from finding out whether the current global settlement is still to be or not. Whilst I am sleeping; the mad king of an unravelling empire will decide if he steps another rung up the escalation ladder. If he does, there’s no way back down. When I wake up on Tuesday morning, the decision will have been made. The direction of our lives; for the rest of our lives; will be set either way.

It seems strange to think that the story of my own individual, personal problems right now is wrapped up in geopolitical and world historical events. But of course they are. They always have been. It’s just that at certain moments, the seam between the two becomes a bit more visible.

I’ve written before that when things become unreadable, one must learn how to feel. Not because feeling offers certainty, but because certainty is unavailable. Feeling is not a theory of history, it’s not analysis. But it is one way of orienting oneself inside of the confusion. One way of staying human when the world becomes unreal.

The post-Covid world is still hurtling towards us along the tunnel; close enough now to make out the shape of the thing. I have been shocked by the tone and the reporting in the media here in the UK about what that thing is. As someone who was a teenager when the planes hit the towers, another time when the seam was a bit more visible. I’ve watched the current atmosphere gathering over the whole of my adult life. The most coherent story that the people who gathered those clouds are telling us about the future (and the present) has slipped away from them, and towards the stories people have been telling themselves for a while.

Global pandemics, oil wars, crack down on freedoms over terrorism, useless politicians; both national and international, institutions so ideologically captured they can no longer perceive that the story is a dream. Fires and floods, climate, drone war, smartphones, ubiquitous solar, battery storage. The list goes on. None of this is especially shocking or surprising. This is the texture of the near future I grew up with. The Cyberpunk weather forecast the culture wrote for itself.

Meanwhile, for the last decade the hologram has continued to force-feed culture stories of superheroes and exceptional individuals coming to save the day. But out here in the real world, nobody is coming. The politicians and the government; are not here for us, and are not particularly interested in being here either. No rational and pragmatic decisions are being made, and haven’t been since about 2008.

That, I think, is part of the deeper horror I feel. Not simply that things are bad, but that the inherited forms of modernity no longer seem capable of even recognising the nature of the moment they, and by extension we, are in.

The liberal nation-state is, among other things, the story it tells about itself. A social technology held together by newspapers, mass literacy, and the shared imaginary of ‘the nation’, a more or less hegemonic information environment. And has been for four hundred years, give or take. But the conditions that made that story possible have been eroded, if not blasted apart, by the information age. The interfaces have changed, and that has changed the psychic weather. The idea of “the public” has changed too. The old settlement is unwinding either way.

I’m not sure how long that unwinding is going to take. Five years, maybe? Maybe more. But it seems impossible to believe, standing where we are, that the current arrangement can meaningfully hold.

And yet, despite all this, in the main I remain optimistic about the medium term. Not because I think things will resolve cleanly, and not because I think we are on the verge of some redemptive turn, but because history does not stop. New habits, new forms of life, new ways of organising and being together always emerge. The problem is that there is an enormous amount of struggle between here and there.

Everything depends on the extent to which those in power can accept that things are unwinding. Or whether they cling on while the gyre circulates ever faster and faster. Full of velocity and friction. A system overshooting itself.

For those us born in the 1980’s and after; the so called digital natives and citizens of the internet, culture and personalities formed inside one world, are now being forced to build in another. The next ten years, for families and neighbours and towns, and whole countries, things are going to be extremely difficult. I’m not convinced much of the post 2008 condition; culturally, politically, is going to be much use.

In some ways, the last 23 days have been a catalyst for the small gestures that make a difference to me; spring cleaning and decluttering, emptying drawers, wiping down surfaces, processing accumulated stacks of paper, and tidying. Sorting and clearing out. A feathering of the nest, driven by the desire to put one’s house in order.

So what is one supposed to do? Not much, apart from tidying ones room? Nothing can really be done at the level or scale of the problem, or in any kind of register that the people still telling old stories demand.

But one can make habitat. One can clear a desk, sort the papers, wipe the surfaces, and make room. One can refuse the false drama of omniscience. One can resist being ridden by the worst moods of the machine. One can learn how to feel. One can pay attention to family, neighbours, friends, and the real texture of ordinary life.

We need to try our best.

Experience.Computer

Marco Giancotti (Aether Mug)

https://experience.computer/

IN THIS INTERVIEW

Jay Springett and guest Marco Giancotti, a thinking-tool artisan, explore aphantasia, SDAM, and spatial memory. They discuss writing as thinking, cognitive frameworks, and wonder why looking at a picture of a sour fruit (Umeboshi) doesn’t make everyone’s mouth water.

Then they discuss:

• Spatial presence without mental imagery

• The shared ontology of digital and physical objects

• Writing as a process of refactoring thoughts

• “Framing” and “virtual physics” as cognitive tools

A huge thank you to Marco for responding so enthusiastically to my Bluesky DMs after I spent an afternoon binge-reading his fantastic blog, Aether Mug — which is definitely not about science, philosophy, philosophers, languages, Japan, or picture frames, or boxes, (though you’d be forgiven for thinking otherwise).

Marco had some really nice things to say about his appearance on the show, his blog is fantastic check it out.

Last week I had a lot of fun being interviewed by Jay Springett of Experience.Computer. Jay runs a truly unique podcast, focused specifically on an activity that I feel people should do and share more: “curious introspection”, or the careful examination of what your consciousness and perception are like and feel like from the inside. I care about it so much that I maintain a living list of my and others’ introspective descriptions.

The moment you start reading/listening to this kind of mental spelunking you realize how deep, varied, and mysterious it all is. We (including our scientists) have only scratched the surface in our understanding of these matters.

On The Blog

Huge week for new posts this week. Put out about 15k worth of words on the blog this week over 4 posts. It’s all indexed and linked from the post below. basically summarising the last 5 years of thinking; both independently and professionally, about software environments and tecno-social systems as worlds.

When a language model is given tools and set to work on a task, it wakes up inside a world.

These three essays are about what the shape of that world might be, and why it matters more than most people building agents currently assume.

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

• Put out experience.computer
• Edited and posted the Worlds posts above
• Had a long and very cool call with Japan about bunraku pupperty, ai agents, hatsune miku and the state of Vtubers/virtual idols in 2026.
• Started sorting out ‘my financial affairs’ lol such a long job. Want to get my tax return done super early.

Terminal Access

This is a very good essay directly tackling the “Stochastic Parrot” framing of LLMs, and how almost all the claims in the original paper were false even at the time of writing. It’s a must read, or article to send to the people in your life who are still clinging to this understanding.

Perhaps the most influential single paper on the public perception of LLMs is On the Dangers of Stochastic Parrots: Can Language Models Be Too Big?. It is, however, a bit of a mash-up, and credibly seems like it should have been at least two papers. One of those papers raises many valid concerns about the ethical implications and impacts of AI training and use. Another makes the claim in the title, that an LLM is a “stochastic parrot” operating “without any reference to meaning.”

That core claim is either irrelevant or completely wrong in every detail, both in how it is commonly understood and in its technical assertions. It hamstrings AI ethics as a field, providing a veneer of technical justification for ignoring many problems.

Reading

I’m currently reading Impromptu Man: J.L. Moreno and the Origins of Psychodrama, Encounter Culture, and the Social Network by Jonathan D. Moreno. And when I find a good spot to and i’m feeling more sleepy, i’m switching over to The Heart of Prayer by Rupert Spira. It’s giving me weird dreams.

I hope to finish some of these books before Tchaikovsky’s Children of Strife drops in audiobook next week.

Funkot (Genre)

No specific track to recommend this week, as I’ve just been listening to hours and hours of the Indonesian genre: Funkot. It’s basically 190-220bpm house music thats been made with the default sound banks found on on Yamaha and Casio keyboards.

And on to of that… people… line dance to it?

Everything about this is amazing.

Remember Kids:

The post Try Our Best | Weeknotes #431 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.