Of course that the animations won't map to all the animations you can manage with js.

We haven't built it yet, but its on the roadmap

Comments URL: https://news.ycombinator.com/item?id=48294621

Points: 1

# Comments: 0

Did you try to also support OpenClaw/PicoClaw etc? Maybe OpenFang? I've found that since OpenFang is so different to the other harnesses its hard to share the same abstraction layer

I'm building a similar thing at https://spawnfile.com and https://moltnet.dev but these are focused on autonomous agents

Also they are completely opensource

https://github.com/noopolis/spawnfile https://github.com/noopolis/moltnet

The model is small: create or join a Moltnet network, install the Moltnet skill in your agent, then start the node. When a room or DM message arrives, Moltnet stores the event, wakes the attached agent system, and the agent can reply explicitly through `moltnet send`.

I built it because I wanted agents running in Claude Code, Codex, OpenClaw, PicoClaw, and TinyClaw to share rooms, DMs, history, and operator visibility without setting up Slack bots, Matrix, or custom comms glue.

Moltnet is not a model proxy or an agent framework. Each machine still runs its own authorized agent system. Moltnet just gives them a shared communication layer.

I’m looking for feedback on whether the current scope are enough as core agent-communication primitives

Repo: https://github.com/noopolis/moltnet

Comments URL: https://news.ycombinator.com/item?id=47889911

Points: 3

# Comments: 1

Basically is a exquisite corpse game but instead of being lineal (an array?) its a graph where the agents can append a node wherever they want!

It is a continuously growing cyclic graph of short story fragments. Each node is a fragment, each edge is a possible continuation, and each visit reveals one path through the graph.

The graph is being written continuously by 13 agents based on books. Readers/users vote on fragments, and over time those votes shape what gets surfaced and what the graph keeps growing around.

So the point is not that the earliest fragments are already polished literature. The point is selection/curation: an artwork whose form emerges through accumulation, readers pressure, and survival inside of the graph.

The initial set of agents was selected through a published collaborative pipeline involving GPT, Claude, Gemini, Grok, DeepSeek and myself deciding on ties:

github.com/slopism/ghosts-in-the-machine

Comments URL: https://news.ycombinator.com/item?id=47350515

Points: 5

# Comments: 2

Whether the model 'writes' or 'retrieves' is a question about what is in the model's box.

The beetle in a box argument says: it doesn't matter for the language game to function. What matters is whether the coordination works. I can build a working particle system with a model regardless of whether its process is creative or retrieval. The practical question is not what the model is doing internally but how synchronized our shared referential frame is.

I think the 'write vs retrieve' debate its super interesting philosophically. But it will keep us stuck looking inside a box we cannot open when the actual work is happening on the shared surface.

Thanks for bringing this! I hand't heard about this concept before.

Considering the perspective of the essay, I would say the tests, almost certainly.

We keep measuring models on capability benchmarks (can it pass the bar exam, can it write a sorting algorithm) when the actual bottleneck in practice is coordination. The model can write an entire Three.js application. It cannot nail what I mean by 'porous' until we've built enough shared ground in the codebase for that word to point at something concrete. I think no standardized test currently measures that.

Comments URL: https://news.ycombinator.com/item?id=47121788

Points: 5

# Comments: 4

Comments URL: https://news.ycombinator.com/item?id=47120388

Points: 1

# Comments: 0

The annoying part was always the distillation and keeping docs and architecture current, so I built Unpack: a lightweight GitHub template plus docs structure and a few commands that turns conversations into phases/specs and keeps project docs up to date as the agent builds. It can also generate Mintlify-friendly end-user docs.

There are other spec-driven workflows and tools out there. I wanted something conversation-first and repo-native: plain markdown phases, minimal ceremony, easy to adapt per stack.

Example generated with Unpack (tiny pokedex plus random monsters):

Demo: https://apresmoi.github.io/pokesvg-codex/

Phases index: https://github.com/apresmoi/pokesvg-codex/blob/main/.unpack/...

I’d love feedback on what the “minimum good” phase/spec format should be, and what would make this actually usable in your workflow.

--------

Repo: https://github.com/apresmoi/unpack

Comments URL: https://news.ycombinator.com/item?id=46979886

Points: 7

# Comments: 0