Is AGI Here? A Reality Check on GPT-4 and Friends

The question is everywhere: have we achieved Artificial General Intelligence? Every time a new model drops, like GPT-4o or Claude 3, the claims get louder. Some researchers see “sparks of AGI,” while others see a dead end.

Let’s cut through it. The answer is no. Not even close. And I can show you why.

AGI isn’t just about being really, really good at a lot of tasks. AGI, in practical terms, means being able to reason, plan, and learn in novel situations, just like a person. It’s about transferring knowledge from one domain to another without being explicitly trained on it. Today's models don't do that. They do something else.

They're incredible pattern-matching engines. Think of them less as a nascent brain and more as a system of interconnected, specialized skills that can be called upon with text. This is a powerful tool, but it's not a general intelligence.

Where The Magic Happens: Spikes of Superhuman Skill

Don't get me wrong, what these models can do is genuinely astonishing. If you treat them as expert systems, they perform tasks that feel like magic. Their 'spikiness'—being superhuman at some things and useless at others—is their defining trait.

Take code generation. Ask Claude 3 Opus to build a simple React component for a to-do list app, and it will spit out clean, functional JSX in seconds. It can even add styling with Tailwind CSS and include comments explaining its logic. This would take a junior developer 20 minutes, and a senior developer would still need a few minutes to type it out.

// A prompt like: "Create a simple React todo list component using hooks. Users should be able to add and remove items."

import React, { useState } from 'react';

const TodoList = () => {
  const [items, setItems] = useState([]);
  const [inputValue, setInputValue] = useState('');

  const handleAddItem = () => {
    if (inputValue.trim()) {
      setItems([...items, inputValue.trim()]);
      setInputValue('');
    }
  };

  const handleRemoveItem = (indexToRemove) => {
    setItems(items.filter((_, index) => index !== indexToRemove));
  };

  return (
    <div>
      <input
        type="text"
        value={inputValue}
        onChange={(e) => setInputValue(e.target.value)}
      />
      <button onClick={handleAddItem}>Add Item</button>
      <ul>
        {items.map((item, index) => (
          <li key={index}>
            {item} <button onClick={() => handleRemoveItem(index)}>Remove</button>
          </li>
        ))}
      </ul>
    </div>
  );
};

export default TodoList;

They are also masters of translation and summarization. You can drop a 10,000-word academic paper on quantum computing into a model and ask for a five-bullet-point summary for a fifth-grader. The result is usually coherent, accurate, and incredibly useful. This is a skill that few humans possess.

These are not small feats. They are accelerants for anyone who works with information. But they are sophisticated mimicry, not understanding.

The Cracks in the Facade

The illusion of intelligence shatters when you poke at the edges. Models lack a persistent world model, common sense, and the ability to plan more than one or two steps ahead. They predict the next most likely word; they don't reason from first principles.

Give a model a classic logic puzzle. For example: "There are three boxes, one labeled 'Apples', one 'Oranges', and one 'Apples and Oranges'. Every box is mislabeled. You can pick one fruit from one box to figure out the correct labels. Which box do you pick from?"

Most models get this wrong on the first try. They might suggest picking from 'Apples' or get confused by the logic. The correct answer is to pick from the box labeled 'Apples and Oranges'. Since you know it's mislabeled, whatever fruit you pull out is the only fruit in that box. If you pull an apple, that's the apple box. From there, you can deduce the rest. This requires a chain of reasoning that models struggle with because they can't 'hold' the state of the world in their head and manipulate it.

Physical reasoning is another huge blind spot. Ask a model, "If I have a bowling ball and a feather in a bag, and I drop the bag, which hits the ground first?" Many will start talking about vacuums and air resistance, missing the obvious point: they're in a bag. They hit the ground at the same time. The model doesn't understand the container, only the abstract concepts of 'bowling ball' and 'feather'.

This lack of a real-world anchor is their fundamental limitation. They have read every book, but they have never been in a room.

So, What Are We Actually Building?

If it's not AGI, what is it? It's a universal information processor. A tool that manipulates and generates text, code, and images based on statistical patterns from its training data. It’s an incredibly powerful prosthetic for the mind, but it’s not a mind itself.

The danger in using the AGI label is that it sets the wrong expectations. It makes us think we can trust these systems with ambiguous, high-stakes tasks that require genuine judgment. We can't. Not yet.

When we treat models like GPT-4 as what they are—incredibly powerful but flawed, non-sentient tools—we can use them more effectively. We can lean into their strengths for drafting, brainstorming, and coding assistance, while remaining vigilant for their nonsensical failures in logic and reasoning.

Forget the AGI hype. Focus on what's real: we have a new class of computational tool that is changing how we work with information. That's a big enough deal on its own.