Are LLMs the Final Form of Artificial Intelligence?

Language is cheap. outcomes are expensive. Words, images and video now pour out on demand, like water from a tap. LLMs are an impressive language cortexbut intelligence needs the rest of the nervous system: memory, senses, tools, a world-model, and the ability to act.

If you want outcomes (not just output), wrap specialised LLMs in a stack that can plan, use tools, remember, verify, and take action. That’s how you get personalised, proactive agentic systems.

TL;DR

• LLMs are brilliant with words: fast, helpful, increasingly competent.
• But real intelligence needs more than fluent sentences or flashy media.
• To deliver outcomes, wrap your selected AI model(s) with four pieces: memory, tools, a world model, and the ability to act.
• We’re headed toward agentic systems that plan, call tools/APIs, verify, learn from experience, and act across software - and eventually the physical world.

The AI Agent Stack

LLMs already excel at explaining, translating, and generating code. They improve with longer context, better grounding, multi-step planning, and multimodal inputs. The real unlock is architecture: make your model goal-driven inside a modular stack with clear guardrails. Here is a simplified version of the entire stack:

1. Modular Planner/Reasoner (Swappable): plan → act → reflect loop. Treat it like a chip you can upgrade.
2. Memory (RAG & Logs): retrieval for truth and continuity. Prevents amnesia and hallucinations.
3. Tools (via MCP): All connected through a standard like Model Context Protocol (think USB for AI), resulting in the need for limited custom implementation.
4. Evaluator/Verifier: Rubrics, tests, and Chain-of-Verification to check their work, catch any nonsense and reduce hallucinations before it ships.
5. Actuators: Software APIs today (Email, Google Docs or CMS)… robots tomorrow. Measuring tool-call success and rollback rates.

Key principle: Bigger models help, but we’re hitting diminishing returns. Architecture perpetually compounds.

4 Key Pieces of the Agentic Stack

There are 4 key components that enhance LLMs' ability to deliver expected outcomes:

Why LLMs Are NOT the Destination

1) Scaling helped; structure helps more

Bigger models lowered loss, but the biggest reasoning jumps came from how we use them. Chain-of-Thought, test-time self-consistency, and modern context architecture that retrieves the right facts at the right time. Architecture and skill beat raw size.

2) Reasoning needs loops, not monologues.

When the model can think → use a tool → think again (the ReAct pattern), accuracy rises and hallucinations fall.

3) Multimodal specialists beat generalists

DeepMind’s AlphaGeometry2 combines learning with symbolic proof search, and it now performs at IMO gold‑medal level on geometry problems. This is an example where hybrid multi-modal systems outpace generic text‑only models on tough reasoning tasks.

4) Embodiment is coming.

RT‑2 style Vision-Language-Action models also learn from web + robot data to turn instructions into robotic actions. Meanwhile, Meta’s V‑JEPA 2 pushes video-trained world models so agents can predict and plan in the physical world. Text alone can’t do that.

5) Even leaders are saying it out loud.

The mood has shifted: scaling alone won’t get us to robust intelligence. Meta’s Yann LeCun has been explicit about the limits of “just make it bigger” and the need for richer world models and interaction. Essentially, the biggest bottleneck is world-modelling and interaction.

Change Your Approach

Stop thinking prompt → answer. Start thinking goal → plan → tools → results.

An example - Simplified Content Creation Workflow for Monthly Evergreen Content: You need next month’s content pack tailored per channel, on-brand, varied, and scheduled.

1. Plan: The agent begins the workflow (topics → drafts → assets → review).
2. Tools: Use of appropriate tools to complete the task, from web/search for facts and dates to image or video generation during the execution phase.
3. Memory: Pull brand guidelines, product pages, and recent announcements via connectors (MCP, app APIs)
4. Evaluator. Style guide checks + Chain-of-Verification pass before publishing.
5. Act. Creates assets in your CMS, schedules in your social tool, and emails the KOL list.

Pilot snapshot (illustrative):

• Inputs: 12 source docs, brand guide, 3 tools (Sheets, CMS, Email)
• Process: 37 plan/act/reflect cycles,
• 18 tool calls,
• 4 auto-caught verification failures
• Outputs: 22 ready-to-ship assets, calendar populated, 7 emails queued
• Metrics: 98.2% factuality (pre-pub checks), £38/asset all-in (vs £110 baseline), 0 escalations

Result: a calendar + ready-to-ship assets, not a pile of drafts or AI slop.

7 Low Drama, High ROI Tips & Tricks to Ship an Agentic Stack ASAP

1. Wrap your model in a tiny kernel: Expose three verbs: plan(), act(), reflect(). Use ReAct so the agent can think → tool → think.
2. Add retrieval for truth and require citations: Put your docs and trusted web snapshots in a vector index. Force sources in outputs. That keeps knowledge fresh without retraining and makes results auditable (RAG).
3. Spend a little compute, buy a lot of quality: Use Chain-of-Thought on tricky tasks, then self-consistency to select the consensus. Enable it on important work; skip it for quick tasks.
4. Log outcomes, not vibes: Track task success, factuality rate, tool-call success, and £/deliverable. If a new reasoning model beats your baseline on these, swap it in. The rest of your stack stays stable.
5. Standardise tool access with MCP: Treat tools like plug-and-play peripherals. MCP is the clean way to attach CRMs, data stores, analytics, and custom APIs to whichever reasoner you’re running.
6. Cache & trace: Response caching + execution traces accelerate evals and debugging (making it cheaper!).
7. Guardrails: Schemas, safe tool scopes, and recovery paths; measure policy-block and recovery rates.

Metrics that matter

• Task Success Rate (TSR): completed goals / assigned goals
• Factuality Rate: verified-correct claims / total claims
• Tool-Call Success: successful tool responses / tool calls
• Autonomy Ratio: agent actions without human intervention / total actions
• Verification Coverage: outputs audited by COV / total outputs
• £/Deliverable: (model + tooling + review time) / approved outputs

Rule: Swap the reasoner when it moves these numbers.

Final Thoughts

Build systems that plan, remember, use tools, verify, and act. Keep the reasoner/AI model swappable. That’s how you protect margin today and stay ready for whatever replaces LLMs tomorrow.

Original portfolio artwork +