Frontier models are asked to inhabit a strange range of timescales.
At one extreme, we ask them to work on mathematical problems that have resisted us for decades. At another, we ask them to inspect an email, rename a file, transform a record, or choose an API call.
Difficulty is only part of the difference. These tasks run on different clocks.
A difficult proof may require fresh search. A routine operation often repeats a mechanism that has already been understood. Replacing the frontier model with a smaller model reduces the cost, but retains inference as the runtime architecture.
Another possibility is to move the competence out of inference altogether.
A capable model can map the task, infer its edge cases, construct tests, and synthesize a bounded artifact. Once validated, that artifact can execute quickly, deterministically, and at negligible marginal cost.
I call this competence compilation: the conversion of expensive general reasoning into machinery that retains its result.
Competence compilation
The resulting artifact might be a script, a parser, a state machine, a signal transform, a controller, a routing policy, an evaluator, or a small domain-specific program.
These forms can remain highly responsive. A state machine retains local memory. A controller reacts to changing inputs. A program can search locally, recover from expected errors, and choose among actions. Within a bounded domain, substantial adaptation can occur without another model evaluation.
The reasoning used to construct the artifact survives in its structure, tests, and operating boundary.
A single expensive call can amortize its reasoning over every subsequent execution. Reconstructing the same mechanism from context discards that leverage.
A mature agent should notice that recurrence. It should identify which parts of its reasoning have become invariant, extract them, and leave only the unresolved remainder inside the model.
Keep only the unresolved part of the problem inside the model.
Compilation also requires a boundary. The artifact needs a declared domain, tests that establish its behavior, and conditions under which it should yield. When inputs escape that domain, evidence weakens, or outcomes drift, broader reasoning can return.
The design problem is to place each competence on the fastest, cheapest clock that can carry it without erasing its boundary.
A trading organism
The trading system I am building makes these clocks concrete.
Its fastest behavioral artifacts are programs written in a small trading-domain Lisp. They access signals as variables and compose them into executable behavior. The representation is compact enough for fast execution and structured enough for mutation, recombination, and inspection.
The signals are artifacts too. They may contain filters, transforms, statistical machinery, or learned components. They can be composed and evolved alongside the programs that consume them. Intelligence can settle into a signal, an expression, a mutation operator, a behavioral descriptor, an evaluator, an allocation policy, or a promotion rule.
The population spreads across a behavior space. Some programs trade frequently; some wait. Some respond to short histories, others to longer structure. Some accept volatility. Some occupy narrow regions that are rarely useful until the environment changes.
The system preserves these differences in niches. A niche does not need a name such as “bear market strategy” or “high volatility strategy.” It preserves a behavior with particular properties, while later evidence reveals where that behavior is useful.
The behavior map becomes an implicit regime memory without requiring the final regime vocabulary in advance.
Different clocks
Signals and Lisp programs operate on the clock of the market. They update continuously and cannot wait for a frontier model to reconstruct their purpose from tokens.
Above them, an allocator updates its belief over the repertoire. Promotion and suppression operate at another cadence. Evaluation accumulates evidence more slowly. Evolution generates, composes, and tests alternatives more slowly still.
The frontier model operates at a slower cadence and with a wider field of view. It can wake on a heartbeat or in response to an event: a failure, a gap in the behavior map, an unusual result, a change in the environment, or a region the existing search machinery cannot reach.
It may synthesize a signal, a program fragment, a descriptor, an evaluator, a mutation operator, or a change to the language in which lower competencies are expressed. Once tested and accepted, that contribution moves downward into a faster layer.
semantic reasoning
↓ compile
evolution / evaluation
↓ promote
allocation
↓ control
signals / programs
↓
environment
↑ evidence
↑ failure / driftThe downward movement is compilation. The upward movement is escalation.
A clock here is the characteristic cadence at which a process observes, decides, or changes. Some clocks are continuous, some periodic, and some event-driven. Their separation allows local processes to keep acting while slower processes gather enough evidence to intervene.
Multi-clock intelligence
Multi-clock intelligence is an adaptive architecture in which slower, more general reasoning synthesizes and revises bounded competencies that operate on faster clocks, while evidence can force escalation upward.
Systems have long separated control across timescales. Frontier models add a consequential operation: the slower process can deliberately construct, inspect, and revise the machinery below it. The destination can be code, signals, tests, constraints, policies, representations, or search operators. The model weights may stay fixed.
The intelligence of such a system lies partly in how work is distributed: what can act locally, what must accumulate evidence, and what deserves general reasoning. Fast layers trade scope for cadence. Slow layers see more context and intervene less often.
No single layer contains the whole adaptive process. Signals respond. Programs act. Allocators shift belief. Evaluators accumulate evidence. Evolution maintains alternatives. General reasoning expands or repairs the machinery when its current boundaries become visible.
Between calls
Many current AI agents adapt by being called again. They receive new context, reason, and emit another action. Their adaptation is serial and inference-bound.
A multi-clock system continues to adapt between model calls. State changes. Allocation moves across a repertoire. Evidence accumulates. Candidates are promoted, suppressed, or replaced. The model returns when the existing machinery encounters something it cannot adequately absorb.
The same pattern applies wherever expensive reasoning can create bounded machinery for a faster environment: scientific instruments, industrial control, software operations, and personal automation.
It also describes how I increasingly use AI. The conversation runs on a slow semantic clock. Observations become distinctions; distinctions become terminology, diagrams, tests, programs, and articles. What matters is compiled outward into forms that can persist and operate between conversations.
The model does not need to think at the speed of the market. It needs to build things that can.