The Frontier AI Landscape

A language model is not an agent; an agent is not a world model; a world model is not a simulation of reality. Each layer depends on the ones beneath it and adds something specific. The practical question for ATLAS is not 'how capable is the AI' but 'which of these layers does the licensed platform actually contain, and which would we have to build ourselves'.

• Large language models — predict the next token; the substrate for almost everything else.
• Reasoning models — spend more computation at inference time to work through multi-step problems.
• Foundation models — broad pretraining, then adaptation to many downstream tasks.
• Autonomous agents — a model plus tools, a loop, memory and a permission boundary.
• Multimodal models — reason across text, image, audio and structured data in one representation.
• Model-based reinforcement learning — learn a model of the environment, then plan or train inside it.
• World models — an explicit latent state plus transition dynamics, rolled forward to test futures.
• Specialised domain intelligence — narrow models with domain data, verifiers and tooling.

The transformer architecture introduced attention as the primary mechanism for relating tokens to one another, which made training on very large corpora practical. Pretraining on next-token prediction over a broad corpus produces a model that encodes a great deal of structure about language, and — as a by-product — about the world that language describes.

Instruction tuning and preference-based fine-tuning then turn a text-completion engine into something that follows requests. This is a behavioural layer, not a knowledge guarantee: it makes the model cooperative, not correct.

• Strength: broad competence without task-specific training, and rapid adaptation through context.
• Strength: a single interface for analysis, drafting, classification and extraction.
• Limit: fluent output is not evidence. Plausibility and correctness are different properties.
• Limit: knowledge is frozen at training time unless retrieval or tools are added.

Chain-of-thought prompting showed that asking a model to work through steps improves performance on multi-step arithmetic and reasoning benchmarks. Later work trained models, often with reinforcement learning against verifiable rewards, to do this internally and at length. The practical consequence is that capability now scales with test-time compute: you can pay more per query to get a more careful answer.

What this does not do is verify itself. Longer reasoning traces improve the probability of a correct derivation on problems with checkable answers; they do not make an unverifiable claim true. In a financial or contractual context, the verification step must remain external.

• Executive consequence: latency and cost per decision rise, sometimes by an order of magnitude.
• Executive consequence: reasoning is worth paying for where the answer can be checked.
• Evidence status: the mechanism is well documented; any specific accuracy claim is benchmark-specific.

A multimodal model maps images, audio, text and structured data into a shared representation, so a single system can reason across them. This matters directly for operational work: documents, charts, screenshots, transcripts and tables stop being separate pipelines.

ReAct established the pattern that dominates today: interleave reasoning with actions, observe results, and continue until a stopping condition. Toolformer showed a model can learn when to call external tools. Production systems add orchestration, retries, sandboxes and human approval gates.

• Cost model: agent runs multiply model calls; cost is per completed task, not per query.
• Reliability: error rates compound over steps, so horizon length is the governing constraint.
• Governance: every tool is a permission. An agent with write access is an operational risk, not a feature.

Model-free methods learn a policy directly from experience. Model-based methods learn a predictive model of the environment and use it — to plan, to generate synthetic experience, or to reduce the number of real interactions required. AlphaZero is the clearest public demonstration that self-play against a learned model of a well-defined system produces extraordinary performance within that system.

The published evidence is real but bounded: Ha and Schmidhuber demonstrated learning inside a compact learned model of a visual environment, and the Dreamer line of work reported a single world-model configuration mastering control tasks across many domains. Neither result implies that a learned model remains accurate over long horizons, or that it transfers to an environment with strategic, adaptive participants.

• Domain data usually matters more than model size, and is the asset we already hold.
• Deterministic verifiers — schemas, invariants, reconciliation — convert probabilistic output into accountable output.
• Narrow scope makes failure measurable, which is the precondition for any honest evaluation.