The Radial Agent Why We Need to Stop Buildin

Introduction: The Magic Trick Everyone’s Falling For

You may have inadvertently stumbled onto what I consider the greatest magic trick in enterprise AI right now: everyone’s frantically hammering the square peg of agent technology into the round hole of their beloved RPA workflow thinking, then looking utterly bewildered when it costs four times as much and performs like a hungover intern.

It’s like watching someone with an Aston Martin insist on driving it with L-plates and a top speed of 30mph because that’s how their Reliant Robin worked. We’re building overpriced workflows masquerading as AI agents; the equivalent of putting a bow tie on your cat and calling it Fred Astaire.

The fundamental problem? We’re still conceptualizing AI agents as machines rather than apprentices. We’re constraining them with linear processes when their power lies in adaptability and learning—abilities that require a radial approach to agent architecture.

As enterprise leaders rush headlong into the agent revolution, many are unknowingly setting themselves up for disappointment by misconstruing what makes these systems transformative. The benchmarks tell the story: OpenAI’s SWE Lancer test showed that even the most advanced LLMs complete less than 50% of real-world software engineering tasks. Yet simultaneously, vertical agents in specific domains are achieving 90%+ success rates.

The future belongs to those who embrace a radial approach to agent architecture—not just a technical shift, but a profound cognitive one that reimagines how intelligence operates within our systems.

The Fundamental Shift – From Linear to Radial

“We should not be using system design to channel the agent, we should let the agent channel the system design.”

This single statement represents the most profound shift in how we approach AI agent architecture. The conventional wisdom has been to design rigid workflows and force AI to operate within them. This approach treats AI agents like traditional software: strictly bounded, predictably linear, and fundamentally constrained.

The radial approach inverts this thinking entirely:

• Linear Model: AI agent → task workflow → predefined endpoints
• Radial Model: AI agent at center → spokes extending to tools, knowledge, and other agents

In the radial model, the agent sits at the hub of a wheel, with spokes extending outward to different resources: databases, APIs, knowledge bases, reasoning tools, and even other specialized agents. Rather than following a predetermined path, the agent determines which spokes to traverse based on the task at hand.

This isn’t merely semantic nitpicking—it represents a fundamental reconceptualization of AI system design:

The radial approach also mirrors how we organize our own cognitive processes. When faced with a new task, we don’t execute a rigid, predetermined sequence. Instead, we dynamically access different mental resources, external tools, and collaborators as needed.

As one enterprise architect recently told me, “Once I started thinking radially about agent design, I couldn’t unsee it. Our previous attempts suddenly looked like we were trying to teach calculus by having someone memorize specific equation solutions rather than teaching them mathematical reasoning.”

Are your AI implementations designed around workflows, or around capabilities? The difference will determine whether your agents are genuinely adaptive or merely expensive automations.

The Task Length Barrier: Why Horizontal Agents Hit a Wall

Perhaps no concept better explains the widespread disappointment with horizontal AI implementations than what I call the “task length barrier”—a phenomenon validated by the METR research that shows AI performance degrading exponentially as tasks grow in complexity and duration.

The data is striking: While leading models like Claude 3.5 Sonnet achieve impressive results on tasks requiring minutes of human effort, performance plummets for tasks requiring hours. In the SWE Lancer benchmark, even the best models completed only 40% of real-world software engineering tasks.

Why does this happen? The barrier emerges from three compounding limitations:

1. Context Window Constraints: As tasks grow longer, they generate more intermediate results and require more contextual information, eventually exceeding even the most generous context windows.
2. Attention Dilution: With more information to process, the model’s attention mechanisms become less effective at maintaining coherence across all aspects of the task.
3. Error Compounding: Small mistakes early in a complex process cascade into larger errors later, with no built-in correction mechanism.

The key insight: This barrier isn’t merely a technical limitation, but a fundamental constraint of the horizontal agent approach itself.

Look at the data from specialized vertical agents that overcome this barrier. In domains like insurance claims processing, vertical agents achieve 92% accuracy versus 47% for horizontal counterparts. The difference is architectural, not just a matter of scale or training.

What is the longest, most complex task you expect your AI systems to handle? Have you tested whether they hit the task length barrier? Understanding this threshold is crucial for setting realistic expectations and designing effective agent architectures.

The Apprenticeship Model: Teaching Agents to Fish

“Just like you would when you sit down an intern or apprentice on first day… Here are the tools dude, here is the knowledge base of our policies and procedures, these are your goals… here is your orchestrator and your other buddy.”

This apprenticeship framing fundamentally transforms how we conceptualize AI agent onboarding. Rather than programming strict rule sets, we’re creating learning environments—just as we would for human intelligence.

Consider how you’d bring a new employee into your organization:

1. You’d introduce them to available resources
2. You’d explain company policies and procedures
3. You’d clarify their goals and responsibilities
4. You’d connect them with colleagues and mentors
5. You’d give them space to learn and grow

This human-centered approach is precisely what effective vertical agents require. Rather than constraining them with predetermined workflows, we provide them with:

• Resources: Access to relevant tools and data sources
• Knowledge: Domain-specific information and guidelines
• Purpose: Clear objectives and success criteria
• Connections: Interactions with complementary agents and systems
• Autonomy: Space to develop their approach within appropriate guardrails

The difference is profound: “I am not going to build a workflow because I want my intern to learn to fish, and not come to me every time the workflow is not working.”

This approach doesn’t just make philosophical sense—it delivers practical results. In financial services implementations, apprenticeship-oriented agents show 37% higher accuracy in complex decision tasks compared to traditional workflow-based approaches. The key differentiator is adaptive learning: these systems refine their approaches based on feedback, just as human apprentices do.

How would your agent architecture change if you thought of your AI systems as apprentices rather than automatons? Would you focus more on providing resources and guidance rather than rigid instructions?

The Technical Debt Paradox: How Complexity Can Reduce Maintenance

“With properly designed vertical agents, we’re witnessing something beautifully counterintuitive: past a certain threshold, agents begin reducing maintenance costs precisely because they’re adaptable.”

This insight challenges decades of conventional wisdom in system design. We’ve all been trained to view complexity as a direct driver of maintenance burden—a formula “as reliable as death and taxes.” Yet vertical agent implementations are revealing an unexpected paradox: properly structured complexity can actually reduce long-term maintenance requirements.

The technical debt paradox works like this:

1. Traditional Systems: More complexity → More failure points → Higher maintenance costs
2. Vertical Agents: More adaptability → Self-maintenance capabilities → Lower ongoing costs

This isn’t theoretical—it’s observable in production environments. One financial services firm reported a 43% reduction in system maintenance hours after migrating from traditional RPA workflows to vertical agent architecture. The key wasn’t simplification, but strategic complexity that enabled self-healing capabilities.

What makes this possible? Three key mechanisms:

1. The Knowledge Network Multiplier: As agents accumulate domain understanding, they become increasingly effective at handling edge cases without requiring code changes.
2. Decoupled Architecture: Radial design naturally creates loosely coupled systems where components can be updated independently.
3. Self-Diagnostic Capabilities: Well-designed agents can identify their own limitations and performance issues, flagging them before they become critical.

This represents a paradigm shift in how we think about system maintenance. Rather than minimizing complexity at all costs, the goal becomes creating the right kind of complexity—adaptive, self-improving systems that grow more robust with use.

Is your organization still associating system complexity with maintenance burden? Have you explored how agent adaptability might actually reduce long-term operational costs?

Building Self-Improving Systems: The Ultimate Competitive Advantage

“I have taught my AI agents to re-build their own system instructions… burn-down entire CloudOps workflows and re-build them based on knowledge graph data.”

This capability represents the frontier of agent architecture—systems that not only execute tasks but continually refine their own operating instructions. It’s the difference between traditional software that requires external updates and living systems that evolve through experience.

The mechanics of self-improvement operate at three key levels:

1. Output Reflection: The agent analyzes its results against quality metrics, creating a tight feedback loop that drives continuous improvement.
2. Process Reflection: The agent evaluates its own decision-making steps, identifying inefficiencies and bottlenecks in its reasoning.
3. Full-Flow Reflection: The agent optimizes its entire operational pipeline, from initial understanding through execution to verification.

This isn’t just theoretical—it’s being implemented in production environments today. One cloud operations team reported that their self-improving agent architecture reduced incident response time by 68% over six months, with the system autonomously refining its approach based on past interventions.

The memory architecture that makes this possible is critical:

For every maths problem solved you store it as memory in a store outside of the LLM. And then dump your oldest bit of session context, because hey you can cache it in Redis or a LangObject (another tool at the end of a true agent's spoke). Don't put it in a workflow, tell the agent it can store its memories in vector stores, graphs, cache tools.

This approach solves one of the most persistent challenges in agent design: limited context windows. By externalizing memory and reasoning, we create systems that can maintain coherence across complex, extended operations—effectively pushing past the task length barrier.

What if your AI systems didn’t just perform tasks but actively improved their own operations? How would that change your approach to system design and maintenance?

Conclusion: The Cognitive Shift Required

The transition from linear to radial thinking doesn’t come naturally to everyone. As I’ve observed, “my cognitive shift happened earlier than the rest…there are other likes me though…funny story, they are neurodivergent too.”

This isn’t just a casual observation—it points to something profound about how different cognitive styles approach system design. The conventional, linear thinking that dominates enterprise architecture works well for stable, predictable systems. But the fluid, associative thinking often associated with neurodivergent perspectives may be better suited to designing adaptive agent architectures.

For enterprise leaders, this suggests that building effective agent systems may require more than just technical expertise—it may demand cognitive diversity on your teams. The most successful agent implementations I’ve seen have been led by individuals who naturally think in terms of networks and relationships rather than linear sequences.

What’s at stake is significant. Organizations that successfully make this cognitive shift will gain extraordinary advantages:

• Systems that adapt and improve without constant intervention
• Reduced maintenance burdens despite increased capabilities
• The ability to handle increasingly complex tasks that exceed the task length barrier

Those that don’t will find themselves trapped in the “bow tie on a cat” syndrome—spending enormous sums on systems that underperform because they’re fundamentally misconceived.

The future of enterprise AI belongs not to those with the biggest models or the most data, but to those who fundamentally reimagine how intelligence operates within their systems. The radial agent approach isn’t just a technical architecture—it’s a new way of thinking about the relationship between humans, machines, and intelligence itself.

Is your organization ready to make this cognitive shift? Are you building AI agents as if they were machines, or as if they were apprentices? The answer will determine whether you’re at the forefront of the agent revolution or merely following the crowd into expensive disappointment.

About the Author:

Chris Jones is CTO of Eclipse AI, where he helps enterprises navigate the complex landscape of AI implementation. Drawing on his experience across software development, system architecture, and AI strategy, he brings a uniquely multidisciplinary perspective to the challenges of integrating artificial intelligence into business operations.

Connect with me on LinkedIn to continue the conversation about agent architecture and enterprise AI transformation.

#EnterpriseAI #VerticalAgents #AITransformation #SystemDesign