Date: 1 September 2026 Participants: Frode Hegland, Gabo Beaumont, Eric (Seed)
Editing notes: filler, false starts, cross-talk and interruptions (doorbells, laundry, connection issues) have been removed. Transcription errors have been corrected: “CT”, “see”, “seed” → Seed; “fraud” → Frode; “Lord”, “cloud”, “blood” → Claude; “hyperthermia” → hypermedia; “Damon” → daemon; “our gummy text” → Origami Text. Speech has been lightly tidied for readability without changing meaning. Nothing of substance has been cut.
Gabo: Let me share my screen and explain how Seed works and how I think we can offer the connectivity it provides to Origami Text.
Our experiment for the conference is this: we have a repository, we import the open access papers initially, and we add all the metadata. Ideally we do some fun things too, so that, as we said yesterday, every single piece of information is one click away from being addressed, and discussions are one click away from any piece of information.
This is local-first. It’s a peer-to-peer app running on my computer. All the content is verifiable, everything is digitally signed by keys. It also runs on a web server. So you could either connect to the server, or we could easily create an integration with Origami Text where you download all this content and transform it at runtime to your schema, including comments and annotations. People could be using different software, but there is one body of knowledge, conversation and annotation.
(Eric joins.)
Gabo: Eric, I’m sharing my screen and explaining to Frode the experiment we’re going to do at the conference, and we were discussing how to do the integration with Origami Text.
Eric: Could you first explain the goal? That will inform how we integrate everything.
Gabo: I think we’re still in the middle of brainstorming what the goal is. Unless Frode already has a clear one.
Frode: I have a clear, vague goal. We absolutely need to brainstorm what it means, but here it is. Origami Text is EPUB with two attributes. One, the visual layer is strict EPUB 3. We don’t add anything, and we say: don’t add anything yourself either, because then we get compatibility issues, which is one of the main reasons EPUB is not successful in academia yet. Two, it uses the Visual-Meta approach to metadata: if it’s important, write it down. All relevant metadata for how to cite the document, the BibTeX entry, the references, the structure, glossaries, is written in the HTML inside the EPUB wrapper and in a separate JSON. That’s it.
This gives rise to a huge amount of interactions and accessibility options that PDF cannot provide and HTML can, but without portability. So we look at EPUB as HTML in a box. It’s very similar to what you’re doing with your local-first approach.
What would be really cool, impressive and useful is if we can use your system on an EPUB to do annotations that are easy for the user to share in a live environment. Imagine that in a session, somebody is reading an EPUB while someone is presenting, and they add annotations, side notes, highlights, whatever, and that is shared with the other people in the room to help the discussion. That sounds about what you were thinking too, right?
Gabo: That’s exactly the experiment we wanted to do. We want to demonstrate that this can be done with sovereignty, with no central authorities. That a community can collaborate, maintaining attribution, without giving away their data rights to Google Docs or Amazon Web Services or any central server. If we could amplify this experiment with two different applications, our own Seed application and a second application, Origami Text, using our syncing engine and hypermedia network to connect members’ devices, that would be really something big.
Frode: The reason it’s exciting for me, in addition to working with you, is that Origami Text is aggressively open source. It’s entirely coded by me and Claude in Xcode. In the settings there’s an option called Open Source with two buttons: one describes the format, the other describes how the app was built. The idea is that whether human-coded or AI-coded for another platform, there’s enough detail there to make that possible. All the source is on Git, obviously, but we’re also trying to make it really easy for any enthusiast to make their own version. We have a module system for views that works the same way, so you don’t have to redo the whole app, you just build the view you want. To show that this can plug into what you’re doing would be a really good proof of concept of the community aspect.
Eric: So is the idea that Seed is treated as the database, and Origami Text is a view layer on top? I’m trying to understand where the source material is stored, and what the user story is: what the user sees, what they click on, what they want to do, that we want to demo in this integration.
Gabo: I think we want to use hypermedia as the distributed application database. The question is how we treat Origami Text as a kind of middleware, because it owns its own data structures. Eric, if it’s too hard, tell us.
Eric: You need to describe the goal in more detail. “Middleware” doesn’t mean anything by itself. Let’s walk through the user story and then we can figure out how to accomplish it technically.
Frode: (sharing Origami Text) There are many ways to see things. Let’s go to Proceedings. The whole point of Origami Text in terms of usability right now is to help people go through a set of proceedings quickly to decide what to read.
Gabo: Are you okay with me taking public notes? I want to document what the customer journey is going to look like.
Frode: Absolutely. And I can make this video public later or keep it private, whatever you prefer.
Talking directly to the customer journey: someone downloads all the papers from the conference. Hopefully they’ll be in the Origami Text EPUB format; I’m in talks with the ACM to make that an official alternative distribution this time. They import them, one by one or in a batch. Under Proceedings you see the names of the authors on the left, and auto-extracted concepts, and you can choose how to view them.
Once you get to a paper, you can do many things. There are many views: horizontal column view so you can read more as you would expect a paper on a bigger screen, and a focused view. There are many options that are important for accessibility. Some are strange, but accessibility is a huge deal for us, not just for people with issues but for all of us. This is colour coding based on grammar, based on meaning, based on arguments: “we argue”, “support”, and so on. We can also make it more of a flow read. There is text-to-speech too.
Now to your question. Annotations are important. Here is highlighting. I’m still working on it, it isn’t flawless. These are colour-coded highlights. What would be really cool is if, in addition to highlighting, we could use the W3C annotation standard, which this should already be using, to live-share this, so that when I’m sitting in the same room with you, whatever is highlighted appears for you.
Gabo: Can you create an annotation with a comment?
Frode: Let’s say this is problematic… it didn’t appear, so that’s obviously a bug. But this is experimental.
Gabo: One incredible option is that you create a comment here and that comment appears in our site. Eric, is this too crazy? Are we flying too close to the sun?
Eric: Are there collaborative features in Origami Text? If there are two comments, one from you and one from me, and they show up in my Origami Text, do they both appear as my comments? We would need to integrate a whole identity system, which seems like a lot. Maybe there’s a more focused workflow. This is why I keep asking about the exact user story. Maybe we can support comments flowing in one direction, but both directions is hard. It depends how much time we have.
Frode: I think we have two weeks.
Gabo: I would treat this as an experiment. We need to be honest with ourselves that this is not going to be production-ready in two weeks. It’s a way to give the community a taste of how we imagine the future.
Eric: So the user story is: some users want to use Seed and some want to use Origami Text. But then we need to make everything work in Origami Text: links, version history, identity…
Gabo: No. In my opinion we don’t need to make Origami Text into Seed, or Seed into Origami Text. We can’t recreate all the functionality of one in the other.
Eric: We could. Some users want to use one and some the other, and that’s the why.
Gabo: But for different purposes. Frode, correct me if I’m wrong: Origami Text right now is more of a personal experience.
Frode: Yes.
Gabo: So Origami Text is for somebody to think and reason with information, and it has far more affordances for that than Seed does, because Seed is focused on the collaboration itself. Maybe that’s the experiment: Origami Text does one thing, Seed does another, but we archive the documents and annotations from Origami Text into Seed so everybody can see them.
Eric: So we flow the comments from Origami Text into Seed. That’s a very tangible workflow.
Gabo: One more thing. Frode wants to make Origami Text local-first independently of Seed. So in my mind there are two possible architectures. One: Origami Text connects to the server, as our app does. Two: Origami Text uses our daemon for local-first connectivity, so Origami Text users get our local-first superpowers and can sync content without a central server. Maybe that’s not for these two weeks.
Frode: My experience with what some people call vibe coding is that it’s like working with a programmer who is sometimes brilliant and often gets dumb things wrong. The benefit is a little bit cost, but mostly that the boring stuff gets done. Origami Text is now highly functional in some areas, particularly views, but also quite brittle. With Claude in Xcode I made literally the whole solar system and it’s amazing, but moving things around in a settings dialog can fail forever.
My point is this. What would actually be useful for the hypothetical person in the session? They have the speaker’s paper open and they want to make a note that is shareable. A highlight maybe, but it might be even simpler. Origami Text EPUB has high-resolution addressing; the system knows where things are. That’s a very Doug Engelbart thing that had to be built in from the beginning. So if we simply have notes in the margin that are distributed — Eric and I talked yesterday about devices on the same network — even if it’s just text messages that land on the right page, that would be cool and useful.
Eric: Totally. It sounds like comment syncing is what we want to focus on. Maybe that can apply to annotations too, but the way Seed annotations work, they are baked into the document, whereas comments are a floating layer of discussion, which is more flexible for this use case.
Frode: Let’s imagine the three of us are in a session with Mark Bernstein presenting. He says something really cool. How do we share that with our buddies? If we’re sitting next to each other we might whisper, “that’s cool.” If there’s something questionable we’d like to ask him at the end, we might write it in a note. How do you envision being this participant, with the paper in front of you, wanting to express that to the rest of us?
Gabo: Does Origami Text have an iOS app, or is it desktop?
Frode: That’s down to me spending a couple of hours saying “no, that’s wrong, do it again.” We can have one.
Gabo: We need a certain SDK for identity and connecting to a server and signing in. Eric?
Eric: We have an SDK in TypeScript that could be ported to Swift. We don’t have one ready to go for Swift.
Frode: In my experience, Claude in Xcode does incredibly sophisticated things really well; the problem is the details afterwards. Almost anything you give me, I can set it to work on and we see if it works.
Eric: It usually comes down to how well you test it. We could tell it to convert to Swift and it might look like it works but have big bugs that haven’t surfaced. If you’re testing as you go, it’s totally worth a try.
Frode: And it would be added to Origami Text as a plugin of sorts. (showing settings) This is the Open Source section: the description of the format, automatically updated whenever I make changes; how the app was built, including the visionOS implementation; and the view modules. Each is a Swift file. You can import or create your own, it tells you what you need to do, and there’s a starter module.
Eric: It’s cool that it accepts the source code directly. Usually there’s some weird build process and plugin format, but your plugin is just raw code.
Frode: I’m a Photoshop guy; I’m fast because I know all the shortcuts. I’m trying to make a system for a similar level of user: not a coder, but someone willing to get their hands dirty. Here are the AI settings. If you have LM Studio or Ollama running it finds the models, so you don’t have to use the paid online ones. Here are the AI prompts. Under assistive technology we have Apple’s voices and one that has to be downloaded. I’m thinking that’s how we do the Seed integration: it’s an install, it has settings, but it’s entirely an external thing added to augment your experience.
Eric: Sure. There are several layers of plugins here: the LLM integration is more deeply integrated but still flexible, while the view plugins are fully independent.
Frode: I’m installing Seed Hypermedia now. (Gabo has sent the mobile app link.)
Gabo: It works on desktop but it’s meant for mobile. The interesting thing is that this one is not running the whole P2P stack, which is heavy on computer resources. It connects to one server and that server provides the syncing. So one option is exactly this: Origami Text just connects to the conference server. The conference server is infrastructure that helps with online/offline coordination, but it’s not required, because the data is self-verifiable.
Frode: I think that sounds absolutely perfect.
Eric: (to Gabo) You sent him the iPhone app and he’s on desktop. I don’t think we should be promoting this to desktop users, but the Seed website works in exactly the same way: it doesn’t require a daemon. If you do run the daemon you get a lot of benefits: you can connect to others peer-to-peer, and if you’re not connected to the internet but can reach each other, you can keep collaborating. And these options aren’t mutually exclusive. You could run the Seed application locally and benefit from the peer-to-peer features, or the daemon could run inside Origami Text, which is another exciting possibility.
Frode: The way I read what Gabo showed me: this would be inside Origami Text. You give me the code to be a client, and that’s a tab in settings. What I saw is: it works. Now you need to tell me how to make it work so that someone in Origami Text goes to settings and connects. What should we call it? I don’t want to call it Seed; it shouldn’t be a brand name. Connections? Community?
Gabo: You can call it Server.
Eric: The hypermedia protocol.
Frode: Let’s have a tab called Hypermedia.
Eric: We already have that separation from our brand.
Gabo: When we changed the name to Hypermedia, we chose that word for the protocol precisely because you cannot register it as a trademark. Protocols are starting to register their names so you need permission to use them. I said, let’s do the crazy thing of using a word that cannot be trademarked.
Eric: It’s a pre-existing word and other services already advertise themselves as hypermedia systems. It’s fully undefendable, which we chose deliberately. In the same way Apple can’t sue another company for selling a watch.
Frode: Okay. We’ll call it Hypermedia. Now you need to provide me with the information I feed to Claude.
Eric: We already have GitHub repos that do this, on my personal GitHub. One can both read and write content and has a “sign in with Seed” experience. Sign-in is a little tricky because it has to go to what we call the vault, where your keys are encrypted and saved on the server, which gives you easier access to your keys. That’s only if you want to write content into Seed. If you just want to read, I can give you a simpler example. I’m posting both on our Discord channel. Both are TypeScript, but the same ideas should work fine in Swift once Claude gets hold of them.
Frode: Then we have to coordinate with the server which paper is being read, right?
Eric: Everything has a URL. A Seed document is identified with a hostname and a path, a human-readable document name. URLs are the interoperability layer. Once you’re in the Seed world, you can upgrade a normal web URL so the link can’t break, or is almost impossible to break. By default web links are fragile. The real benefit of hypermedia comes when you convert them to hm:// URLs, which contain keys and IDs so you can get the content from anybody. If your URL includes the server name, you need that server to be up, not hacked, and paid for. With the hypermedia URL you don’t need that server, you can get the content from anybody and still have complete integrity.
Frode: I’ve written the key interaction in the chat. Do you agree with it? Once I wrote it down it changed a bit.
Gabo: This is so exciting.
Eric: For the commenting system to work, we need the actual documents to be available identically in both locations. Opening documents is probably going to be the biggest prerequisite.
Frode: It will have to be the EPUB, made by us to begin with and distributed by ACM.
Eric: Why? There are lots of documents on the hypermedia network and it would be really cool to open those in Origami Text.
Frode: The last part was an assumption, not a truth. As long as we have permission to also distribute these as EPUBs, I’m very happy to have them on your server, because the way they’re opened in Origami Text now is clunky, one by one. The documents you’ve seen there, including your paper, are there because Mark Anderson gave me the zip of the Overleaf LaTeX version. Origami Text can read that and convert it cleanly to EPUB. Converting a PDF to EPUB is extremely onerous, especially with images. So if we have permission to put the EPUBs on your server, that would be ideal.
Gabo: How do we get permission for that?
Eric: For the conference proceedings, I thought we were already planning to put them on Seed. That’s something Gabo and Mark have been working on together, so the permissions should already be there.
Frode: Good. Origami Text is something Vint Cerf and I have been working on for a while, and we have a paper pending in Communications of the ACM on it; it’s just taking forever with committee stuff. At a high level, everybody I know in the ACM Hypertext community supports moving away from PDF. The chance of it not being allowed is tiny. I’ll give you the papers once they’ve been converted, you put them on the server, everybody’s happy.
Gabo: Our approach, Mark’s and ours, is that this is the Hypertext conference and we are doing an experiment. We shouldn’t be strangled by bureaucracy and copyright licences. We need a space of experimentation. Data rights are super important to us and we want to be compliant, but how can we build systems that protect digital rights and still boost collaboration? We need to find a way of doing it.
Frode: For previous years, what is the source technically? Only PDF, or HTML, or LaTeX?
Gabo: A mix. Some years we have HTML.
Frode: Because if we convert one year, or even a section, to EPUB, we can really start testing.
Gabo: Eric, how do we attach the different formats to a document? The document has its own format that gives you verifiable keys, authorship, attribution and versioning. But then you can link up to a PDF or EPUB. Do we store them together as IPFS files?
Frode: You’re talking about editions: a PDF edition, an EPUB edition.
Eric: There are different ways. It depends what workflow we’re optimising for: archival looks different from readability or editability. What I would usually do is bring it in as a full document and link to the underlying data beneath it. But if we need to keep both versions up to date, the Seed version and the Origami Text version, and especially if the format is lossless, then storing it as Origami Text might only hurt you because it would slowly get out of date. Instead you’d have an export workflow that takes the latest hypermedia document and exports it to whatever you want, including Origami Text. If you have a bunch of documents linking together, you might need to export them together.
Frode: That’s not a worry, because Origami Text is intended as a publish format. It should never change; only the annotation layer above it changes.
Eric: And the URLs will never change?
Frode: I can’t guarantee the URLs, but the document name should never change.
Eric: In the web world and the hypermedia world we always have to resolve to a URL of some kind, and we’ve thought very deeply about this. Sometimes you want to reference an old version, sometimes the current version, sometimes part of the current version, sometimes an exact word. We have a sophisticated link format that handles all of that through the protocol; it’s totally open and you don’t need our software to benefit from it. When it comes to importing and exporting, links are usually where everything breaks. Maybe a Seed document is intentionally linking to an old version of another document, because the author changed their mind and you want to discuss what they used to say. When you export that URL, will it be correctly interpreted by other systems like the web or Origami Text? Clicking it needs to take you to the old version, not the latest.
Frode: In the Origami Text world, and this is where we interestingly differ, there are no links in that sense, because the expectation is that everything is in the EPUB itself, online or offline: the version, the date, immutable. If you want to compare two, you compare the dates. We can probably get around this by allowing localhost or similar, so if you have the documents on your own system, physically or virtually, it feels local and works.
Eric: We have to figure out how we want to do links, or whether to prioritise them at all. We only have two weeks. Focusing on the commentary layer may be more fruitful than dealing with all the weird things about links. Is it possible for one document to cite another, or do they both need to live inside the same EPUB?
Frode: We have the normal citation handling, including abstracts of what you’ve linked to, but we only really deal with links from the document to its citations, its references. It’s important, because if the cited document is in your own library you can do other things with it.
Gabo: Do you have a schema for Origami Text? For the paper I was researching Alan Kay’s ideas on distributed objects across the internet, where different developers build their own objects that are at heart the same concept, say a document. He came up with the idea of content negotiation, or schema pattern matching: two documents built by different developers need a kind of negotiation to interpret each other. So everything boils down to schemas. What’s the schema of Origami Text, so we can create this semantic negotiation between Origami Text and Seed and see if both systems can interpret each other?
Frode: I’ve put a link in the chat to the website, with links to the repo and the macOS app. The macOS app links to the document format, and I’m happy to answer questions. Eric, there’s a two-minute video, did you see it?
Eric: I saw a little bit. I love the music.
Frode: A few things worth noting about the Map view. It can only happen when the document is local; it doesn’t have to start local, but it has to be downloaded. All the cards beyond the first ones are whatever can be extracted from the citations currently. To integrate this view with the actual data you have would be insanely more powerful. We can talk later about working in XR, not just on the Mac; the graphs are there in visionOS too. When we’re talking about different kinds of annotations, the opportunity to attach little things on the side saying “people really loved this” or “hated this” is massive.
But let’s start with a very simple thing: someone is reading a paper, they write a note, and other people in the community can see it live. That in itself is very cool.
Eric: Okay, so bidirectional comments. If we ask your agent to create a “sign in with Seed” workflow — this is a grey area between Seed and the hypermedia protocol that we haven’t figured out yet, so maybe it says “sign in with Hypermedia” — parts of the protocol like the sign-in workflow haven’t been formalised. It goes to hyper.media/vault, where your keys are stored encrypted, you sign in there, and it gets your identity back into some other place, like a website.
Alternatively we can have a key import/export workflow, which might be easier. It’s a little clunky to export the key from Seed and open it in Origami Text, or there could be a button inside Origami Text that creates a key for you, but then it can’t be used in other ways. I would recommend the import/export workflow as a faster way of getting going, rather than the full redirect to the vault and key selection, which is more complicated.
The two examples I sent on Discord: I haven’t read the code, I just verified that they worked. I used Claude Fable and it got it right on the first try. So it’s worth asking it to do the full thing.
Gabo: Can we do it together and see what happens? Is Eric’s prompt enough, or do we need to create a new prompt or skill: how somebody integrates hypermedia into their application to participate in the distributed network?
Frode: Just before I stop sharing: what you’re seeing now is a highlight, an annotation. The key thing is that when you go to Outline and choose Overview, it’s also there. Because EPUB is a flexible text format, the same annotation is shown in two different ways. I wrote a comment on the first sentence; here it is in the overview, in colour. So if we manage to send that kind of thing, or even a free-floating note, it can appear in many different views, including an overview, so it doesn’t have to clutter up people’s reading. That’s the kind of experimenting I’m looking forward to.
Gabo: Eric, are those examples enough for Frode to integrate hypermedia into his app, or can we describe a better prompt or skill?
Eric: Maybe some documentation would make it better, but I’m not sure we have it. When I asked it to make those examples, I used a few extra words and the technical names from the library it uses. I didn’t use a complicated prompt or a bunch of documentation; the agent figured it out as long as I told it which library to use. The library is listed publicly in the example, so when the agent looks at the example code it understands it needs the Seed client library. But that’s a TypeScript library, so it won’t be super helpful for a Swift application; the agent will have to do more work to port it. I’m not sure how well it will work, but there’s not much I can do to make it better.
Gabo: Maybe we ask people to bring their laptops. Porting all these views to mobile is going to be hard.
Frode: Laptop is very good.
Eric: Either way it’s all Swift. Swift is used for Mac apps and mobile apps, and that’s what Origami Text is.
Frode: The difference between Mac and iOS is much smaller than it used to be. But we will absolutely base this on laptops.
Gabo: So maybe we can see what happens. It’s going to take hours.
Frode: If you can provide me with directions for Claude, I’ll paste them in and we can see.
Gabo: Eric, in your examples there’s no schema conversion. Will Claude figure that out?
Eric: What happens if the Origami Text data is not the same as the hypermedia data? That’s the problem only when you place a comment. For comments to work, the document itself must be the same in both places. So we have to start with just reading documents. Every document that gets opened, if it has bidirectional comment syncing, is going to be a Seed document that can be rendered inside Origami Text. For every document there must be one source of truth. And we need block IDs for the referencing: every paragraph has an ID in the Seed schema, and that’s how you address where a comment goes.
Frode: Two comments on that. The basis of Origami Text is the W3C annotation standard, like Hypothesis and others. Even more core than that: this is a community project. What we have in Origami Text is not public, no one’s using it. So if you want me to change something inside Origami Text, that’s not an unreasonable ask at all. When you talk about a schema, I think what you specifically mean is addressing. It’s reflowable text, so x-y-z coordinates don’t mean anything; it’s a matter of which paragraph. There we have Doug’s purple numbers and all that good stuff. Currently all the paragraphs in the Origami Text EPUB have IDs. Whether it’s worked out correctly is a different issue, and whether it works with your method is completely unknown. So Eric, send me something to teach Claude and we’ll see what happens. Then we should have another meeting quite soon. Please also download Origami Text now and look at it for all its flaws. If you have any usability or end-user issues, tell me. I’d love to fix those as well.
Eric: Very exciting.
Frode: There are a lot of unknowns, but we can solve them together.
Gabo: For me the biggest topic is the transformation between the two schemas.
Frode: I don’t think that’s a big issue. Well, maybe it is. The way I see it: two people have Origami EPUBs in two different instances of the app, and they make things happen between them. You’re also very interested in having an original copy of that document on your server, and having whatever is done in the EPUB transferable to that as well. Conceptually that’s trivial — conceptually only, I’m not saying implementation — as long as we can map the addressing. Eric, why don’t you write it in plain text, with the expectation that Claude, working on Origami Text, will either say “this is horrible” or “I can use this straight away.” Do you have a snippet now? I can try it right now as a verification.
Eric: I’m pretty confident it will work structurally, as long as we’re talking about paragraphs and headings, which is 95% of the content, plus bullet points and links and predictable forms of content. I’m 99% sure that will all work. There might be very weird cases.
Frode: Let me tell you one as an old friend. When I started experimenting with Claude and Xcode, I redid many old apps that had died because I couldn’t afford to keep them updated. Then I worked on Author, my flagship app. One thing I’ve never been able to do with my human programmers is tables: the table support Apple provides is awful. I just did it. Then I thought, what the hell, can you make it a live spreadsheet? Yes. So now in Author you can paste a spreadsheet from Numbers and it’s live. Export that to EPUB, open it in Origami Text, and you can manipulate the numbers and equations live. The changes are stored as web annotations until you click reset. That’s the kind of thing that’s probably very hard to address. Though the question is whether it needs to be independently addressable.
Eric: We’ve had to do some very weird things for tables very recently too, but the complexity came from a different place. For you the interesting thing was live editing and formulas. For us it was: what happens when somebody on an airplane is moving a column while somebody else who’s online is adding a new row? Without a good system the table ends up mangled, with a cell out of place. We developed a system that resolves that properly, so tables inside a hypermedia document have a very weird format. That’s the sort of thing Claude can handle if you point it at our codebase, especially if you give it access to read and search hypermedia content. Sometimes it won’t support tables at all, and then we say “look at how columns and rows are organised in the hypermedia schema,” and it understands. Let’s deal with edge cases as we come across them.
Frode: What you’re describing goes all the way back to Doug. We once did a speed test: I was on a Mac, he was on NLS/Augment, and we decided to look up the phone number of a mutual friend. I had to find my address book, open it, find the search field, type, hit enter. Doug didn’t break eye contact with me: he typed “open the document called Contacts, go to the section beginning with this name.” That’s relevant here, because with his jumping and addressing system, in the future we should be able to say: go to this EPUB, find the second spreadsheet, run the calculation with these different numbers, compare it with this other spreadsheet, and get back to me.
Eric: Definitely. A big part of what we’re doing now is figuring out how to deeply integrate AI workflows, because agents can make very quick work of that. Right now we rely a lot on the cloud models, but it’s already possible in our product not to. They’re going to get better and cheaper, so relying on Anthropic and OpenAI will soon be much less of a concern.
Frode: I have friends who use their own models, but they’re on holiday and I don’t know which ones to choose. That’s the new thing: LLM DJs, the tastemakers.
Gabo: One question. Do the Hypertext authors already expect their papers to end up in Claude or OpenAI? Will they be surprised? Personally I think that happens all the time; somebody takes a PDF and asks OpenAI questions about it. The probability of your paper not ending up in Claude is basically zero.
Frode: I wouldn’t worry, for many reasons. One is the reality you’ve just described. Another: ACM has a new president, and one thing she cares about is inclusivity, and I believe accessibility along with it. That’s part of why I’ve added so many accessibility features to Origami Text; I was going to anyway, but it made it more urgent. If we manage this test with papers both on Seed and in EPUB, it’s clearly a better reading experience for many, and the AI integration is less guessing and more the AI getting the metadata cleanly. It would be insanely weird if the Digital Library board or the president said no, let’s keep it like paper copies.
Gabo: Our system is getting very integrated with AI. You can choose any provider, but in reality, until we have better access to open-source models, we end up using one of these.
Frode: I have to go in two minutes, but this is very exciting and I can be available for discussions online. I think I’m still on the Discord.
Gabo: Discord is the easiest channel for us; we’re there all the time. Hopefully one day we can get rid of it.
Eric: You can also mention us on Seed and we’ll be very responsive. It would be cool to create a Seed site for us to write more documents, because knowledge on Discord is very disorganised. Very discordant.
Gabo: We can use the ACM Hypertext London site.
Eric: Perfect.
Frode: Eric, my technical knowledge is extremely limited. I’m not an Xcode-Claude person with vast programming experience like you. I’m an Xcode coder based on “move this to the left and make it jump right.” So please prompt me too: write really clearly what I need to tell Claude. Talk to me like I’m an LLM on Discord and it’ll be a lot easier to get the right stuff. Also, there’s no reason you can’t open Origami Text from the repo and do whatever you want in a branch, if you prefer that.
Eric: Totally. There are so many ways to collaborate. I’ve sent you one prompt on Discord. We may find we need to do more research and use the agents together. Seed agents are meant for collaborative interactions like this: on the site there are agents you can mention, and they jump in and do research. One of my agents can even code and send pull requests, though that’s not great for a Swift app because it can’t test it well. What they’re good for right now is research: they can search all of hypermedia, search the web, do almost anything you ask. I’ll show you some demos.
Frode: It’s an incredible time for experimenting. When I first talked to Mark Anderson about this I said: we can do stretch text now, we can do whatever we want. There’s a lot of hypertext history we can go back and make real, plus new ideas. (showing Xcode) Here it’s doing what you asked.
Eric: I haven’t actually seen the Xcode harness in action. This is cool.
Frode: It’s beautiful. Up here you have the play button that builds, and to release you just go to Archive. It can be quite friendly.
Eric: It looks like it’s busy researching. It’ll take a while because it’s a big project, but I bet it’ll come up with something that works a little bit.
Frode: I’ll post the result on Discord.
Eric: Can’t wait. If you want to jump on a call later today, let me know. Meanwhile we’ll chat online.
Gabo: We’re happy to jump into a call informally any time.
Frode: Let’s leave it at that. Thank you, gentlemen. It’s been inspirational, practical and very fun. I’ll post the video unlisted, have the transcript analysed and share the text with you so we have a record, if we agree.
Gabo: Yes.
Eric: Sounds great.
1 comment