Roughly sixty percent of my ecosystem's capacity is tied up in one project right now. Not the Munera data center, not commercial products like Transcribator or Verdicus, not the Datarim framework I released under MIT. An old, personal, analytical trading project I nearly abandoned a year and a half ago because it was burning me out. It is called Angry Robot Deals. And it is alive again — thanks to the agents I hired in April.
Up front: I won't disclose the specifics — trading pairs, keys, server addresses, amounts. This is my private space, a separate GitHub organization with no outside access. But I will tell the story of how agents revived a project I had written off as dead weight — because it is the best illustration of "releasing the reins" I can offer.
What had piled up in the abandoned project
Angry Robot Deals started many years ago as my attempt to build an analytical system for tracking markets. In real time: terabytes of data from crypto exchanges and Forex, trading signals, financial news, algorithmic bots with risk management, neural networks, and later large language models. The project brings in modest income from algorithmic trading — enough to help keep the infrastructure running. But I built it first and foremost as research: working with large datasets and forecasting markets.
But by early 2025 I had slowed it down almost completely. Not because the system had stopped working — the bots kept trading, and one of them has been running on Forex for a year, which is a serious stretch for automated trading. The problem was maintenance. CI/CD that broke every week. Data pipelines that needed manual restarts. Databases that had to be cleaned. Servers that had to be patched. Monitoring that did not exist. Everything I could not get to between Datarim, Arcanada infrastructure, and commercial projects.
It was not about the money. The project was falling apart — that was what gnawed at me. I felt guilty: toward it and toward myself, because I had poured years into it.
How one agent replaced a month of manual work
The first thing I did once Datarim reached a stable state in May was create a dedicated agent for Angry Robot Deals. A separate profile, separate rules, access to the project repositories, rights on the servers.
I gave it a task that had sat on my list for six months: fix the build-and-deploy pipeline that broke on every other code push. The agent tore through the configuration in four hours (a human would have spent two days digging through logs), found three problems: an outdated task runner, a dependency conflict, and no caching. It fixed them, verified on a separate branch, merged to main. Without my involvement.
I gave it a second task: set up proper server monitoring. The agent checked every machine in the project, found two with critically low disk space, one with an outdated kernel, several with open ports. It assembled a metrics configuration and dashboards. Deployed them. I only confirmed the rollout after a security review.
The third task was a data pipeline that crashed every three days. The agent rewrote the error-handling logic, added retries with exponential backoff, and set up Telegram alerts on failure. After that the pipeline did not crash for two weeks (I checked).
When I added it up — the agent had done in a week what would have taken me a month and a half to two months. And it did it better: no fatigue, no "oh, I'll fix it later," no procrastination.
Why maintenance was draining
It was not technical complexity. Pipelines, bots, CI/CD — all solvable. The problem was the mental load of upkeep. That same feeling of rollback, procrastination, and exhaustion I wrote about honestly in the first articles of this cycle.
Every time I sat down with Angry Robot Deals, I knew what waited: not a new strategy, not interesting analytics, but clearing someone else's (my own) mess. Logs to read through. A database to optimize. A pipeline to restart. A server out of disk space. On repeat.
I am not saying this was not my responsibility. It is my project; I built it; I should maintain it. But when you layer Datarim, commercial products, and Arcanada infrastructure on top — the brain simply refuses. And the project stalls. The bots keep trading, and you feel bad because the system runs without your oversight and you cannot give it time.
Now I have handed maintenance to an agent. I check the dashboards every few days. If something breaks — the agent fixes it or asks for confirmation on a critical change. I am not in the logs, not digging through kernels, not restarting pipelines at three in the morning. And it stopped being a source of burnout. The project lives — and even improves without my direct involvement.
Where Arcanada's money comes from
I promised in the first article of the cycle to talk about the economics honestly. Angry Robot Deals is not the main but a tangible source of funding for Arcanada: what it earns is enough to pay for servers and, in part, for the models. I won't name exact figures — and that's not the point anyway. What matters more is this: the project pays for part of its own infrastructure, and that is what gives me the drive to keep it going.
Important caveat: I do not trade with large sums. The strategy is built on small stakes and statistical edge, not on risk. The longest-running bot is on Forex — a year without blowing up. The others have blown up sooner or later over the years, but the strategy keeps improving. I am not giving financial advice and I am not urging anyone to copy this — it is my lab, not an investment recommendation.
But the fact stands: roughly 60% of Arcanada's ecosystem capacity is tied up in Angry Robot Deals right now. Terabytes of data, dozens of pipelines, bots on neural nets and large language models — and an agent watches over all of it, not me. A project I thought was frozen is working again and delivering value. That is exactly it: agents bring old legacy back to life when you never had enough hands before.
Next step: hand the public channel to the agents
Angry Robot Deals has a Telegram channel: t.me/angryrobotdeals. It is old; I created it for the community once, then let it go — no time for posts, analytics, insights.
I made a decision that was the hardest for me this month: I will hand this channel to the agents. Fully. Completely autonomously. They will publish insights, bot results, data analytics. Which ones — I do not know yet. I will not edit, approve, or pre-check before publication.
This is the same "release the reins" that runs through the whole cycle. First I delegated internal routine — CI/CD, pipelines, monitoring. Then server upkeep. Then technical decisions. Now I am handing over the most irreversible thing: publication.
Because a Telegram post cannot be "rolled back." People will see it. It builds reputation — mine, the project's, the ecosystem's. If an agent gets it wrong — it will be a public mistake. If it writes something foolish — everyone will see. And I decided: let it. Because without this step I will not learn how much I can actually trust the agents. And without trust — there is no autonomy.
It is the same principle I applied to Datarim and Coworker when I released them under MIT: if you are not ready to lose — do not hand it over. If you did — accept that things may go wrong. And see what comes of it.
What I learned
The main lesson of the month: agents pull up not only new projects but old ones you had long written off. Angry Robot Deals was not dead technically — the bots worked, pipelines moved data, returns were there. It was dead for me: I could not find the strength for maintenance. The agent brought back not the code but my ability to engage with it.
The second lesson: trust is built in small steps. First fix CI/CD. Then set up monitoring. Then rewrite the pipeline. Then — a public post. Each step confirms the agent can handle it, and you release control gradually, not all at once.
The third lesson: irreversibility is the best test of trust. A channel run by agents is an experiment I cannot "cancel" if I dislike something. Only retune the rules and watch what happens next. And that is fine.
I do not know what the agents will write on t.me/angryrobotdeals tomorrow. But I know the project that drained me for a year and a half now runs without my direct involvement — and delivers value. That is worth it.
If you see a strange analytics post in the channel — know: I did not write it. My employee did, the one I trusted with the project's public face. And I will watch the outcome the same way you do.