John Ousterhout wrote in his book A Philosophy of Software Design that the cause of software complexity are dependencies and obscurity. I believe this is exact what current practices of micro agent design is doing. We are designing lots of agents each with special roles and make them talk to each other. In the end, we created a dependency hell and nobody understand what the agents are trying to accomplish. In order to solve these problems and reduce complexity, I’m proposing a deep-task agent design.
Current Micro-Agent Design
The current practice of micro-agent design, often referred to as “Multi-Agent Systems” or “Swarms”, mirrors a human “org chart” by decomposing complex goals into a network of highly specialized, interdependent roles such as “The Researcher”, “The Coder” and “The Manager”. These agents function like microservices in a software architecture, relying on constant inter-agent communication and frequent handoffs to pass context and feedback back and forth. The design is very “chatty” and typically employs a centralized orchestrator to coordinate these shalow, atomic sub-tasks.
Why it’s wrong to mirror human “org chart”
- Human spent 10 years or more to master one skill, such as programming, UX design or management. So we are all specialized and has to divide work according to our specialized skills. AI has no such problems, it has complete knowledge and skills. AI can be master programmer in one step, and become UX designer in the next step.
- Human can slow down due to context switching, that’s why each assembly worker only do one task, and do it efficiently. Machine has no such problems.
Problems with Micro-Agent Design
- It’s designed after “human limitation” by mirroring “org chart” without considering advantages of AI and machine.
- It creates complexity by introducing lots of unnecessary dependencies.
- You can’t understand what it does, unless you print out a diagram, even that might not help.
Introducing Deep-Task Sovereign AI Agent Design
- Sovereign: Each Agent owns an independent task from start to finish. By indepdent, the agent doesn’t rely on any other agents to complete its task.
- Deep-Task: The task can be very deep. It might contains hundreds of steps. It might talk to different AI models based on their capabilities. The task might take minutes, hours, days or weeks.
- Maintain Progress: Agent saves its progress along the way, and can pick it up anytime. So it can run for days, and it’s fault tolerant. If the agent crash, it will just restart and pick up where it left off.
- Manage Context Length: Agent uses context manager to keep its context within the window.
- Clear Logic: Since each agent finish one complete task from start to finish, it’s very clear to see its goal. This reduces obscurity, and improve readability of its logic and design.
- Parallel Since each agent is independent from each other. They can run concurrently in massive numbers.