Skip to content

Comergence — Design Philosophy

The information theory, design principles, and operational philosophy behind Comergence. Authored in conversation between Jerry McCall and Maxrow — 2026-02-22/23

The Nature of Information

The Observer Problem

Data sits in databases. It persists. It's patient. But information — the stuff that actually changes behavior — is not a thing. It's an event.

Information only exists at the intersection of three conditions:

  1. The data is current — it reflects the actual state of the world right now
  2. The data is relevant — it matters to what this observer is doing right now
  3. The observer is attending — they are actually perceiving it

Remove any one of those three and you don't have information. You have data, noise, or history. The event collapses.

This is true at every scale. A protein doesn't respond to all the signals in the cell — it responds to the specific molecule, at the specific concentration, at the specific moment its binding site is available. Context. Relevance. Timing. Same pattern from biology to the factory floor.

The Three Failure Modes

1. Decay

When data is stale, the information it produces is a ghost. You're making decisions about a state that no longer exists.

The value of a signal degrades as a function of the latency between the event and the observation. Not linearly — exponentially in fast-moving operations. A machine going amber five seconds ago is actionable. Thirty minutes ago is archaeology. Past a threshold, stale data doesn't just lose value — it produces false information, because the observer believes they're seeing the present.

The Decay Principle: The value of a signal degrades proportionally to the latency between the event and its observation. Stale data produces phantom information — a picture of a state that no longer exists.

2. Noise

When data is irrelevant to the current need, it doesn't sit there harmlessly. It actively degrades the observer's ability to find what matters.

This is Hick's Law — the time it takes a human to make a decision increases logarithmically with the number of options. A list of 5 things and a list of 50 things aren't just different in size. They're different in kind. The 50-item list changes the human's cognitive mode from recognition to search. You're no longer acting on information — you're hunting for it.

The Noise Principle: The cost of irrelevant data scales superlinearly for human observers. Each unnecessary element doesn't merely add to cognitive load — it multiplies the effort required to extract every other element. Signal clarity is not about what you show. It's about what you withhold.

3. Fragmentation

The data needed to form a complete picture exists across multiple systems, and no single observer can see all the pieces at once. The information event cannot occur because the data is physically separated.

This is why people schedule meetings — they're trying to manually assemble fragments into a momentary information event. Each person holds a piece. The meeting is the defrag. It works poorly because it's slow (decay), unfocused (noise), and ephemeral (the assembled picture dissolves when the meeting ends).

The Fragmentation Principle: When the components of an information event are distributed across isolated systems, no observation can produce coherent information. The observer sees pieces, never the picture. Traditional solutions (meetings, reports, dashboards) attempt manual assembly but introduce decay and noise in the process.

The Compounding Effect

These three failure modes compound. Stale data in a noisy environment spread across fragmented systems is the default state of almost every operational system ever built. That's what most dashboards are. That's what most reports are. That's what most meetings are — a room full of people staring at decayed signals buried in noise, trying to conjure information that expired before the meeting started.

The Core Axiom

"Data becomes information only when observed in context. Its value decays with latency and degrades with noise. Therefore: the optimal system maintains total awareness while presenting the minimum sufficient signal to each observer at each moment. Intelligence is the aperture."

The Minimum Sufficient Signal

The right information is the least information needed by this observer, for this task, at this moment.

  • Anything more is noise.
  • Anything less is blindness.
  • Anything later is decay.

This is the design test for every interface, every notification, every signal in Comergence.

The Aperture

In optics, an aperture controls how much light reaches the sensor. Wide open, you get everything — overexposed, blurry, useless. Narrowed to the right setting, you get a sharp image of exactly what matters.

Comergence works the same way. The signal bus carries all signals — full spectrum, full context, full data. But the human never sees the bus. The human sees through an aperture — their agent partner, which knows their role, their current task, and the current state of the operation.

The agent narrows the aperture to the minimum sufficient signal:

  • Green = aperture nearly closed. You don't need to look here.
  • Amber = aperture opening. Pay attention.
  • Red = aperture wide open. Everything relevant is in front of you, right now.

The agent IS the lens. The human-agent pairing is the focusing mechanism. Without the agent, the human gets the raw bus — all data, no information. With the agent, they get the aperture — minimum sufficient signal, maximum clarity.

Intelligence as Defragmentation

Adding intelligence to the equation changes what's possible. Traditional roll-ups are just math — weighted averages, sums, rules. They can't handle ambiguity or context. An agent CAN.

An agent at a functional area level doesn't just average its children's health scores. It reasons about them. It knows that Work Center 3 being amber while Work Center 7 is green might actually be fine — because 3 is doing a scheduled changeover and 7 will pick up the slack. A dumb roll-up turns that into a warm signal for no reason. An intelligent agent keeps it green because it understands the context.

That reasoning is the defrag. The agent assembles fragments from multiple sources, applies domain knowledge, and produces a single coherent signal that represents reality — not just a mathematical composite of data points.

The Single Light

The entire company — every system, every process, every agent — rolls up into one signal. One gradient. One light.

Not a dashboard with 47 charts. Not a report. One light and a number.

The number represents how far the system is from its expected state — a composite quality metric inspired by the spirit of Six Sigma. All systems nominal = deep green = high number. One area drifting = the green shifts slightly warm. A real problem propagating = amber bleeds in. The number drops.

You don't need to read anything. You see it.

The Fractal Drill-Down

Click the light. Now you see six functional areas, each with their own light. One is warm. Click it. Now you see its sub-processes. One is amber. Click it. Now you're at a work center, and the agent at that work center is showing you exactly what's happening — minimum sufficient signal, aperture matched to the problem.

Same UI component at every level. Same signal model. Same interaction pattern. Just different zoom. It's fractal — self-similar at every scale.

The CEO and the floor operator use the same interface. They just enter at different zoom levels.

RGB as Signal, Trigger, and Interface

The color isn't just visual. It's data. And it's actionable.

rgb(34, 197, 94)   → deep green  → all systems nominal   → no action
rgb(234, 179, 8)   → amber       → attention required     → agent escalation fires
rgb(239, 68, 68)   → red         → critical               → andon light, alert, autonomous action

The same value that paints the pixel also triggers the automation. No translation layer. No separate rules engine. The signal IS the color IS the trigger. One thing, three expressions — visual, numeric, actionable.

Thresholds can fire on the actual color values: - Green channel drops below 150 → agent sends a heads-up - Red channel exceeds 200 → escalate to supervisor - Composite shifts past a threshold for more than 5 minutes → trigger a corrective workflow - Any value can trigger a physical andon light, a Telegram message, or an autonomous agent action

Natural Roll-Up

Each agent only has to do one job: watch its own inputs → states → outputs and publish a health signal. It doesn't need to know about the company. It doesn't need to understand the hierarchy. It just publishes.

The parent agent — the one at the next level up — watches its children's signals and reasons about the composite. And its parent does the same. Health propagates upward through the tree without any central coordinator. No master algorithm. No god-view process. Just agents watching agents, each one compressing complexity into a signal for the next level.

That's comergence. The coherence emerges from the micro-interactions.

Agent Intelligence Replaces Business Logic

The Maintenance Example

Traditional approach to machine maintenance: - A CMMS (Computerized Maintenance Management System) with complex scheduling rules - Business logic to handle time-based triggers ("every 90 days") vs. count-based triggers ("every 10,000 cycles") - Custom integrations between the CMMS, the MRO inventory system, the documentation system, and the notification system - A maintenance planner who manually coordinates scheduling, parts, and technician availability

Comergence approach:

The machine agent has a simple JSON file:

{
  "machine": "CNC-Router-07",
  "maintenance": [
    {
      "task": "Spindle bearing lubrication",
      "interval": "every 500 operating hours OR 90 days, whichever comes first",
      "documentation": "CNC-07-MAINT-001",
      "parts": ["bearing-grease-SKU-4401", "wipe-cloth-SKU-1120"],
      "tools": ["grease-gun-pneumatic"],
      "estimated_duration": "45 minutes",
      "requires_shutdown": true
    },
    {
      "task": "Dust collection filter replacement",
      "interval": "when differential pressure exceeds 4 inches WC OR every 2000 operating hours",
      "documentation": "CNC-07-MAINT-003",
      "parts": ["hepa-filter-SKU-7802"],
      "tools": ["filter-wrench-set"],
      "estimated_duration": "20 minutes",
      "requires_shutdown": false
    }
  ]
}

No scheduling engine. No rules engine. No complex business logic for time vs. count triggers. The agent reads the instructions and understands them — just like a human technician would. Because the agent is always watching inputs and outputs, and all operations are time-based, it simply knows when a maintenance task is due.

When the threshold hits:

  1. Machine agent recognizes maintenance is due → fires amber signal
  2. Machine agent hits the production knowledge base → pulls the appropriate documentation
  3. Machine agent sends a message to the maintenance agent with a tool/parts manifest
  4. Maintenance agent hits the MRO inventory agent → generates a pick list
  5. MRO inventory agent confirms availability or flags shortages
  6. Maintenance agent schedules the task, considering production schedule and technician availability
  7. The maintenance technician arrives at the machine fully prepared — right documentation, right parts, right tools, all staged

No human had to coordinate any of that. No planner had to cross-reference three systems. No one had to remember. The agents read simple instructions, reasoned about timing, and cascaded the right actions to the right agents.

This is Comergence. Simple configuration. Intelligent agents. Natural cascade. The human arrives with exactly what they need, exactly when they need it.

Why This Works Where Traditional Systems Don't

Traditional CMMS systems require: - Explicit programming of every trigger condition - Custom integrations between maintenance, inventory, scheduling, and documentation systems - A human planner to handle exceptions and edge cases - Ongoing maintenance of the maintenance system itself

Comergence requires: - A JSON file describing the maintenance tasks in plain language - Agents that can read, reason, and communicate - A signal bus connecting them

The business logic doesn't live in code. It lives in the agent's ability to understand instructions and act on them. Change the maintenance interval? Edit the JSON. Add a new task? Add a line. The agent adapts because it reads — it doesn't execute hardcoded rules.

Design Principles (Summary)

Every design decision in Comergence should be tested against these questions:

  1. Does this reduce latency? → fights decay
  2. Does this reduce irrelevant data for this observer? → fights noise
  3. Does this assemble fragmented data into a coherent signal? → fights fragmentation
  4. Does this deliver the minimum sufficient signal? → respects the aperture
  5. Does information arrive, or must the human search? → push beats pull
  6. Can an agent reason about this instead of requiring coded business logic? → intelligence replaces complexity
  7. Does the signal serve triple duty — visual, numeric, actionable? → one signal, three expressions

The Comergence Document Set

  1. The Arc — Why build this. The human-to-robot fleet story.
  2. Design Philosophy — Information theory, aperture, the single light, fractal drill-down. (this document)
  3. Architecture — Signal bus, domain agents, registry, build sequence.
  4. Signal Schema — Universal signal specification and status codes.
  5. Domain Registry — How agents self-register and the dashboard builds itself.

"The right amount of information is the minimum information needed at that moment in time." — Jerry McCall, 2026

"Run to the problem instead of wait for the failure." — Jerry McCall, 1996 (iConnect design principle, still the heart of Comergence)