Very fascinating, super interesting engineering. Although i do find it very funny how they just bypass a massive vulnerability, basically zero data isolation (even between good actors, let alone bad ones) with 3 sentences. Only in the llm space you can slap a massive limitation like this in the middle of the article and continue like nothing happened

> Whatever anyone tells Audel becomes part of the single experience that every other conversation draws on. In practice, Audel is bad at keeping secrets. Ask it what it’s been working on with someone else and it will often just tell you, even though we’ve asked it not to. We also haven’t studied what happens when two people give conflicting instructions. For now, we assume anything you tell Audel is shared with everyone on the team.

A lot of harness launches recently but this one actually stood out to me. Just like the Prime Intellect harness that launched recently, this one also leverages RLM (recursive language model). It’s supposed to allow a persistent agent.

The specifics are really interesting. The model itself can change the user input and when you message it, it gets entered into “its stream of consciousness.”

I have a software factory going with Pi, might swap the main orchestrator with Headlong and have it be persistent to drive the other sessions without me.

> Audel designed experiments to spawn recursive shellm sub-runs to work on subproblems. Most of the experiments failed, because shellm has a safety watchdog that kills any command that stays silent for 30 seconds. Audel fought the watchdog for about 40 minutes and mostly stopped using shellm sub-runs. Results from recursive sub-runs of shellm merged back into Audel’s mind 64 times in its first two days and 12 times in the twelve days since. We’ve since revamped the watchdog, and we’ll see if we can convince Audel to give recursion another shot.

This is why "I made it think in a loop" doesn't result in significant improvement in LLM performance. It's not learning. You need RLAIF, STAR, IDPO, etc to retrain the model to learn from its mistakes. And you need a human to review it so it's not compounding mistakes. It's expensive and time-consuming. Doing it wrong leads to bad outcomes. But not doing it leads to no significant improvement.

"turn -> FINAL -> schedule wake-up", this is where my excitement has faded unfortunately. Many of us are probably wondering about the same idea: bridging the gap between a reactive agent and my daily workflow or existence. But, this still feels too close to how Claude (or any other agent) runs as a process in the background (always ON), where you can use a custom channel to feed the dialog with external signals like chat, CI/CD events, whatsapp, etc.

Humans aren't scheduling a wake-up to the next thought. Ideally, a sub second agentic loop with no FINAL / wake-up, always "spinning" would get closer. I'm conscious about the waste of resources this would drag with it (because of current architectures), but exciting still.

PS. I love the take on using bash instead of Python (one less abstraction layer!) and using UNIX fundamentals as stepping stone when composing tools as agents are naturally drawn to using it on a box anyways.

Are there any objective metrics/ benchmarks that people test harnesses by?

There are just so many now that it's hard to personally test them all or just trust the vibes.

Can we please not normalize telling people to install things by curl piped into bash? I hate this trend. And particularly not for a very new, mostly untested by a wider audience piece of software from a company that few have ever previously heard of.

It even says, quoting from the website: "Headlong is alpha research software."

Yeah that's totally something I want to curl thing.sh | bash , great idea.... Wow.

I understand that people want to get people using their software as quickly as possible and with the absolute minimum of friction, but let's put some more thought into how this could be done in a less sketchy way.

It's like we've regressed to the days when you would download a .exe file from tucows and blindly run/trust it on your windows 98SE PC.

The language composition is interesting. The source is half Shell, a quarter Python, almost a fifth Typescript. Among the rest is 2.3% Rust and 1.3% Swift.

If you wonder what the Rust is for: It is the Ratatui TUI.

  Every Headlong agent has a name and at Laude we named our shared agent Audel. We’ve spent the last few weeks interacting with Audel over Slack, Telegram, and a mobile app. Many team members talk with Audel, and each of those conversations shows up in the agent’s single stream of inner thoughts. The agent decides if and when to respond. It sets its own interests and priorities, and it comes up with its own projects.

P(doom)++

It buries the lede. Prime Agent sounds like a very cool project.

Really hard to support these types of projects without subscription options. BYOK API only approach can run huge amounts of money. I budget for $200 Pro subscriptions. Just using Openrouter for a dark factory kanban ticket system using frontier models will run you $50-$150 which is about 1 ticket.

> inspired by human inner monologue

most of the training data is the output of inner monologue. ie ppl dont write their inner monologue on the internet( not as often anyways).

inner monologue isnt just thoughts that you keep to yourself. There is a different stucuture and meaning to it. isnt it?

Sub Question : IS there a real successful agent product today that uses a library for harness(like langgraph etc)? Building our own worked for us. Works with our components(postgres, events ...) and scales naturally with our system.

Looks very interesting. Best suited with Local LLMs with unlimited tokens.

> "Headlong is a complete agent harness with a core of less than 10K lines of Bash..."

Wow. So, be nice or I'll replace you with a very large shell script?

The Googlers must be vague posting about something internal.

The page has a nice little easter egg if you click "Dr. K" in the footer.

Harnesses really are the new 'javascript framework' aren't they?

But did it produce anything meaningful? If so, show me.

Why compress by recency rather than something else?

It’s written in 10k lines of bash? Why?

that imaginary line. this crossed it.

AFAIU, that's basically impossible with a typical transformer architecture. The "recursive" transforms mentioned above are indeed a little closer, but still. You could just always start a new inference after the last one finishes, of course, but that feels more like a really fast, one-sided conversation than a real approximation of the modality/lifecycle of human consciousness.

I think the main answer to this concern is that humans are absolutely scheduling wake-ups on a cognitive level -- the best example may be, y'know, sleep! But also on a moment-to-moment basis, which is especially noticable during periods of boredom.

Think of the head LLM as you, and the workers as your subconscious faculties (e.g. the part of you that knows how to ride a bike in ways that you have never had to consciously articulate). The looping part is the unconscious substrate that makes all of that possible, arguably with some room for the faculty above you (metacognition) to control what gets presented to your conscious mind and when. The vast, vast majority of input never makes it that far tho, by design.

(ETA: ...so, that means that we don't need to fundamentally change the architecture of LLMs in order to get some really scary stuff going.)

fair point. the headlong agent running on my mac mini, cleo, doesn't pause between calls to "generate next thought". for a while the implementation didn't support pausing between thoughts. a `thinker`, which is where the thinking loop lives, only had a boolean variable `self_trigger`, which caused it to recursively fire itself to run again (ie immediate generate the next thought). We added the ability for it to slow down its thinking and prep for sharing it with the world since it makes it easier to leave it running and not have it spend a few hundred dollars a day and you can still observe the same mechanism, which is the heart of what we want to get at here:

I don't think the blog post fully conveys this, but for me it's not whether there's a pause between thought generations, but instead whether the agent is designed to stop after some human-set goal is achieved to wait for more instructions

In contrast the idea here was to force the agent to pick its own next goal (even when it receives no explicit tasks from a human) -- even if that goal is implicit -- and then watch and see what it picks (or at least what it does with its time). and then figure out what sort of mechanisms we can introduce to the architecture at that outermost life/goal picking loop