Hi everyone. I’ve been evaluating BabyAGI for potential automation of some internal IT procurement workflows, specifically for tracking vendor evaluations and contract renewal dates. I’m running into a consistent problem that’s blocking my proof of concept, and I’m hoping the community can help me understand the root cause and possible solutions.
I’m testing with a moderately large initial task list—around 50 to 70 tasks generated from a high-level goal. The system starts well, but after processing 15-20 tasks, it invariably becomes unstable. I’ve observed two primary failure modes:
* The execution loop seems to hang indefinitely, with no new tasks being completed or added to the queue.
* It crashes with various API errors (often around context length) or memory-related issues, even though I’m using the same OpenAI model that works fine for smaller lists.
My setup is fairly standard—I’m using the original BabyAGI script with the OpenAI API. I haven’t modified the core logic, but I have adjusted the `OBJECTIVE` and `INITIAL_TASK`. My goal is to understand this from a total cost of ownership and operational stability perspective before I even think about a rollout.
Could someone with more experience help me break down the likely bottlenecks? My specific questions are:
* **Architectural Limits:** Is the issue primarily with how the task list is managed in memory? Does the iterative process of creating, prioritizing, and executing tasks have a scaling flaw where the context gets bloated with previous results?
* **Configuration Levers:** What are the key parameters to adjust for larger workloads? I’ve played with `max_iterations`, but that feels like a cap, not a fix. Should I be:
* Aggressively pruning the task list or results stored in context?
* Changing the frequency of the prioritization step?
* Implementing a different data persistence method outside of the immediate context?
* **Practical Workarounds:** For those running BabyAGI on longer workflows, did you have to fork and significantly modify the code, or are there established patterns (like chunking the initial objective into smaller, separate runs) that provide stability?
* **Resource Specs:** Could this be a simple issue of my local environment? What are typical hardware or runtime (e.g., Python, memory limits) specifications for running larger task lists reliably?
I’m particularly interested in how this affects **implementation timelines**—if stabilizing for scale requires deep custom development, that changes my vendor evaluation criteria significantly. Any insights, links to relevant forks, or lessons learned from your own stress-testing would be immensely helpful.