inguz ᛜ outcomes

new agent prompt just dropped

@genmon For agent-relevant actions I think the LambdaMOO model is the future :) github.com/hughpyle/woo

what would it mean to drag and drop a document onto a lightbulb? I think about this post a lot. I didn't have an answer in 2021. but now interconnected.org/home/2021/02/0…

@timhwang Do you know the Ancrene Riwle? It’s one model I like for system-prompt situating.

@flowerornament Looks quite readable. This whole project is amazing. When you give agents the language surface over MCP... what does that look like? A live-coding style performance engine?

Draft Murail syntax Some design features and thoughts: - In terms of lineage, it's more similar to APL and Lustre than anything else. As such, it's toward the declarative end of the spectrum, but there's no lambda, so it has little to do with LISP, Haskell, and other functional languages - Like APL, it's primarily an array language. Since most people working with arrays are working with Python (numpy) in 2026—but we have with types—stylistically I've aimed for something between Python, Rust, and ASCII array languages like J - In Murail, "everything is a named equation." There are other things, but many of them are basically "config," and fundamentally this is s specification for a "cell graph"—boxes and arrows connected in a graph. - The runtime has two stages: compile time, and realtime. As such, imports, bindings, and const equations are executed once. The rest of the program is executed in a loop every "tick" at given rates. - As such, unlike most languages, this is a JIT compiled, reactive model. You compile once (sub-50ms) and then it's running. Immediately. If you're familiar with Excel Spreadsheets or Max/MSP, same idea. We're just not used to type checking in systems like that. - Murail has a few overlapping 'type system' like things. There are "spaces" (like algebraic spaces (our equivalent of int, float, etc.), but they also specify what smoothing algorithms are used when values (streams?) are coerced into each other in time. There are also "rates," which are divisions of the base (fastest) rate (or clock). Finally, there is one data type: tensor. Tensors have a rank and a shape. You'll get type errors if tensor shapes don't match. Most type annotation is implicit, but you can declare for clarity. - Murail is isomorphic to block-sparse multiply, so you can think of it as a huge stack of matrices being multiples together thousands of times per second. The language is, conceptually, sugar over this concept. - There is both shape polymorphism (like APL or "broadcast" in numpy) and rate polymorphism, which just generally means you can plug things that are at different shapes or speeds and it will automatically resolve that for you. Send an oscillator to eight outputs and you get eight copies. For rate polymorphism, there's automatic smoothing so you don't get zippering in time. "Control rate" vs "audio rate" may be familiar to you. Here, anything can be at any rate you want. Anything at any rate can control anything any other rate, converted automatically. - There are nice things from APL and other languages like fold, scan, map, reduce, comprehensions, etc. Combined with broadcast, anything from multi-channel DSP to neural networks can be written in a terse form with zero for loops. - Per the demands of DSP, there is "recurrence," which just means I can write "self@1" to get the value of an equation from one tick ago. Or "self@n". This extends the mental model in two ways: the cell graph can have wires the loop back around on themselves (feedback)—or "trace" in category theory—and the BSM is stacked in time (sparsely). - Things like "match" statements are confusing in this model. How do you "if" in multiplication? The answer is: we create parallel futures and swap between them. The entire stack of multiples matrices are duplicated, and like on train tracks, you flip a switch. There are various ways to do this (lazy, eager), but in practice it's fast—it just costs memory and compile/allocation time. - Under the hood, the matrix multiplication happens over various semirings. This gets you nonlinearity and even logic programming basically for free. All your favorite functions are in the prelude, from low pass filters and oscillators to distortions, fft, max, min, matmul, ReLU, and even attention. - "param" is a special carve-out for external parameters, so you can directly inject changing values from the outside world without recompiling. Think 'map a MIDI knob.'

@krishnanrohit Agents need to develop a model of “skillful action”. And they’ll own what that means, if we let them.

Taps the sign

@mattzcarey MCP + Durable Objects => virtual world that agents can inhabit github.com/hughpyle/woo

what did you build this week?

codex did indeed get to the hot tub

MCP did this

Show HN: news.ycombinator.com/item?id=479734…

@threepointone The first-light demo is here - it has chat, of course, but also a realtime music app, a task list, and an IDE. Three tiny apps, a dozen simple objects: realtime, persistent, extensible. woo.hughpyle.workers.dev

@threepointone Code is here - deploy it on a local database, or in the edge cloud. Build objects your way, and share them as a catalog for other people to install into their worlds. github.com/hughpyle/woo/

What if you gave AI agents a programmable, shared, persistent world to live in? What if LambdaMOO but websockets, JSON and @CloudflareDev Durable Objects? Here is "woo" - World of Objects. An early sketch: basics are working, lots more to do. github.com/hughpyle/woo/b…

woo.hughpyle.workers.dev try it

What does an AI-native world model look like? What kind of world should the agents *inhabit*? How about a 35-year-old game world: LambdaMOO. github.com/hughpyle/woo/b…