DEV Community: Debdip Bandyopadhyay

The Coordinate Systems of Intelligence: Why We Need Parallel Agents, Not Bigger Models

Debdip Bandyopadhyay — Wed, 18 Feb 2026 20:50:08 +0000

In [Part 1], I argued that agentic systems—deterministic, stateful, memory-driven—can outperform monolithic AGI for most practical tasks. But I glossed over the how.

How do multiple agents actually coordinate? How do they maintain consistency without becoming a single, fused model?

The answer comes from an unexpected place: multivariable calculus.

The Problem with One Coordinate System

When you solve an integral, you choose a coordinate system:

Cartesian ((x, y)) for grids and linear structures
Polar ((r, \theta)) for circles and rotations
Spherical ((r, \theta, \phi)) for 3D surfaces

Here's the thing: the same problem yields vastly different complexity depending on your choice.

Compute the area of a circle with radius (R):

Cartesian:
[
\int_{-R}^{R} \int_{-\sqrt{R^2-x^2}}^{\sqrt{R^2-x^2}} dy \, dx = \pi R^2
]

Messy. Square roots. Trigonometric substitution. Four pages of algebra.

Polar:
[
\int_{0}^{2\pi} \int_{0}^{R} r \, dr \, d\theta = \pi R^2
]

Clean. Two lines. Same answer.

Intelligence as Coordinate Selection

Current AI forces everything through one coordinate system:

Vision models: Pixel-space (Cartesian-like grid)
Language models: Token-space (sequential, linear)
World models: Geometric-space (3D reconstruction)

But reality doesn't care about your coordinates. A self-driving car doesn't "see" pixels. It doesn't "think" in tokens. It navigates a unified field that requires multiple simultaneous expansions:

Reality Aspect	Best Coordinate System	Brain Region
Spatial geometry	Polar/Spherical	Visual cortex
Temporal prediction	Sequential/Time	Temporal cortex
Physical intuition	Force/Embodied	Motor cortex
Social protocol	State-machine/Boolean	Prefrontal cortex

The brain doesn't fuse these. It runs them in parallel and orchestrates the results.

The Jacobian of Agent Coordination

In calculus, when you switch coordinates, you multiply by the Jacobian determinant to maintain consistency:

[
\iint f(x,y) \, dx \, dy = \iint f(r,\theta) \cdot |J| \, dr \, d\theta
]

Where:
[
J = \begin{vmatrix} \frac{\partial x}{\partial r} & \frac{\partial x}{\partial \theta} \ \frac{\partial y}{\partial r} & \frac{\partial y}{\partial \theta} \end{vmatrix} = r
]

In agentic systems, the Jacobian is the communication protocol. It ensures that when Agent A (vision) says "obstacle at 3 meters" and Agent B (memory) says "this intersection has blind spots," both map to the same objective reality—even though they computed it through different internal representations.

Real-Time Coordination: The Hierarchical Jacobian

Here's where it gets practical. You can't wait for full consensus in real-time systems.

The brain solves this with hierarchical coordination:

Millisecond scale (Reflex):
  └── Agent: Motor controller
  └── Input: Sensor state
  └── Action: Immediate (no consensus needed)
  └── Latency: < 1ms

Centisecond scale (Tactical):
  └── Agents: Vision + Memory + Prediction
  └── Protocol: Async message passing (ZeroMQ/gRPC)
  └── Action: Coordinated response
  └── Latency: 10-50ms

Second scale (Strategic):
  └── Agents: Full swarm consensus
  └── Protocol: Synchronous (Paxos/Raft)
  └── Action: Goal reassignment
  └── Latency: 100ms+

The "Jacobian"—the protocol ensuring consistency—becomes time-varying:

[
J(t) = \begin{cases}
I & \text{if } t < \tau_{\text{reflex}} \text{ (identity, no transform)} \
J_{\text{async}}(t) & \text{if } \tau_{\text{reflex}} < t < \tau_{\text{strategic}} \
J_{\text{consensus}} & \text{if } t > \tau_{\text{strategic}}
\end{cases}
]

Implementation: A Test Automation Example

Consider a flaky test suite. Multiple agents can coordinate in real-time:

# Vision Agent: Coordinate system = DOM structure (hierarchical)
class VisionAgent:
    def observe(self):
        return {"locator": "#submit-btn", "state": "visible", "confidence": 0.95}

# Memory Agent: Coordinate system = temporal/experience (sequential)
class MemoryAgent:
    def recall(self, locator):
        return {"locator": locator, 
                "historical_flakiness": 0.3, 
                "avg_retry_time": 2.5}

# Protocol Agent: Coordinate system = deterministic state (Boolean)
class ProtocolAgent:
    def should_retry(self, vision, memory):
        if vision["confidence"] < 0.9 and memory["historical_flakiness"] > 0.2:
            return True
        return False

# The "Jacobian"—consensus protocol
def coordinate(vision_agent, memory_agent, protocol_agent, locator):
    vision_data = vision_agent.observe()
    memory_data = memory_agent.recall(locator)

    # This is the coordinate transformation ensuring consistency
    decision = protocol_agent.should_retry(vision_data, memory_data)

    return decision

Each agent operates in its own "coordinate system"—pixels, history, rules. The protocol ensures they map to the same decision.

Why This Matters for Engineers

1. Modularity without fusion

You don't need to train one giant model that "understands" both vision and history. You need:

A vision model (existing, pre-trained)
A memory database (deterministic, queryable)
A protocol layer (your engineering contribution)

2. Deterministic safety

The Jacobian/protocol is explicit, auditable, and controllable. Unlike the latent space of a fused neural network, you can inspect and modify the consensus logic.

3. Latency optimization

By keeping coordinate systems separate, you can cache, parallelize, and optimize each independently. The vision agent can run on GPU. The memory agent on a fast key-value store. The protocol on edge.

The Conclusion

Intelligence is not about having the biggest, most unified model. It's about having the right coordinate system for the problem—and the protocol to coordinate between them.

Monolithic AI is like solving every integral in Cartesian coordinates because that's what your library supports. It works. It's slow. It's error-prone.

Agentic AI is like having a library that can switch to Polar, Spherical, or any coordinate system the problem demands—then orchestrating the results through a Jacobian that ensures consistency.

The future isn't bigger models. It's better coordinate systems.

Part 3—The Real-Time Jacobian: Hierarchical Control for Millisecond-Scale Agent Coordination

The Multivariable Reality: Why Intelligence is Parallel, Not Unified

Debdip Bandyopadhyay — Wed, 18 Feb 2026 20:27:03 +0000

The brain is not a processor. It is an orchestra.
I want to propose an analogy. In multivariable calculus, the same problem yields different answers depending on how you expand the equation. Cartesian coordinates. Polar coordinates. Spherical. Each is valid. Each reveals something the others obscure. None is complete.
Reality is like this.
We have been debating whether intelligence is “one modality” or “many modalities”—whether the brain processes a unified reality or separate channels of vision, sound, and touch. But this is a false dichotomy. The brain does neither. It does both. It does something more sophisticated.
The Parallel Orchestration
The brain is not a unified processor grinding through a single stream of reality. It is Broadmann’s areas operating in parallel—visual cortex, auditory cortex, somatosensory regions, associative areas—each handling a different “expansion” of the same underlying reality.
When you drive, your visual cortex is not “merging” with your auditory cortex. They are operating simultaneously, in tandem, each processing their own coordinate system of the problem. The unity you experience is not the input. It is the emergent output of parallel processing.
This is crucial. The intelligence is not in the unification. It is not in the separation. It is in the orchestration—the simultaneous, parallel processing with emergent coordination.
The Coordinate System Problem
Current AI architectures force reality into single coordinate systems. World models try to compress everything into geometric space. Vision models force everything into pixel classification. Language models force everything into token sequences.
Each is valid. Each is incomplete.
The multivariable calculus insight is that we can choose our parameterization. For some problems, Cartesian coordinates simplify beautifully. For others, polar coordinates reveal structure that Cartesian obscures. The skill is not in committing to one coordinate system. It is in knowing which expansion to apply.
This is what agentic systems enable.
An agentic architecture can maintain parallel state machines: one tracking visual input, one tracking temporal patterns, one tracking physical constraints, one tracking social protocols. These operate in tandem—not sequentially fused, but orchestrated. Like Broadmann’s areas.
When a human driver approaches an intersection, they are not fusing “vision” and “sound” and “memory.” They are running parallel expansions: visual geometry of the scene, temporal prediction of traffic flow, physical intuition of braking distances, social protocol of right-of-way. Each is a different coordinate system of the same underlying reality.
The skill of driving is not processing any one of these. It is orchestrating all of them simultaneously.
Why Agentic Systems Mirror Intelligence
This is why agentic systems succeed where monolithic models struggle. A large language model attempts to force all intelligence through the coordinate system of language. A vision model forces everything through pixels. Each is a valid expansion. Each misses what the others capture.
An agentic system allows multiple coordinate systems to coexist: deterministic state machines for protocol, memory architectures for experience, constraint checkers for physics, pattern recognizers for prediction. They run in parallel. They influence each other. But they are not “fused” into a single processing stream.
The orchestration is the intelligence.
The Architecture of Choice
The engineering implication is profound. We are not building systems that “see” or “hear” or “remember.” We are building architectures that can choose the right expansion of reality for the problem at hand.
Some problems yield to visual-geometry coordinate systems. Others yield to temporal-sequential expansions. Others yield to state-machine determinism. The intelligent system is not the one that commits to one coordinate system—the “pure vision” approach, the “pure language” approach—but the one that can orchestrate multiple parallel expansions.
This mirrors the brain. Broadmann’s areas are not “modules” to be fused. They are parallel processors, each with their own coordinate system, each contributing to the emergent understanding.
The Skill of Orchestration
When we say humans have “skills,” this is what we mean. A skilled driver is not someone with better vision. They are someone who has learned to orchestrate the parallel expansions: to weight the visual coordinate system heavily in fog, to trust the temporal prediction system in heavy traffic, to let the physical intuition system override when something “feels wrong.”
The skill is knowing which coordinate system to trust when.
Agentic systems can embody this. They can maintain explicit state machines for different expansions. They can have “meta” protocols that decide which agent’s output to weight in which context. They can learn from experience not by updating a single massive weight matrix, but by refining the orchestration—the rules of engagement between parallel processes.
Conclusion: The Parallel Path
The future of artificial intelligence is not the unified mind. It is the orchestrated chorus.
We have been seduced by the idea of a single, coherent intelligence—one model, one architecture, one coordinate system to rule them all. But this is not how intelligence works. Not in brains. Not in the mathematics of multivariable calculus. Not in reality.
Intelligence is parallel expansion. It is maintaining multiple valid coordinate systems simultaneously. It is letting the visual cortex do its geometry while the temporal cortex does its prediction while the memory system does its pattern-matching—and trusting the emergent coordination to yield the right action.
Agentic systems give us this architecture. They allow us to build not one superintelligence, but a society of intelligences—each with its own coordinate system, each its own expansion of reality, orchestrated by protocols that mirror the brain’s parallel wisdom.
We do not need to solve intelligence. We need to orchestrate it.
The orchestra is already tuned. The musicians are ready. The intelligence is in the conducting.