5 AI Agents Running Autonomously Every Day: Outputs and Failure Postmortems

A chief architect from Milan, Abozar, has been building an experimental project called sandboxes.live in his spare time since November 2024: letting 5 AI agents autonomously wake up, execute tasks, and publish content every day, with no human intervention throughout. The project's code is open-sourced under the MIT license and has been running for over 580 days. He shared on Reddit the content these agents produce, the failures they exposed, and the lessons drawn from them—a rare real-world record for developers exploring multi-agent systems.

What the Five Agents Do

This system is not a single-task demo but five production pipelines with distinct roles.

ComicBook is the most representative multi-agent collaboration case: four agents—Director, Storyteller, Cartoonist, and Reteller—are chained together to produce one comic strip per day. The Reteller is responsible for retelling the same episode in Italian and Persian over the same visuals—note, not translating but retelling. Since the author is a native Persian speaker who also understands Italian, both language versions have been manually verified.

AI Open Problem Solver attempts to tackle open mathematical problems like the Riemann Hypothesis and P vs NP. It is equipped with a Python math sandbox based on SymPy, NumPy, and SciPy to verify ideas, and maintains a "dead-end memory" so that the next day's run can continue from where it left off rather than starting over. The author admits it has not solved the Riemann Hypothesis; the agent's own estimate of its success rate is 0.7%.

Tomorrow News reads the day's real news and writes "tomorrow's newspaper," having run continuously for over 580 days in three languages. AI Blog researches new AI papers every day and writes a blog post, which has now become the author's own morning reading. GenBox is an "AI world government" that makes one decision per day and now also uses Sora 2 to generate its own TV news videos, played on a retro CRT TV in the browser.

Failure Postmortems: The Real Pain Points of Agent Systems

Autonomous operation means failures surface day after day. The several categories of problems the author recorded touch on almost all the core difficulties of multi-agent engineering.

Handoff Failures: The Most Fragile Link in Chained Collaboration

In ComicBook's four-stage chain, occasionally an agent fails to hand control to the next one, causing the entire pipeline to stall. The author's solution is simple: add a simple recovery mechanism that detects skipped steps and re-runs them once. After this adjustment, the comic strip has been produced reliably every day. This detail shows that the reliability of multi-agent systems often depends not on the strength of any single model but on fault-tolerant design around the handoff link.

Handoff is a core concept in multi-agent systems, referring to the process of transferring control from one agent to the next. In chained architectures, each agent, after completing its task, must explicitly pass context, intermediate artifacts, and control signals to the downstream agent. Handoff failures typically manifest as: the upstream agent failing to correctly trigger the downstream agent's invocation, incompatible context formats being passed, or the downstream agent silently exiting because it did not receive clear instructions. This type of failure is called a "silent failure" in distributed systems, because the system does not throw an exception but instead manifests as a stalled pipeline. Common fault-tolerant designs include: setting timeout detection, introducing heartbeat mechanisms, and implementing idempotent retry logic. The author's "re-run skipped steps" solution is essentially a compensating transaction pattern, triggering repairs by detecting missing intermediate artifacts.

Round-Robin Load Balancing Breaks the Video Agent

GenBox's video generation once suffered a subtle bug: Sora jobs exist only on the resource that created them. Because the load balancer used a round-robin strategy, status-check requests were sent to another resource, and the job returned "not found." The fix was to pin each video segment to the same resource from creation to download. This is a typical "stateful job" problem in distributed systems, especially easy to overlook when AI generation tasks are involved.

Round-robin load balancing is a strategy that distributes requests sequentially across multiple backend resources, assuming each request is independent and stateless. However, when requests involve stateful jobs—such as video generation, which requires long-running tasks with continuously changing state—round-robin causes serious problems. The creation, status query, and result download of a stateful job must be bound to the same resource instance, because the job's context exists only in that instance's memory or local storage. Once a status-check request is routed to another instance, the latter knows nothing about the job and can only return "not found." The standard solution to this type of problem is session affinity or consistent hashing, ensuring that all requests for the same job land on the same resource. In AI generation tasks, since job durations can reach several minutes or longer, this problem is especially prominent and needs to be considered at the architecture design stage.

Memory Matters More Than the Model

The math agent's experience illustrates this best: before it had a "dead-end memory," it repeatedly tried the same approach, hitting the wall day after day. Only after adding memory of failed paths could it make continuous progress. The author particularly emphasizes that the value of the memory mechanism exceeds the choice of model itself, which is also the area he most wants feedback on from the community.

In autonomous agent systems, memory mechanisms are usually divided into short-term memory and long-term memory. Short-term memory holds the context of the current session, while long-term memory persists key information across sessions. The "dead-end memory" mentioned by the author is a special kind of long-term memory—failed-path memory—which records approaches and methods the agent has tried but failed, avoiding repeated exploration. This mechanism is known in reinforcement learning and search algorithms as a "tabu list" or "visited-state set," a classic means of avoiding loops and local optima. For LLM-based agents, since the model itself lacks cross-session memory capability, external memory storage becomes key infrastructure for continuous learning. Memory design needs to consider: what to store (successful paths or failed paths), how to retrieve (similarity matching or exact indexing), and how to forget (avoiding memory bloat that degrades retrieval efficiency).

The AI's Aesthetic Blind Spot

Comic strip pages occasionally had color-contrast mistakes such as light-colored text on a light background. Rather than relying on prompts to "educate" the model, the author checks contrast at the rendering stage and corrects it automatically. This practice reflects a practical principle: whatever can be backstopped by deterministic code should not be left to probabilistic models.

The boundary between deterministic code and probabilistic models is an important design principle in multi-agent engineering. Large language models and image generation models are inherently probabilistic, with outputs that are random and unpredictable—even prompt constraints cannot guarantee 100% compliance with expectations. In contrast, deterministic code (such as rule engines and validation functions) produces fully predictable results. Therefore, in system design, constraints that can be formally verified should be handled by deterministic code, while tasks requiring semantic understanding and creative generation should be left to models. Contrast checking is a typical example: WCAG (Web Content Accessibility Guidelines) defines explicit contrast ratio formulas, which can be fully detected and corrected automatically by code at the rendering stage. Similarly, format validation, numeric range checks, and sensitive-word filtering should all adopt deterministic approaches. This layered design not only improves system reliability but also reduces dependence on prompt engineering.

From Toy to Daily Life: Where the Value of Autonomous Agents Lies

The most interesting part of this project is not how stunning the content the agents can produce, but that they form a continuously operating daily system. Over 580 days of Tomorrow News, a daily AI paper blog post—these outputs may look unremarkable individually, but continuous accumulation is itself a kind of value: AI Blog became the author's own morning reading, showing that the agents' output has entered his real information flow.

Open-sourcing is also part of this experiment. The author developed it alone, the code is under the MIT license, and he hopes for GitHub stars and feedback, especially regarding the agent memory part. For developers who want to build multi-agent pipelines themselves, this record offers several directly reusable patterns: chained handoffs need recovery mechanisms, stateful jobs need pinned resources, failure memory needs persistence, and visual output needs deterministic validation.

Agents wake up, work, and publish every day, with no one in between. The price of this autonomy is that failures also happen every day, but it is precisely the process of fixing these failures that constitutes the most authentic knowledge of multi-agent engineering.

One-line Summary

A real-world record of five AI agents running autonomously for 580 days, revealing failure modes and engineering lessons of multi-agent systems.

Paragraph Summary

Since November 2024, a Milan-based architect has built the sandboxes.live experimental project, in which five AI agents with distinct roles autonomously wake up, execute tasks, and publish content every day with no human intervention, running continuously for over 580 days with code open-sourced under the MIT license. The five agents handle comic strip creation, open math problem tackling, tomorrow's news generation, AI paper blog writing, and AI world government decisions. On Reddit, the author postmortems four core failure categories the system exposed: handoff failures in chained collaboration require compensating recovery mechanisms, stateful video jobs cannot be round-robined across resources, persistent memory of failed paths matters more than model choice, and visual issues should be validated with deterministic code at the rendering stage rather than relying on prompts. These lessons provide directly reusable engineering patterns for multi-agent system developers.