Is AGI Here? A Sober Look at GPT-4 and Friends

No. AGI is not here. Not even close.

Now that that's out of the way, we can have a real conversation. The hype around models like GPT-4, Claude 3, and Gemini has created a fog of war. Some people see "sparks of AGI," while others see a glorified auto-complete. The truth is somewhere in the messy middle, and for developers, understanding that middle ground is where the real work gets done.

AGI, or Artificial General Intelligence, isn't just about being good at a lot of tasks. Your laptop is good at a lot of tasks. AGI implies autonomy, self-directed learning, and a robust model of the world. It should be able to set its own goals to solve a novel, complex problem. It should know what it doesn't know. It should, for lack of a better word, understand.

Today's models don't.

The Illusion of Intelligence

Let's be fair: what current foundation models can do is genuinely incredible. A decade ago, this was science fiction. You can give a model a blurry photo of a whiteboard sketch and get back clean, functional React code. They can pass the bar exam, score highly on AP tests, and write a sonnet about your dog in the style of Shakespeare.

This is the illusion. Because the model has ingested a vast portion of the internet, it has seen the bar exam (or questions like it) before. It's seen millions of lines of React code. It's seen every Shakespeare sonnet ever written. It's an unbelievably powerful pattern-matching machine, interpolating between billions of data points to give you the most statistically probable answer.

When the task falls within its training data distribution, the results are stunning. For example, asking it to write a Python script for a common task like scraping a website works flawlessly because it's seen thousands of examples.

# Prompt: Write a simple python script to scrape the title of the SuperThinking blog.

import requests
from bs4 import BeautifulSoup

URL = "https://superthinking.ai/"

try:
    response = requests.get(URL)
    response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)

    soup = BeautifulSoup(response.content, 'html.parser')
    
    # The title tag is a good, standard place to find the page title
    title = soup.find('title').get_text()
    
    print(f"The title of the page is: {title}")

except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

The model produces clean, correct code. It even includes error handling. This feels like intelligence. But it's really just a high-fidelity echo of the knowledge it was trained on.

Where It All Falls Apart

The trouble starts when you ask the model to step outside the patterns. This is where the lack of a true world model becomes painfully obvious. The reasoning is brittle.

Here are the classic failure modes:

• Simple Logic: You can still stump the most advanced models with grade-school logic puzzles. Ask it something like: "I have two coins totaling 55 cents. One of them is not a nickel. What are the coins?" It will often get confused, because the answer (a 50-cent piece and a nickel) requires it to understand that the other coin can be a nickel. It processes the negation token "not a nickel" and applies it too broadly.
• Physical Reasoning: Ask a model to tell you how to get a wolf, a sheep, and a cabbage across a river with a small boat. It knows the riddle because it's famous, so it will give you the right answer. But give it a slightly novel variation—maybe the boat can hold two items but the wolf is afraid of water—and it falls apart. It can't reason from first principles about the physical constraints.
• Planning and Self-Correction: Chain-of-thought and agentic frameworks are clever scaffolds we've built to force models to "think step-by-step." But the model itself doesn't know when its plan is bad. It can't look at its own output, recognize a fundamental flaw in its strategy, and decide to start over from a different angle. It just plows ahead, executing a flawed plan with perfect confidence.

This isn't a knock on the technology. A tool that can instantly access and synthesize nearly all human knowledge is a miracle. But a tool is not a mind. It doesn't know anything. It's a calculator for words.

Building for a Smart, Stupid Tool

So what's the takeaway for those of us building with this stuff? Stop waiting for AGI. The interesting work is in designing systems that leverage the model's strengths while aggressively guarding against its weaknesses.

This is the entire philosophy behind Retrieval-Augmented Generation (RAG). We don't trust the model's internal, parametric memory. Instead, we fetch real, up-to-date information from a trusted source and stuff it into the context window, forcing the model to work with known facts. We're not asking it to know, we're asking it to summarize.

Agentic workflows are similar. We use the LLM to generate a plan (e.g., a sequence of API calls) but we, the developers, are the ones who define the tools, validate the outputs, and create the feedback loops. The LLM isn't the autonomous agent; it's the reasoning engine inside a state machine that we design and control.

You are the AGI. The model is your brilliant, erratic, and deeply unreliable intern. It can draft amazing things, but you'd never let it ship to production without a thorough review. Your job is to design the system of reviews.

Stop asking if the model is intelligent. Start building systems that assume it isn't.