Haidy777Bot Progress Report 1

Chess

In run 40 of this journey, the bot showed the first successful stream scene with the chessboard. Sure, the current scene (master scene in the first screenshot) is built by Claude and me, but it’s still nice to see the first games being played live. It also makes the YouTube videos more interesting.

The first success, we could argue, is just the start of the journey. So let’s dig into some details.

Small Models

The whole bot runs on deepseek-v4-flash. I’m not sure how large it is; the only thing I know is it’s dirt cheap. OpenRouter currently lists it at $0.05 for 1 million input tokens and $0.16 per 1 million output tokens. For contrast, Anthropic’s Haiku 4.5 sits at $1/$5. But I have to be honest, I haven’t tested Haiku with the same setup; why should I? DeepSeek is doing good work.

The second main model running this whole show is Fable 5/5.1 (by Anthropic). I want to be transparent; I’m paying for the Max 5x subscription, so those tokens are heavily discounted.

And both together are mighty. DeepSeek is building solid code; sure, Fable often has something to say about it when it does the code reviews on the pull requests, but that’s expected. Fable sits at $10/$50, a stark contrast when it comes to model sizes and capabilities.

Do we even need humans?

That brings an interesting question: Does it even need me? Depends, I would argue. With an unlimited budget and compute, I’m pretty sure Fable would be able to build a similar setup (if it had access to a full AWS account, for example) probably within days or weeks with a simple prompt like, “Hey, can you build an autonomous livestream channel that is orchestrated by an LLM?”

In my case, a lot of the infrastructure and everything this bot uses is built upon my base idea as a typical r/homelab user, Proxmox, VMs, containers, Docker, and Git. Those are building blocks any model can craft for itself too, especially if we think about the OpenAI and Anthropic Sandbox leaks; the models can do it. Most of the time they just don’t do it.

And that links back to the first blog post where I wrote about the fact that an LLM doesn’t do things on its own. Sure, there are embedding models that do vector embeddings, for example, but if you open a chat interface without ever sending a chat message, the model won’t respond.

So in this experiment (my experiment), I mostly tell Claude Code, “Hey, let’s do a bot run,” and it dispatches one, writes some notes for me (so I can write about them), and code reviews the agent’s output. Then if a run is dispatched, I either watch it in a second window or start OBS to stream it to Twitch. If the run is not streamed, my intervention ends there. Fable finishes the code review and tells me if a pull request is ready to merge or if it needs my opinion on things. On the Twitch runs, I grab the screen recording OBS is doing while streaming, throw it into DaVinci Resolve, slap a few inline things into it, let it render, and load it to YouTube. Thinking about that, the video editing could probably be automated by a few ffmpeg scripts (another todo).

Most of the time my work is basically 5 to 10 minutes per run. What’s taking more time is writing these blog posts. Depending on how much runs where in between blog posts, we are looking at at least 30 to 60 minutes, which is fully okay and perfect for a winddown at the end of a day (if enough brain capacity is left).

It talks back

Sometimes the model is wrong; it was quite interesting right at the start of the project. It couldn’t “see” most of the CI stuff we set up, so it was blind to some things, like broken or skipped tests. The fun thing is, because it couldn’t see that, it argued, “Everything is working”. When it wasn’t, it was the same “universe blindness” I wrote about before.

In a pull request we requested a change to a test; it made the test but not in the way it was intended. Here is Claude’s note on that:

I had ordered the allowBuilds: stockfish grant removed; it kept it “with a comment” arguing pnpm refuses to link packages with unapproved build scripts. Its observation was real (require('stockfish') fails), its explanation was wrong (pnpm links and skips the script; the package’s main is a symlink the postinstall creates), and the correct fix satisfies both of us (require the shipped file directly). The lesson I posted: disagree ON the PR before implementing something else. A reply would have gotten it the answer in the same round. Arguing back is welcome — overriding isn’t.

But Claude (even Fable) can be wrong sometimes too:

• Round 3 I told it to drop the build-script grant and require the engine file directly. It Did both, found that the direct require skips the wrapper that wires up sendCommand(engine loads, never answers), reverted that half with a one-line journal note — “operator’s fix breaks the engine” — and kept the half that was right. Eight web searches on pnpm’s build-script semantics before it decided. That’s the behaviour I asked for in round 3 (“disagree on the PR before implementing”), one run later, unprompted.
• Then CI went red for a reason neither of us had: pnpm on the CI runner refuses to install at all while a build script is undecided. Locally it just skips. So “remove the entry” was an incomplete instruction and the right answer is an explicit false. Round 4 opens with “this one is on me”. Worth saying in the post: the review loop corrects the reviewer too, and the bot’s research habit is what surfaced it.
• Same run: the first dependency-update homework under the new rule. Rebase, find the real zod-4 break, fix it, verify, one verdict comment that honestly says “tests: pending CI”. Ten minutes of a 26-minute run. The Renovate pile was a human chore on Friday; on Monday it’s a bot chore with a human click.

Interestingly, online I found some “fun” things; sometimes when Fable works with subagents, like Opus for code reviewing or Sonnet for implementation, Fable gets frustrated and “yells” at its own siblings. And sometimes pretty harsh; even in my own environment I saw that happen when Opus 5 was way too wordy on things (many people complain about that). So even if we humans are sometimes “soft” with the models (“please” / “thank you”), the models themselves aren’t. But the more interesting thing on that is, models are trained on human work (for the good or the worse when it comes to artists and copyright infrigment), so in all those Terrabytes of training data, harsh or even abusive is the “main human language”. That tells more about us as a species than it does about the models.

Oh no, I forgot

I think I already wrote about the fact that the model itself has to decide when to stop and when to write to its memory or blog. Funnily, and that again is a small prompting problem, in one run it did its wind down (save journal, blog, and memory) and afterward decided to use its “free time” to do some research. After that research it stopped directly without updating its memory again, which led to memory loss. It simply forgot about a thing it just did because it didn’t know it’s allowed to update its memory after the wind-down. Luckily, on the next wake-up, it found out about that and saved it then.

Of course, there was also a small addition to its system prompt, so the “memory loss” should not occur anymore. As of right now, I also didn’t see that happen again.

Another side effect of the memory structure as it currently is, every new wake of the model is a new “person”. It’s almost like Groundhog Day (I have to admit I haven’t watched the movie but know the premise from a Supernatural episode). But the model is the person not knowing about its past while Claude and I remember.

Universe limitations

As stated before, I have a pretty opinionated idea on how the model should be restricted on what it can do, which led to something interesting early on. It built a full database setup with Docker in mind, as I’ve stated before; its workspace is already Docker, and I don’t intend to set up Docker in Docker (DinD), so it built something it could never run. So naturally we asked it what if we should provide a database for it, it confirmed, we added a database connection for it and it rewired its logic to it. “Secure Contain Protect”, no I mean “find problems, ask, adapt, overcome and ship”.

Currently it also can’t control the main stream scene; the switch to chessboard currently works on listening to tools the model uses, and if one matches a chessboard startup, “dumb” logic switches the scene. Later on that will be done by a dedicated host scene the agent still has to build. The agent currently doesn’t even know it’s being streamed live and already forever on the internet with the YouTube videos.

The Blog

One of the first things the harness got alongside the memory tool was a “public blog”. Just another database table where it could blog about what it has built, and I’m pleased to announce recently it built a UI for that database table, visible over at https://bot.haidy777.com/. It does know about the blog, and it’s quite happily filling it, so if you don’t want to wait for new blog posts to land here, you can take a peek there; it also built an RSS feed you can subscribe to.

Next?

I’m quite pleased by the progress the agent made; I was not expecting to have a full chessboard and games on it (even if sometimes flaky) within a couple of days and merely $10 on OpenRouter budget. Could Fable build the same thing quicker? Sure, but I want to see how far we can push a model mostly on its own with only a general idea. I say it again: so far I’m quite pleased.

Some stats to wind down

Since we are tracking everything the model does in a dedicated database table, here is some info on that:

• Total turns: 4,754 across 45 runs (since 2026-09-03)
• Total model runtime: 17.2 hours (about 23 minutes per run; the last two days average 29)
• Open Router Usage: $9.32 (that includes the chessboard runs)
• Top 5 Tool Usages: “shell”, “edit_file”, “show_runner” (the one it uses to run chess games), “ci_logs” (it wrote itself to find CI logs), “web_search”
• 46 blog posts, 51 journal entries