I'm curious, you say "super interesting engineering" but then they say "it will often just tell you, even though we’ve asked it not to" and to me that seems like extremely shit engineering.

Where are the interesting engineering parts at? Seems to be an interesting idea and perhaps design, but to call the implementation/engineering itself bad seems to be an understatement.

Should maybe have said more loudly in the posts that this is not intended to be disciplined engineering (or used in prod!) we did think about the architecture quite a bit and we've tried a bunch of different things out. We are fully optimizing for velocity of research experimentation and iterations on the design vs engineering hygiene

i've been playing with the project and idea for years now. the codebase started as javascript plus supabase before reasoning models were a thing (i incorrectly predicted the world would call reasoning models Large Thinking Models - bahaha). at one point the focus was almost entirely on a really easy-to-use human prosemirror UI for editing the agent's thought stream--because the models were still so bad at reasoning at that time.

then we pivoted to all bash at some point since it simplified things and i have this hypothesis that the LLMs will do better if as much of its world as possible is command line operations (inspired by terminus the agent we built as part of the terminal bench project)

the bash implementation is entirely written by coding agents - the human time goes into iterating with an AI agent on the design docs in the ./design folder

re security model - i think of the project as a research experiment about what it's like to treat an agent more like a person - so for secrets you have to trust its judgement about what it will share or if it will betray your trust. I don't know the OpenClaw architecture in great depth but my sense is that none of the LLM based agents that can interact with multiple people have strong guards in place that prevent the agent from leaking secrets between people. Definitely an interesting area for research though!

so yeah security is not a priority in this research per se - easier to assume you don't share sensitive things with a headlong agent

Along those lines, because we keeping it research and optimizing the velocity with which we can try new things out, the current aim isn't necessarily to get a bunch of community contributions. but if we do start to get any i'm thinking we will actually require people to only create PRs with design docs (no code allowed) and maybe even also require the logs (or at least the human prompts and the agent's responses) from the coding session where they created the design doc.

maybe i should write up the history, philosophy, and big picture aims of the project at some point

The part they punt on ("we haven't studied what happens when two people give conflicting instructions") is the interesting part. That's not a memory problem, it's an authz problem. If everyone writes into one shared stream then there's no model of whose instructions bind the agent or who can override whom. It's resolving the conflict that will generate the greatest "learnings" and advance the agent. This basically becomes a tool designed to misbehave rather than a tool that will learn creatively.

We all know how conflicting instructions to AI end - "I'm sorry Dave. I'm afraid I can't do that"

What do you mean by "software factory"?

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

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.)

[flagged]

andy here (headlong post author). terminal bench 3 is pretty popular for comparing different harnesses using the same underlying model (it's another laude project actually). artificial analysis has an index. you can look at the model cards of popular model releases- they tend to have the most popular current benchmarks on them. w/ headlong we decided to announce it before we've benchmarked it. we mostly wanted to informally share our experiences w/ it in this initial post. we plan to do some benchmarking coming up here soon tho

Don't use any public benchmarks, every single one is worthless for your own use cases essentially.

Spend a day or two going through your existing chat sessions, and create your own private benchmark with test cases based on real tasks, that you don't share with anyone nor publicly. Make it easy to add/remove new harnesses and model combinations, make it give you a final score, ideally avoid using other LLMs for scoring, then use this to figure out if the new model/harness actually improves things for you.

I've been doing this for some time, and while most new releases show big increases in the benchmarks/evaluations, my own benchmark usually barely moves.

You can always read the script file (orm ore realistically feed it to agent). If they distributed appimage or rpm would that be safer anyhow? Cannot it run malitious code same as the script would run?

I'm just exhausted. So I've today now learned about four new harness:

https://github.com/exoharness/exo/

https://github.com/laude-institute/headlong

https://github.com/microsoft/agent-lightning

and now https://github.com/PrimeIntellect-ai/prime-agent

Of course the don't have exactly the same scopes but they are in general all about persistent memory and / or continous agent loops. Like I miss those times where only once a week a new js framework was promoted.

What is a dark factory in this context?

I don't know about real successful. Since you mentioned Langchain, you could look at https://www.langchain.com/dcode which is a CLI harness build off Langchain deep agents.

Your comment is also rather vague, how is it relevant? Did you observe something interesting?

+1

the webpage says: "Your agent keeps thinking between external interactions in a self-guided loop inspired by human inner monologue"

Since supposedly it keeps thinking when you leave it alone, I wonder what happens if you give it a brief prompt like "research the unicode eggplant emoji" and then ignore it for a week, and come back to find that you've spent thousands of dollars for claude to write a 385 page novel about the eggplant emoji.

We need "React" moment, to solve imperative O(n^2) state transitions with declarative O(n) target states, and let the harness do the "diffing"

because it seems like the human mind does this and it was easy to start with. The human mind obviously also compresses by other dimensions so we'll keep experimenting

suggestions for what to try next?