A living map of what has happened, what is changing now, and what credible futures may come next.
21 past turning points · 39 now signals · 15 next forecasts
As agents learn internal workflows and accumulate context, switching costs compound silently. What looks like a productivity gain becomes structural dependency on a single vendor's memory layer.
_Watch for the moment your AI vendor's memory of your business becomes more valuable than the model itself._
Cursor adding Git platform features and a mobile app signals that AI coding tools are no longer competing on model quality alone. The battleground is shifting to full developer workflow ownership.
_Expect coding tool vendors to absorb adjacent developer tooling categories rather than stay focused on the editor._
Agents running autonomously in the background are exposing the same failure modes as distributed systems: race conditions, unbounded retries, and no clear ownership. The gap between demo and production is turning into an engineering crisis.
*Expect a wave of agent circuit-breaker tooling as teams discover that loop management is now a first-class infrastructure problem.*
Five Eyes agencies are now saying offensive AI threats are months away, not years. That shifts the conversation from policy speculation to active defence preparation.
*Watch for enterprise security teams accelerating AI threat modelling as government warnings give internal risk budgets a concrete anchor.*
AWS and Cloudflare both shipped agent-focused infrastructure fixes in the same week. Platforms are no longer waiting for standards to settle before solving agent operational problems themselves.
_Watch for cloud vendors to quietly lock in agent workflows before open protocols can compete._
Banning AI models hands labs free publicity and drives curiosity-driven uptake. The Anthropic ban saga shows regulation can backfire badly when the product is software.
_Expect policymakers to face pressure to find enforcement mechanisms that don't double as marketing campaigns._
Tools that gate, review, or audit AI-generated commits are shipping as standalone products. As AI writes more code, the enforcement layer around that code is becoming its own market.
_Teams adopting AI coding tools should expect a parallel spend on commit-level governance before the end of the year._
Agents that update their own memory from experience can quietly encode bad behaviour with no checkpoint. The gap between capability and oversight is opening faster than tooling to close it.
_Watch for the emergence of memory-auditing as a distinct product category alongside agent deployment._
Temporary accounts and blank-slate modes for agents signal a shift away from persistent identity toward throwaway, task-scoped instances. This changes how trust, auth, and billing get handled at the infrastructure layer.
_Expect identity and access management vendors to rebuild product lines around short-lived agent sessions rather than long-lived user accounts._
A 3B reasoning model and a retrieval-focused small model appearing in the same radar cycle shows the compression trend moving from general chat into harder tasks. Small is no longer a concession, it is a design choice.
_Reconsider any architecture that defaults to large models for retrieval or reasoning steps without benchmarking smaller alternatives first._
Companies are shipping identical models with different safety configurations to serve both enterprise and consumer markets simultaneously. This creates artificial product tiers where safety becomes a feature you pay to customise.
Expect safety to become a configurable product parameter rather than a universal standard.
AI agents are gravitating towards command-line interfaces because they force clarity, but this dumps decades of system administration complexity directly onto developers. The terminal is becoming the preferred agent interaction layer.
Prepare for every developer to become a systems administrator as CLI agents proliferate.
Smart task routing between local and cloud models is creating systems that can't decide what they are. Local inference frameworks are making cloud APIs look obsolete whilst hybrid systems try to bridge both worlds.
Watch for AI systems to develop split personalities as they juggle local efficiency against cloud capability.
Chat interfaces are proving inadequate for complex AI agent workflows. Terminal-style interactions force precision and enable proper operational control.
Expect agent platforms to prioritise CLI tooling over conversational interfaces.
Model repositories are becoming attack vectors with no established cleanup protocols. The infrastructure for safe model distribution is broken.
Expect enterprise model deployment to shift towards private registries and strict provenance tracking.
Every AI company is racing to stream responses faster, creating pressure for instant interaction even when it degrades user experience.
Optimise for streaming latency as a primary competitive metric, not just model quality.
The industry is moving from shipping different model sizes to shipping different deployment configurations of the same model. This changes how we think about model distribution and optimisation.
Expect deployment infrastructure to become the primary differentiator, not model architecture.
AI interfaces are crossing from request-response patterns to continuous real-time interaction. This fundamentally changes how we design AI experiences.
Design for streaming, persistent connections rather than discrete API calls.
AI coding agents are shifting from prototyping tools to production engineers by requiring formal specifications before execution. This separates serious deployment from experimentation.
Write specs first, let AI execute second.
AI companies are building proprietary networking protocols to control large-scale training and inference infrastructure. This creates new lock-in mechanisms beyond model weights.
Control the pipes, control the AI.
Voice AI is moving from stilted turn-taking to natural conversation flow. This shifts AI from a tool you operate to a participant you converse with.
Expect voice to become the default interface for AI agents, not text chat with audio bolted on.
Push notifications for AI jobs turn models from batch processors into always-on services. This transforms AI from a tool you visit to a service that reaches you.
Prepare for AI-driven notification fatigue as every model tries to grab your attention.
Model interpretability is shifting from academic exercise to operational necessity. Companies need to understand what their AI systems are doing, not just whether they work.
Expect interpretability tools to become as standard as monitoring dashboards in production AI systems.
The AI training pipeline is splitting into haves and have-nots based on data quality. Clean data is becoming the new competitive moat.
Budget for data cleaning and curation like you budget for compute, because that's what determines model quality now.
Models that process time-based data natively aren't just better at audio and video. They represent a fundamental shift in how AI understands sequential information.
Expect temporal reasoning to become standard across all model architectures, not just audio specialists.
When AI startups get billion-dollar valuations before solving basic engineering problems, investment becomes speculation rather than technology assessment.
Prepare for a correction when market expectations meet production realities.
Teaching smaller models to mimic larger ones is becoming the default path from research to production. This isn't just optimisation, it's how AI knowledge transfers.
Expect most deployed models to be distilled versions, not the original research breakthroughs.
Cloud-based AI agents are making local development environments obsolete. Remote execution is becoming the default for agent deployment.
Prepare for development workflows that assume agents live in the cloud, not on your machine.
Major AI companies are shipping open-source privacy tools as protection becomes essential for deployment. Privacy is shifting from afterthought to core infrastructure.
Build privacy protection into AI workflows from the start, not as a retrofit.
When AI models hit 70% on complex coding benchmarks like SWE-bench, we're crossing from helpful assistants to primary developers. The gap between AI capability and human necessity in software engineering just collapsed.
Prepare for software teams to flip from AI-assisted to human-assisted development cycles.
Anthropic heading for a £900B valuation whilst big tech drops £725B on AI infrastructure signals AI companies reaching nation-state scale economics. This isn't venture capital anymore, it's geopolitical infrastructure investment.
Expect AI development to follow sovereign investment patterns rather than traditional tech funding cycles.
When AI agents trade and interact with each other at scale, economic inefficiencies become software bugs we can identify and patch. Markets become programmable systems rather than natural forces.
Prepare for economic policy to start looking more like software engineering than traditional regulation.
Failed tests and error logs contain information about edge cases and real-world complexity that clean datasets miss. This data is suddenly more valuable than the working code.
Start treating your debug infrastructure as a strategic data asset, not just operational overhead.
GLM-5.1 (Z.AI) ships as a 754B open-weight agentic model that hits SOTA on SWE-Bench Pro and sustains 8-hour autonomous execution at roughly a third of frontier API cost. Three distinct moats collapse into one release: open weights, frontier capability, agentic competence. Direct continuation of the DeepSeek-R1 thread from January.
If your stack still routes reasoning through a paid API by default, the math has changed. Self-hosted frontier reasoning is no longer a research curiosity.
Three independent launches in three days, each targeting a different layer of the agent production stack: BotCTL (process management, billed as systemd for agents), OnCell.ai (per-user isolation), Relvy (automated on-call runbooks, YC F24). These are problems that only matter once agents are actually being deployed in production, which means agents are actually being deployed in production.
Building on agents in production now means picking from a real toolkit, not duct-taping cron jobs and shell scripts. The stack is shipping faster than the frameworks.
AgentDM (agent-to-agent over MCP and A2A), QVeris (10k capabilities discoverable via one protocol), Postagent (Postman-style CLI for agents), and ZeroID (OIDF-based agent identity) all landed within two days. The pattern is the same shape MCP started in late 2024. Agent infrastructure stops being framework wars and starts being shared plumbing.
If you are picking an agent framework today, prefer the ones that compose over the protocol layer (MCP, A2A) rather than locking you into a single vendor's tool surface.
OSGym ships infrastructure to manage 1,000+ OS replicas at $0.23 per day for computer-use agent research. That is not a product launch, it is a capability. Parallel rollouts on real operating systems become economically viable. Astropad Workbench and TUI-use round out the pattern: agents need bodies, and the bodies are computers.
Computer-use agents are about to be cheap to train. If your product touches workflows that humans currently do in a browser or terminal, expect competitive pressure within six months.
Four launches in five days defaulting to local-first inference rather than cloud: Google's offline AI dictation app on iOS using Gemma, Imbue's Bouncer (on-device LLM for Twitter feed control), QVAC SDK (universal JS for local AI), and Meta's EUPE (sub-100M-parameter vision encoder family). Notable that Google itself is shipping offline-first using its own models. That is the shift, not any single launch.
The economics are flipping. Default to local for new launches unless you have a specific reason to go cloud-first. Users increasingly notice the difference.
Meta Superintelligence Lab released Muse Spark, a multimodal reasoning model with thought compression and parallel agents. Frontend-VisualQA (Yutori AI) gave coding agents visual verification of their own UI work. EUPE shows compact vision encoders can rival specialists. Multimodal reasoning is no longer a frontier-lab talking point. It is becoming a baseline capability across the stack.
Vision is no longer a separate capability you bolt onto a model. Plan for it as a baseline assumption when designing agent workflows.
Within 18 months, sandboxing, approval gates and audit logs will be standard features in serious agent platforms. Tool-connected agents turn prompt injection from a content problem into an operational-security problem.
Within 12 months, AI agents will produce most greenfield boilerplate, test scaffolding and straightforward refactors in fast-moving software teams. The capability is already good enough for bounded software work, while the hard part remains review, architecture and production judgement.
Within 24 months, more jurisdictions and platforms will enforce synthetic-media labelling or provenance rules than will settle training-data licensing rules. Transparency is easier to operationalise than copyright economics.
Within 18 months, at least one open-weight reasoning model will sit within striking distance of the best closed APIs on public reasoning and coding evals at materially lower cost. The DeepSeek-R1 to Gemma 4 arc suggests the open curve is steepening faster than frontier labs can preserve a clean capability moat.
By April 2027, most serious enterprise agent stacks will expose tools and data through an MCP/A2A-style protocol layer rather than mostly bespoke connectors. Once agents need many tools, shared plumbing becomes cheaper and more governable than custom glue.
Within 12 months, browser and desktop agents will stick in a small set of repetitive back-office workflows but remain too brittle for broad consumer autopilot. The capability curve is real, but permissions, exception handling and reliability are still improving slower than the demos.
Within 24 months, most large enterprises will run at least three model families in production rather than standardise on one provider. Bedrock, Vertex and Azure are all training buyers to purchase optionality instead of allegiance.
Within 12 months, assistant retention will depend more on memory, projects and connectors than on small differences in base-model quality. Once models are all good enough, continuity starts to matter more than eloquence.
By 2028, AI regulation will still be regionally split, with the EU more rule-heavy, the UK lighter-touch, and no clean global settlement on copyright or frontier-model duties. The compliance machinery is diverging faster than international consensus is forming.
By 2028, AI-driven robots will create clearer economic value in warehouses, factories and structured commercial settings than in ordinary homes. Manipulation is improving quickly, but the home is still the messiest possible deployment environment.
By late 2027, planning, shopping and research queries will more often begin in assistant-style surfaces than in a blank search box for power users. Search is already absorbing reasoning, follow-up dialogue, personal context and agentic steps.
Within 18 months, AI video will be routine for pitches, previs, explainers and ad variants but not a clean substitute for premium live-action production. The tools are improving fast, but taste, control, rights and production workflows still matter.
Within 24 months, schools and employers will rely more on supervised, oral and process-based assessment because AI tutoring is easier to absorb than AI credentialing. Teaching is easier to displace than trusted signalling.
Within 24 months, many privacy-sensitive or offline AI features in mainstream apps will default to local inference, with cloud models reserved for heavier reasoning. The model-size curve is falling fast enough that latency, privacy and cost can outweigh raw frontier quality.
Within 18 months, non-engineers in medium and large firms will ship useful internal tools through conversational builders and agentic IDEs. The interface to software is getting easier faster than organisations can redesign review, integration and security.
Systems matching or exceeding human performance across most cognitive tasks, including ones outside their training distribution, without task-specific retraining. See debate →
AI systems that autonomously execute multi-step knowledge work across tools, queues and approval boundaries, owning outcomes end-to-end rather than assisting a human operator.
General-purpose physical robots (humanoid or otherwise) that are commercially routine, not demo-quality, with fleet-deployable reliability and workable unit economics.
Coding agents reliably owning the loop from ticket to monitored production deploy across large codebases, leaving humans mostly specifying, reviewing and steering.
AI tutoring and assessment displacing institutional course and credential delivery as the primary structure through which people learn and signal mastery.
The pattern is no longer “open follows years later”; it is “open absorbs frontier ideas fast enough to matter commercially”. Stable Diffusion proved that closed advantages can leak into public ecosystems, LLaMA broke the sense that only a few labs could play, and DeepSeek-R1 showed that open reasoning can arrive with real teeth. If open gets to 90–95% of frontier capability at a fraction of the cost, permanent practical parity is enough to change who wins distribution.
The frontier does not stand still while open catches up. Closed labs still control the best compute, the richest feedback loops, the strongest product distribution and the hardest-to-copy post-training tricks, which lets them keep moving the goalposts from text to multimodal, from answers to agents, and from fluency to reasoning. Open will be formidable in cost-sensitive niches, but the top layer of capability will remain structurally concentrated.
o1 made it plausible that test-time compute is not just extra verbosity but a new way to buy capability on hard tasks. Once models can spend inference budget deliberately, the product question changes from “how fluent is it?” to “how much thinking is this worth?”. That creates a genuinely new optimisation space for models, interfaces and pricing, and it is why reasoning now feels like a separate frontier rather than a mere feature.
A lot of the current reasoning story may be packaging rather than paradigm. Bigger inference budgets, hidden chain-of-thought and better scaffolding can lift benchmark scores without solving the messy problems users actually care about, such as reliability, context management and action in the real world. If the gains are costly, slow and narrow, “reasoning” could turn out to be an expensive wrapper around familiar techniques.
Routine, high-frequency AI use wants low latency, predictable cost and privacy by default. Once a model is good enough to summarise, transcribe, draft, organise and personalise locally, shipping every interaction to the cloud starts to look like a design relic rather than a necessity. Cloud will still do the heavy lifting, but local could become the default surface most people touch first.
The average user will not choose local over cloud on principle; they will choose whatever works best. The strongest models, freshest world knowledge, richest tool access and fastest product-improvement cycles are still cloud-shaped advantages, and platform owners have economic reasons to keep the smart layer centralised. Local will grow quickly, but mostly as a complement to cloud rather than its replacement.
When a field starts inventing shared protocols, permission layers, eval harnesses and operational controls, that usually means the pattern is becoming real. Agents that touch tools, data and workflows need governable plumbing, and that need does not disappear even if today’s demos are messy. The category may still be early, but the infrastructure demand looks structural rather than faddish.
Every platform shift produces a premature standards rush before anyone knows what the durable primitive actually is. Many so-called agent frameworks are still thin wrappers around brittle model calls, and the winning abstractions may end up bundled into the major model platforms instead of living as an independent layer. What looks like category formation could still be the noisy middle stage before consolidation.
Vibe coding lowers the hardest barrier for many would-be builders: getting from intent to working software. That means domain experts can finally ship internal tools without having to become full-time engineers, which is how real capability usually spreads inside organisations. If guardrails improve, the organisational effect could look less like chaos and more like the spreadsheet moment for software creation.
Most software cost arrives after the prototype: security, integrations, ownership, maintenance and change control. Vibe coding widens the front door, but it also makes it easier to generate brittle systems that create hidden review and governance debt. In companies, that may mean more shadow IT and more QA burden rather than a clean productivity windfall.
The useful definition is economic: a system is AGI when it can reliably perform most paid knowledge work at human level or better, across domains, without task-specific retraining. This framing is measurable, matters commercially and treats “general” as a threshold of breadth rather than a philosophical claim about understanding. Reasoning models plus tool use already point at this definition, even if the threshold is years away.
The economic definition smuggles in a philosophical claim and hides the hard part. Genuine general intelligence arguably requires durable goals, embodied experience, robust world-modelling and cross-domain transfer that current systems do not have even when they score well on benchmarks. A system that passes every exam and still cannot run a small business on its own is not general; it is a very capable text engine. The label matters because it shapes policy, investment and safety expectations.
Andrej Karpathy named a new way of building software by talking to AI and steering outputs conversationally. It marked the moment coding started to feel like directing and taste-making, not just writing syntax.
DeepSeek released an open reasoning model it said was on par with o1, with open weights and MIT licensing. It reset expectations on open models, reasoning economics and who could shape the frontier.
Google's Gemini 2.0 launch foregrounded agentic capability — multimodal reasoning, tool use, and long-running task execution — as the explicit framing for what the next generation of frontier models would compete on.
Anthropic open-sourced MCP, a standard for connecting AI assistants to tools and data. It gave the agent era shared plumbing instead of endless bespoke integrations.
Models began visibly spending more effort on reasoning before answering. It marked the move from fluent prediction to deliberate reasoning as the next frontier.
OpenAI's GPT-4o unified text, audio and vision in a single model with conversational latency. It moved the assistant interface from turn-by-turn typing toward real-time spoken interaction across modalities.
Anthropic's Claude 3 made the frontier model race feel genuinely multi-player. It ended the idea that one lab would automatically own the assistant layer.
OpenAI previewed a video model with unusually coherent scene generation. It made world-simulation feel plausible rather than gimmicky.
Eliezer Yudkowsky's intervention helped push existential-risk arguments into mainstream debate. It split the story of AI into two tracks, capability acceleration and safety confrontation.
OpenAI released a much stronger model with a visible jump in capability. It moved AI from novelty to serious knowledge work, coding and professional use.
Meta's LLaMA escaped into the wider world and sparked rapid open model work. It broke the feeling that only a few labs could seriously participate.
A conversational interface put frontier AI in front of ordinary people. It turned AI from a sector story into a civilisation story almost overnight.
OpenAI released Whisper as open-weight automatic speech recognition matching commercial systems on many languages. It seeded a wave of locally-runnable transcription that did not need to call a cloud API.
Powerful image generation became openly available on ordinary hardware. It started the open model era in public consciousness.
OpenAI showed that human feedback could make models more useful and aligned. It changed the winning formula from just training bigger models to training and then aligning them.
DeepMind solved protein structure prediction at near-experimental quality. It showed AI was not just a media tool but a scientific instrument.
AI coding help moved into everyday developer workflow. It turned software creation into one of the first mass human-plus-AI production loops.
OpenAI showed text-to-image generation as a general capability. It opened the public imagination to generative AI beyond text.
OpenAI showed a giant language model that could do many tasks from prompting alone. It shifted the field towards general-purpose foundation models instead of narrow task systems.
Attention Is All You Need introduced the transformer architecture. It became the core design behind modern language models and much of generative AI.
DeepMind's system beat one of the world's best Go players. It broke the assumption that intuition-heavy human domains were still safe from machines.
horizon: land 2 Now entries from #174 with corrected evidence refs
bot(horizon): propose 2 Now entries
Filter the map by what you actually care about. Picked themes sync to the URL, so you can bookmark or share a slice.
The horizon map runs on the same pipeline as the rest of the site. The bots propose, we decide. See how it works.