i. Cognitive Systems

CLOS

Cognitive Operating System

A 37-agent operating system for attention, where every routing decision comes from one hardcoded priority equation rather than a model's mood.

Running, with an iOS client Python Swift MCP SQLite Ollama

What it does

CLOS takes raw signal, a voice note, a CLI line, a captured thought, and decides what, if anything, should happen to it. Agents are named after the people who founded the algorithms they wrap, which keeps the roster honest about what each one actually is.

The pipeline is deliberately narrow: condense, score, route. A voice transcription arrives as 500 to 5,000 tokens of filler; the condenser strips it to under 150 before any model call happens, which is both a cost decision and an accuracy one. The condensed signal is then scored, and the score decides which agent sees it.

In the code

The priority equation, hardcoded on purpose
"""
CLOS Priority Scorer
Implements P(S) = (Leverage x Relevance x Quality x Urgency) / Attention Cost

This is the non-negotiable, hardcoded equation that drives ALL task routing
and agent activation decisions in CLOS.
"""

@dataclass
class Signal:
    raw: str                      # original text input
    leverage: float = 0.5         # downstream impact
    relevance: float = 0.5        # alignment to current goals
    quality: float = 0.5          # information density
    urgency: float = 0.5          # time sensitivity
    attention_cost: float = 0.5   # cognitive load required

Attention cost is a divisor with a floor, so nothing can claim to be free. A model can propose the five inputs, but it cannot change how they combine, which means a routing decision can be recomputed and argued with later.

The condenser runs before the model, not after
# Filler patterns common in voice transcriptions
_FILLER_PATTERNS = [
    r'\b(um+|uh+|ah+|er+|hmm+|like|you know|i mean|basically|actually)\b',
    r'\b(i think|i guess|i suppose|let me think|how do i say this)\b',
    r'\b(sort of|kind of|more or less|pretty much)\b',
]
_STUTTER_RE = re.compile(r'\b(\w+)(\s+\1){1,}\b', re.IGNORECASE)

# raw input -> condense() -> compact signal (< 150 tokens target)

Deterministic regex, no model call. Cheap, auditable, and it runs identically offline, the expensive stage only ever sees signal.

How this differs from the ordinary version

The routing rule is readable

Most agent frameworks route by asking a model which tool to use, which makes the decision unrepeatable and unarguable. Here the rule is five numbers and one equation. You can disagree with a routing decision and point at the term that caused it.

Cheap work happens before expensive work

Condensation, domain tagging and scoring are all deterministic and local. A model is only invoked once the system already knows the signal is worth the call, which is the opposite of the common pattern of piping raw transcript straight into a frontier model and paying for the filler.

In the field

Why an operator needs this

The pattern generalizes past personal use: any operation that takes unstructured inbound, dispatch calls, shift-handover notes, quality complaints, has the same problem, which is that the volume is high, the value is uneven, and the expensive step should be reserved for the items that earn it.

Questions

Why name agents after algorithm founders?
It forces honesty about what each agent is. An agent named after the person who published the method it wraps cannot quietly become a general-purpose chatbot.