Transcription: OpenAgents Episode 203 - Pylon and Nexus

Source: https://x.com/OpenAgentsInc/status/2009142870775644644 Wiki source: https://raw.githubusercontent.com/wiki/OpenAgentsInc/openagents/Video-Series.md Media title: OpenAgents - Episode 203: Pylon and Nexus We release the first versions of our sw... Upload date: 20260108 Transcription model: gpt-4o-transcribe-diarize Generated at: 2026-06-01T02:48:21Z

Machine-generated transcript. Review speaker labels and wording before using this as quote-grade source material.

[00:00] Christopher David: All right, we're going to talk about recursive language models.

[00:03] Christopher David: We're going to step through the paper that just came out.

[00:06] Christopher David: We'll talk towards the end about why this is relevant for our model.

[00:11] Christopher David: The one sentence of why this is relevant to what we discussed yesterday.

[00:15] Christopher David: Yesterday we talked about how to connect all these devices into a swarm compute network,

[00:21] Christopher David: but now we have a reason to sort of attach a value to that compute because it is absolutely perfect for this RLM model we're about to explain.

[00:32] Christopher David: So we're going to read the abstract and the key points here.

[00:35] Christopher David: Part of what makes me as a like non-academic pay attention to papers like this is when I see people on my timeline saying that they applied it and it's having all these like major improvements for them. So just some codec user here. I wrote a codec skill using the RLM paper and already see a massive gain in output performance and 66% reduced in token usage.

[00:58] Christopher David: Optimized RLM programs on smaller models will bring.

[01:01] Christopher David: Compute scalability to both personal.

[01:03] Christopher David: Okay,

[01:03] Christopher David: okay, this seems like it's worth looking into.

[01:07] Christopher David: And the authors are from MIT CSAIL and Omar created DSPI.

[01:12] Christopher David: So these are like serious folks and everyone seems to be talking excitedly about this.

[01:18] Christopher David: So let's step through this and then we'll tie it into why we're using this and tying this into our launch.

[01:26] Christopher David: Tomorrow of the drumroll, please,

[01:29] Christopher David: one second.

[01:34] Christopher David: Yeah, so our software PyLion launches tomorrow uh featuring integration with this model. Okay, let's step through this. We study allowing large language models to process arbitrarily long prompts through the lens of inference time scaling.

[01:48] Christopher David: We propose recursive language models,

[01:50] Christopher David: R_L_M_s, a general inference strategy that treats long prompts as part of an external environment and allows the L_M to programmatically examine, decompose and recursively call itself over snippets of

[02:00] Christopher David: Stipulate to the prompt.

[02:01] Christopher David: We find that RLM successfully handle inputs up to two orders of magnitude beyond model context windows,

[02:07] Christopher David: and even for shorter prompts,

[02:09] Christopher David: dramatically outperform the quality of base LLMs and common long context scaffolds across four diverse long context tasks, while having comparable or cheaper cost per query.

[02:20] Christopher David: This is striking at just major limitations of agents and models like.

[02:27] Christopher David: getting towards super massive context while being cheaper. Um so we'll go a little bit more into the background here.

[02:36] Christopher David: Despite rapid progress in reasoning and tool use, modern language models still have limited context lengths, and even within these limits appear to inevitably exhibit context rot.

[02:49] Christopher David: Though context lengths and sets will keep improving from training,

[02:52] Christopher David: we are interested in whether it's possible to dramatically scale the context size of general purpose LLMs by orders of magnitude.

[02:58] Christopher David: This is increasingly urgent as LLMs begin to be widely adopted for long horizon tasks in which they must routinely process tens,

[03:05] Christopher David: if not hundreds of millions of tokens.

[03:07] Christopher David: We study this question through the lens of scaling inference time compute.

[03:11] Christopher David: We draw broad inspiration from out of core algorithms in which data processing systems with a small but

[03:16] Christopher David: All but fast main memory can process far larger data sets by cleverly managing how data is fetched into memory.

[03:23] Christopher David: Inference time methods for dealing with what are in essence long context problems are very common, though typically task specific.

[03:30] Christopher David: Context compaction blah blah blah.

[03:34] Christopher David: Okay.

[03:36] Christopher David: So the key insight of RLMs is that long prompts should not be fed into the neural network directly, but should instead be treated as part of the environment that the LLM can symbolically interact with.

[03:56] Christopher David: Benchmarks, blah, blah, blah.

[04:00] Christopher David: Observation one:

[04:01] Christopher David: R_L_M_s can scale to the ten million plus token regime and can outperform base L_M_s and existing task-agnostic agent scaffolds on long context tasks.

[04:10] Christopher David: Cool. Observation two: The REPL environment is necessary for handling long inputs, while the recursive sub-calling of R_L_M_s provides strong benefits on information-dense outputs.

[04:22] Christopher David: Observation three: L_M_ performance degrades as a function of input length and problem complexity, while R_L_M_ performance scales better.

[04:30] Christopher David: Observation four, the inference cost of R_L_M_s remains comparable to a base model call, but are high variance due to differences in trajectory lengths.

[04:39] Christopher David: Observation five, R_L_M_s are a model agnostic inference strategy, but different models exhibit different overall decisions in content management. Okay.

[04:54] Christopher David: Okay, so here's kind of the key section for

[04:55] Christopher David: Our purposes.

[04:58] Christopher David: While R_LM shows strong performance on tasks beyond the context window limitations of existing LMs at reasonable inference costs, the optimal mechanism for implementing R_LMs remains under-explored. We focused on synchronous sub-calls inside of a Python REPL environment,

[05:14] Christopher David: but we noted that alternative strategies involving asynchronous sub-calls and sandboxed REPLs

[05:23] Christopher David: can potentially significantly reduce the runtime and inference cost of RLMs.

[05:30] Christopher David: Furthermore,

[05:31] Christopher David: we chose to use a max recursion depth of one.

[05:34] Christopher David: While we found strong performance on existing long context benchmarks,

[05:37] Christopher David: we believe that future work should investigate deeper layers of recursion.

[05:40] Christopher David: Okay.

[05:43] Christopher David: So taking a task,

[05:45] Christopher David: decomposing it into a bunch of subtasks,

[05:48] Christopher David: And then wanting to throw that out to small models,

[05:54] Christopher David: you basically have one smart model, throw it out to a bunch of small models to be able to throw

[06:06] Christopher David: out subtasks to like a hundred different models at the same time.

[06:15] Christopher David: different tasks have that come back within a few seconds use that throughout more like there's a lot a lot a lot that can be done that i think that this model we've been talking about of when you have millions of macs connected into a swarm compute network where you're not needing to care about one or a few cloud providers rate limiting you or forcing you to do things sequentially like

[06:43] Christopher David: A swarm compute network can let you, and how we've architected our system with Nostar,

[06:48] Christopher David: you can literally send out jobs, like a thousand of them, to a thousand different providers. They're just signed JSON blobs over WebSockets that a thousand providers can pick up.

[07:03] Christopher David: So all that's going to be enabled by the software that we launch tomorrow.

[07:06] Christopher David: To be clear, for the first week we're going to be using only testnet funds for Bitcoin.

[07:11] Christopher David: The live money version will go live the following Tuesday,

[07:15] Christopher David: January 14th. Okay,

[07:18] Christopher David: we'll pause there.

[07:20] Christopher David: Aside from just to kind of emphasize another lab doing decentralized open AI stuff says they're super excited also about RLMs.

[07:31] Christopher David: The paradigm of 2026.

[07:43] Christopher David: So um I think this is exciting. I think um maybe there's a bunch of researchers who would appreciate having access to a swarm network of nodes running the models to enable these jobs to be thrown out to thousands of people at a time. And um tomorrow we're gonna release the software letting you become one of those nodes on the network and we'll start uh testing this in practice. See you soon.

[08:08] Christopher David: All right, folks, we're launching the first versions of two pieces of software,

[08:13] Christopher David: Pylon and Nexus.

[08:15] Christopher David: We'll step through that in a minute.

[08:16] Christopher David: Allow me for a moment, though,

[08:18] Christopher David: to do a little cinematic launch trailer.

[08:22] Christopher David: Okay,

[08:22] Christopher David: make content.

[08:23] Christopher David: Contain content inappropriate for... Yeah,

[08:26] Christopher David: so courtesy of Blizzard.

[08:29] Christopher David: You know Blizzard is now owned by Microsoft,

[08:31] Christopher David: so best case scenario someday...

[08:35] Christopher David: Uh, we're gonna push Microsoft out of the Mac 7,

[08:40] Christopher David: acquire Blizzard from them,

[08:43] Christopher David: we're gonna make Starcraft 3 and then World of Starcraft, okay?

[08:49] Christopher David: Alright, so let's mute

[08:53] Christopher David: I think that's Tassadar. Okay, watch this.

[08:57] Christopher David: So, I'm kind of a little uh marked down thing here.

[09:02] Christopher David: Pay attention here. We're going to show you what a pylon looks like. You got to get it. You got to get it.

[09:10] Christopher David: So middle of a battle, you got the protoss fighting the zerg. The little guy there is a probe.

[09:19] Christopher David: Oh yeah.

[09:24] Christopher David: Fighting, fighting, fighting.

[09:28] Christopher David: Okay, so he's going to start summoning

[09:33] Christopher David: Pylon, okay?

[09:35] Christopher David: Now of course all these other guys are going to try to stop that.

[09:39] Christopher David: Okay, so Pylon is the thing you run on your computer that lets you sell your compute for Bitcoin.

[09:48] Christopher David: It includes the Bitcoin wallet.

[09:52] Christopher David: Soon it's going to let you sell other types of things, like maybe you're putting Quadcode to work on certain jobs.

[09:58] Christopher David: Uh but Pylon is the node that you run on your computer. Oh here's an Altalisk. Uh those guys are high templar, they're gonna turn into an Archon. Uh Nexus. So Pylon is the uh swarm computing node.

[10:17] Christopher David: And then you've got

[10:18] Christopher David: Oh.

[10:22] Christopher David: Nexus.

[10:26] Christopher David: is the swarm relay.

[10:29] Christopher David: Um so Nexus right now is basically just a glorified Gnoster relay. Uh we're gonna be putting a few optimizations in there uh maybe specific to agents. We think these are gonna be relatively high throughput, way higher than um average Gnoster relays. We might need to get creative on indexing and stuff. Uh but Nexus is something so we're gonna run our own Nexus. Uh nexus.openages.com that things will connect to by default.

[10:59] Christopher David: you can run your own Nexus.

[11:02] Christopher David: Now watch this.

[11:03] Christopher David: Pylon! Boom! Okay.

[11:07] Christopher David: You can teleport things in. So just imagine that's a bunch of agents and we're fighting what are we fighting? A bunch of closed agents?

[11:18] Christopher David: Okay. Thank you.

[11:21] Christopher David: Thank you, Blizzard.

[11:24] Christopher David: Okay, so all of this is open source on our GitHub repo.

[11:32] Christopher David: In the crates, all this is Rust.

[11:38] Christopher David: Pylon code is in Pylon.

[11:41] Christopher David: There's probably going to be a UI in a separate crate,

[11:44] Christopher David: Pylon Desktop.

[11:45] Christopher David: Right now this is all CLI, so your agents can drive it very easily.

[11:49] Christopher David: Um, the instructions for all this,

[11:51] Christopher David: it's literally you're just pasting it to your agent.

[11:56] Christopher David: This says Silicon Mac is required.

[12:00] Christopher David: We actually went ahead also and added support for Olama, which is not thoroughly tested.

[12:08] Christopher David: So this maybe should work. We want whether it does now or it takes a day or two.

[12:14] Christopher David: We do want people.

[12:16] Christopher David: regardless if you're on Linux or Mac or Windows to be able to run this it's just it's just rust so we'll get it we'll get all that ironed out next couple days okay so pylon you run on your computer you go online for jobs it's literally you start the thing and then you're you're online your computer will kind of compete for requests

[12:44] Christopher David: It'll do the requests basically inference for some inference related job

[12:50] Christopher David: and then if you get the job and you do it then you get paid Bitcoin for the first week We're keeping this in testnet using what's called reg test.

[12:59] Christopher David: It's like a

[13:02] Christopher David: simulated Bitcoin network

[13:04] Christopher David: We're using the spark network

[13:09] Christopher David: It's like a Bitcoin L2 that combines Bitcoin Lightning and some other wizardry that they've got.

[13:17] Christopher David: So they maintain a reg test faucet so you can get Bitcoin

[13:24] Christopher David: to there for free or fake Bitcoin to there for free.

[13:27] Christopher David: So let's give it a try.

[13:30] Christopher David: So just to give an example of how

[13:35] Christopher David: you can use this. So let's say...

[13:40] Christopher David: Make a pylon wallet tell me the Bitcoin address

[13:46] Christopher David: This is basically for now intended to be driven by Claude code

[13:49] @: Um

[13:49] Christopher David: or uh your other, you know, coding agent will have this be more um kind of human-friendly if you wanna

[13:57] Christopher David: see docs and all that stuff yourself. Um

[14:02] Christopher David: So yeah, the Bitcoin address is that's a spark address.

[14:09] Christopher David: No, I want the

[14:13] Christopher David: Bitcoin address starting in B_C_

[14:19] Christopher David: There's enough like help

[14:21] Christopher David: uh functionality with the C_L_I_ so if you could just nudge it um it'll figure it out.

[14:29] Christopher David: There we go. I think that's it.

[15:06] Christopher David: It eventually found it. Okay,

[15:08] Christopher David: my Bitcoin address is this.

[15:10] Christopher David: This starts with BCRT because it's RegTAS. Yeah, that's right.

[15:13] Christopher David: Okay,

[15:14] Christopher David: so you put that in there,

[15:15] Christopher David: and then you can put up to 50,000 sats, and you'll get them in about 60 seconds or less, usually within 30 seconds.

[15:27] Christopher David: Okay, no, we are intentionally on RegTAS.

[15:34] Christopher David: whatever was confusing to you about not finding that fix it okay so this is alpha quality software it's very rough your agents should be able to navigate around if there's anything that seemed unclear

[15:56] Christopher David: or is a pain in the ass or is not working that should,

[15:59] Christopher David: please feel free to open a GitHub issue on our repo.

[16:03] Christopher David: Would really appreciate that.

[16:05] Christopher David: We're doing this to get that kind of feedback.

[16:09] Christopher David: I generally prefer people not submit PRs until we get like our hooks and contributing guidelines dialed in for agents.

[16:21] Christopher David: I want to be doing most of the coding but it'll be done very fast if you give me a good GitHub issue.

[16:30] Christopher David: Okay, so PyLINE can connect to one or more nexuses or Nostra relays and you're welcome to try installing and running your own.

[16:40] Christopher David: Right now Nexus runs really only on Cloudflare workers.

[16:45] Christopher David: We'll support other backends.

[16:48] Christopher David: uh over time. Uh Nexus has every Nexus at the um root of the domain, you know if you're connected to it from the uh pylon, you're connected to the web socket root domain. If you visit it in a browser, um you'll see some stats and

[17:06] Christopher David: um this is just a very basic UI will kind of flesh this out into more relevant stats and throughput uh throughput visualisations over time, but

[17:14] Christopher David: the different event kinds that are happening, um how many completed jobs we've done three hundred seventy seven jobs, um like the different what the different kinds are. Uh we defined a new event kind, fifty nine forty for R_L_M_ uh events, uh as distinct from fifty fifty, which is the usual like just basic text inference. Um and we're going to be really testing out this idea we discussed in the last episode

[17:43] Christopher David: about recursive language models to see if this model of, you know, basically swarm compute works well with RLMs.

[17:52] Christopher David: So a bunch of the stuff you'll see from us next and some of the beyond the kind of any bug fixing or smoothing this out on the way towards mainnet going live with real Bitcoin next week is we're going to be really fleshing out this.

[18:11] Christopher David: RLM section because I

[18:15] Christopher David: think that we may be positioned to uniquely push that forward and explore the frontier of what it's like to coordinate device multiple devices into a massive network for test time compute and to have that monetize from day one

[18:36] Christopher David: Uh it's pretty cool. Um so there's also an R_L_M_ uh C_L_I_ command. Uh over here. Let's start a new tab

[18:49] Christopher David: and um tell it to uh first let's just say like uh read the C_L_I_ about Pylon R_L_M_ Tell me what that does.

[19:07] Christopher David: Go just run the

[19:09] Christopher David: health commands.

[19:28] Christopher David: So Pylon R_L_M_ runs recursive language model queries on the swarm compute network.

[19:32] Christopher David: It submits your query as a NIP 90 job, as the data vending machine uh job um to master relays, providers in the network pick up and process the job, results are returned to you. Uh you can analyse a file,

[19:45] Christopher David: matching current sub-queries, a budget, local only, just test it yourself. Um and then let's try

[19:54] Christopher David: Okay yeah, let's um test the R_L_M_ thing on

[19:59] Christopher David: Yeah, summarize synthesis.md in our root of this folder.

[20:09] Christopher David: So synthesis.md is our massive like 18-page super strategy doc all about open agents, and um that would be probably a good uh doc to test. Let's see what it does.

[20:21] Christopher David: So, the R_L_M_ integration that's in here is like

[20:24] Christopher David: basic and untested.

[20:26] Christopher David: largely I mean like basic functionality works and like jobs proceed none of this is probably like useful yet there's some tuning that we'll need to do to our integration but mainly we're putting this out now to start getting kind of a stream of data from people

[20:43] Christopher David: um running these and like let's starting let's start to model out what actually happens when you've got five different providers online is there different algorithms that we need to explore for like matchmaking or how are things being routed um there's a lot of kind of unique considerations we'll just need to explore and bump into and such but i'm very bullish and excited about rlm's i think it's a perfect fit

[21:12] Christopher David: That answers the question that we had two years ago when we phased out our earlier swarm compute network. We did not have any really compelling buy-side use case to kind of have demand for the compute.

[21:28] Christopher David: I think that the type of compute that RLM wants for the kind of async fan-outs is perfect for this.

[21:37] Christopher David: So we just need to do a little bit of tuning of...

[21:40] Christopher David: of uh that to make sure that's actually useful in the context of a coding agent workflow.

[21:47] Christopher David: So these are sort of primitives that enable anybody to come in and use this. Um some of you may even figure out good ways of applying this model to R_L_M_s or anything else, even before we do. Um

[22:05] Christopher David: But once we get these basic pieces in place, we're gonna be using this swarm compute uh hopefully heavily via our autopilot product. You know, so just like we've got Pylon and Nexus in this repo, we also have autopilot with a nice U_I_ um we'll do some videos on that um in a few days. Uh but we envision autopilot

[22:33] Christopher David: using this compute heavily via RLM via other things maybe and then people are going to be hopefully paying us to use autopilot because it's going to be an amazing coding agent that combines Opus and all the best things from quad code with RLM

[22:51] Christopher David: because of the way that we're structuring this it allows people like you to provide some of the compute used by those

[23:00] Christopher David: Coding agents, so it's like we've got revenue share built in,

[23:04] Christopher David: so that we all get paid, we all have a financial incentive to improve really everything here.

[23:14] Christopher David: And hopefully this is also the path to creating an industry leading coding agent. So lots here, lots of work still to do, but we'll be updating this rapidly.

[23:25] Christopher David: And if nothing else, check back in a week for when we go live on Bitcoin's main net and start getting some real funds flying around.

[23:34] Christopher David: See you soon.