There Is Probably No AGI With LLM
I think you've already heard of OpenClaw even if you don't want to. I struggle to find a usecase for it all this time, and to be honest, for those who do have legit cases where the introduction of an AI assistant would lighten the workload and increase the productivity, I find it hard to care about. My ultimate goal when it comes to LLM agents has always been two things:
- The agent must be able to acquire abilities that are not theirs on their own; this is called Self-Improving;
- The agent must also be able to write and orchestrate their own agents; this is called Higher-Order.
I've been experimenting with the self-improving side of things, which resulted in a failed coding agent called Tarha and a probably failed AI assistant prototype called OpenPixie. The development of the latter is what inspired this blog post. I'll explain it as follows.
To be able to self-improve, one must be able to assess its own situation and come up with things that it can improve on; I call this kind of thinking metathinking. When it comes to code and programs, an obvious way to implement whatever's needed to do after such thinking is self-modification and hot reload. I can always have a copy of its own source code ready, and Erlang is one of the languages that are easiest to do hot reload, and due to how Erlang works I can wire its crashes into triggers that makes the agent to fix its own crash as well. I struggle to find a better fit for my purpose (other than Elixir which also targets Erlang BEAM, but I doubt it'll make any meaningful difference); this is the reason why both Tarha and OpenPixie are Erlang projects. If you think about it, this is probably the closest structure to AGI using LLMs if there ever could be one. Like, what feature do you want? Just ask it, it can write the code for you. What, the feature is too complex you think you need a Plan Mode but it didn't have a Plan Mode? Just ask it for a Plan Mode, it'll be alright, the agent can figure things out itself. But as I've said in an earlier blog post, the first attempt of this failed miserably because the coding-agent-also-assistant always hallucinate non-existent interfaces, so I've basically given up on the idea.
The first (and probably the only) breakthrough comes weeks later when I was taking a shower. The idea was to have the following two things: (1) a set of detailed internal documentation that are consistent with the behaviour of the current code and would be updated accordingly whenever a self-improvement edit is applied; (2) a dedicated verification agent that checks the code change against the internal documentation; if the change is inconsistent and breaks the current interface, then the verification agent would reject it and demand the coding agent to try again; and if the change do be consistent, then it would be applied with the internal documentation being updated. After a few days of ruminating on this idea, I added it to OpenPixie and it somehow worked. I don't have a benchmark, but after this change the agent went from "always break the frontend" to "always never break the frontend". I thought I was onto something, so I quickly added a cronjob Skill and a few things required for an external cronjob to trigger the agent, and then asked the agent to schedule a cronjob that would trigger itself to do a self-improvement every hour. In the beginning there was a few hiccups but that's what you'd expect from LLM; after fixing a few bugs it was changing its own code and pushing the changes to GitHub somewhat smoothly.
It was looking all cool and good until I noticed that the changes are all very small changes (like changing how certain things are logged) and none of those changes are actually meaningful enough. I deliberately left out a few UX rough points in the frontend; none of it got fixed. Things that should be easy to spot and fix (like how the max tool call can be too low) also didn't get fixed. I originally hoped that it would be smart enough to add a TTS feature; that of course never happened. Even for the kind of small changes it has been doing, it occasionally didn't do it successfully either: sometimes it reports "there's no improvement to be made", sometimes it errors out, and a lot of times the self-improvement flow just stops midway. This is not what I wanted, so I started thinking how I should fix this.
If you really think about it, the fact that it wasn't until that thought-inspiring shower that I took that actually improved things that this whole idea had even just a slight chance of truly working is already saying something. If my agent cannot modify itself out of this mess, then it probably implies that lower-quality agents are not able to elevate themselves into higher-quality agents. If I cannot modify it out of this mess by telling Codex or Claude Code to fix it, then it probably implies that even higher-quality agents cannot elevate a lower-quality agent into a higher-quality agent. But of course, me who just saw how successful the introduction of the verification agent was just couldn't give up. I tried to ask Codex to add a "code graph" to the code base (because it was reading irrelevant files and the same irrelevant file multiple times wasting tool calls), I tried to ask Codex to add a "world model" so that it could (pretend to) know what will happen when the changes it proposed are applied before it applies them. None of it worked. In fact, I've never seen a fully-complete automated self-improvement being done after all the new changes. Maybe I was framing the problem incorrectly, since it would be at least a little bit confusing to a person if you simply ask him to "go and improve on yourself" and give no other instructions after all; but then again, I don't expect that same person to do the equivalent to whatever this agent I've made has been doing on my money.
Right now I'm thinking about calling it quit. It genuinely feels like there is a thick wall between this approach and "true" intelligence; I suppose I can think of new structures to regulate the model's behaviour, but I seriously doubt that's gonna bring about any meaningful qualitative change.
Last update: 2026.5.31