AGI: Artificial General Intelligence, Precisely
AGI is not a brand name for whatever is impressive this year. It is a precise idea, and the interesting part for a student is designing the test that would show whether a system has it.
The definition, and why general carries all the weight
Artificial general intelligence is a system that can perform any cognitive task a human being can, and can take what it learned in one task and apply it to a different one without being retrained for that task. Both halves matter. A system that is brilliant at one bounded domain is not general, it is specialised, however good it is at that domain.
The term itself was coined by Marvin Minsky in 1967 and has been argued over ever since. The honest summary is that no AGI has been demonstrated. No system has been shown to carry a skill from one domain into an unrelated one as generally and as reliably as a person does, and nobody has produced a test that everyone agrees on, which is itself part of the problem.
What makes generality the hard part
Current systems are narrow in a specific way: they are excellent inside a well-defined task and brittle just outside it. A model that writes good code has no idea how to test a physical robot, and a model that reads a sensor log cannot decide what to do with the reading unless it is told the shape of the decision in advance.
Two problems block the obvious path. The first is verification: to improve at a task you need a way to check the output, and checking is easy in arithmetic and very hard in open-ended work. The second is embodiment: a person learns from a lifetime of physical interaction, and no one has built a system that learns that way at all. Both are research problems, and neither is solved by a faster chip on its own.
Step by step
-
Write the definition so it could be tested
If your definition cannot be turned into an experiment, it is a slogan. General has to mean something you could check on a task nobody designed it for.
-
Test a current system on a narrow task
Give it the sort of task it was built for and watch it succeed. Every one of them does something like this well, which is exactly why narrow is hard to notice from inside.
-
Test the same system on a task from another domain
No retraining and no examples from the new domain. Watch where it stops. The gap between these two results is the whole subject.
-
Look at how benchmarks get broken
Any narrow measure becomes a target, and a system that optimises the measure stops doing the task. This is Goodhart's law, and it is why passing a benchmark is not the same as being able to do the job.
-
Write your own definition and its test
Two students will write different definitions, and defending yours in a viva is the actual assessment. Being able to say what evidence would change your mind is the skill worth marking.
-
Map it onto a robot you can build
Ask which parts of your bot's task are general. A line follower is narrow. A robot that finds an unfamiliar object and adapts its approach is closer, and you can test that on a table.
What you'll need
| Item | Qty | Why |
|---|---|---|
| Arduino Uno R3 | 1 | Runs the narrow, repeatable part of any robot task, which is the part that has to work every single time. |
| HC-SR04 ultrasonic sensor | 1 | Provides the raw observation for a task you design yourself, rather than a task somebody else scripted. |
| SG90 micro servo | 1 | Acts on a decision, so you can measure whether a policy generalises or has simply memorised one case. |
| LED bar graph module | 1 | Shows the state of the task, so a transfer test is visible rather than something you argue about afterwards. |
| Pushbutton | 2 | Two buttons give you a two-choice task, which is the simplest possible generalisation test you can build. |
| Buzzer module | 1 | Marks the outcome of each trial so you can log a score for every run and plot it later. |
Practise it before you build it
Every step above has a matching circuit in the ThinkEdge Learn simulator. The simulator runs a real
Arduino sketch against a modified-nodal-analysis solver, so digitalWrite actually drives the
LED on screen and the readings change when you change the wiring — no hardware, no burnt components.
Simon Says is a classic memory game: the Arduino blinks a sequence of LED colors, and the player must repeat the sequence by pressing the corresponding buttons. Each round adds one more color. The game tracks the current level and ends when the player makes a mistake. This project teaches arrays, random numbers, and state machines.
A real reaction-timer game: an LED lights up after a random delay, and you have to press a button as fast as possible. The Nano measures the time between the LED turning on and the button being pressed, then prints the result in milliseconds. This is the kind of small project the Nano was made for — fits on a single breadboard, perfect for school science fairs.
A two-player reaction game: an LED goes off after a random 1-4 second delay, and the first player to press their button wins. The winner's LED lights up and the loser's LED stays off. A buzzer chirps on each press. The trick is to use millis() for non-blocking timing so the button check is responsive.
A real traffic light runs a state machine: GREEN (cars go) → YELLOW (slow down) → RED (cars stop) → PEDESTRIAN WALK (cross the road) → RED → GREEN. The Mega has enough pins to build a full intersection: 3 LEDs for cars in one direction, 3 LEDs for cars in the other, 2 LEDs for the pedestrian signal, and a button to request to cross. Use millis() for non-blocking timing so the button check is responsive.
A 10-segment LED bar graph is the easiest way to visualize an analog input: spin a potentiometer and 1, 2, 3 ... 10 LEDs light up in sequence. This is a "VU meter" — the kind you see on stereo equipment. The Mega is ideal because it has 10 free digital pins without stealing any from the analog or serial pins. The same code can be extended to 20, 30, or 100 LEDs on a Mega.
Mount an HC-SR04 ultrasonic sensor on top of a servo. Sweep the servo from 0° to 180° and back, and at each step measure the distance. Print the results to the Serial Monitor as "angle,distance" pairs. Open the Serial Plotter in the Arduino IDE to see a live radar-like graph of the room. With Processing on your computer, you can build a full visual radar.
Common questions
Does AGI exist yet?
No. No system has been demonstrated to handle any cognitive task a human can, with the ability to transfer what it learned into an unrelated task. What exists is a set of impressive narrow systems, each of which fails in a way that is easy to demonstrate once you know where to look.
When will AGI arrive?
Nobody knows, and the honest answer is that any confident date is a guess dressed as a fact. Predictions have been made for decades and have been wrong every time, which is useful evidence in itself: treat a confident prediction as a reason to check the reasoning, not as a schedule. For a classroom project the interesting question is what evidence would count as progress, not when it arrives.
How is AGI different from a chatbot?
Breadth and transfer. A chatbot is usually excellent at one kind of conversation and has no way to carry a lesson from one situation into another. AGI would mean a system that can start on a task it was never trained for, work out what is being asked, and improve from feedback. That last part, improving from feedback, is the part that is still genuinely open.
Related guides
Try the full simulator with your class
103 guided circuit projects, 21 lessons and an in-browser Arduino simulator. The first 15 projects are free, no account needed. NCERT Science mapping on 47 projects, with Arabic and English copy in the regional builds.