VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

How Super Intelligence Works | The Whole Stack — From Human Intent to Machine Action

Three students work together at a classroom table, reviewing open textbooks and notes.

The Super Intelligence stack is the connected system that turns a human request into a machine-generated answer or an authorised action. Understanding how Super Intelligence works means understanding AI models, training, context, retrieval, memory, tools, evaluation and the controls surrounding them—not only the chatbot on the screen.

A clearer understanding begins with a small change in perspective. Instead of asking only which model is answering, ask what information reached it, what it was allowed to use, and how anybody will know whether its work is correct.

This first-principles guide explains the complete SI system for students, parents, teachers, professionals and beginning builders. It connects the familiar language of artificial intelligence, large language models and AI agents to an everyday question: what has to work underneath a useful answer?

Terminology: eduKateSG uses “Super Intelligence”, or SI, as this series’ umbrella name for AI technologies. This is an editorial convention, not a claim that the systems discussed possess artificial superintelligence. We retain conventional technical terms such as AI, machine learning, LLM, AGI and ASI when explaining research.

Start with a simple working picture: a person sets a task; an application assembles information; a model performs computation; other software may retrieve evidence or execute a permitted operation; and the result must be checked. The exact arrangement differs between products. Not every system needs every component described here.


The Hidden Transition: From an Answering Model to a Working System

Imagine asking for a short explanation of evaporation. Now imagine asking a system to prepare tomorrow’s lesson using an approved textbook chapter, identify three misconceptions, create suitable questions, and save the finished worksheet in the correct folder without sharing student information.

Both requests involve language. The second also involves source selection, document access, instructional choices, file creation and a boundary around private information. A fluent paragraph alone cannot establish that those additional jobs were completed.

This is the important transition. The model contributes useful capabilities, but the application must connect those capabilities to information, operations and evidence. The Stanford report On the Opportunities and Risks of Foundation Models describes foundation models as broadly trained models adaptable to downstream tasks. “Foundation” is a helpful word: a foundation supports a building; it is not the completed building.

The distinction changes how we investigate mistakes. A wrong worksheet may come from an unsuitable model, but it may also come from the wrong chapter, an unreadable diagram, a missing instruction, or an unchecked answer key. Replacing the model is not automatically the appropriate repair.

A Practical Map of the SI Stack

For this guide, we organise the stack into six connected responsibilities: establish the task; obtain and represent information; apply learned capability; connect external knowledge and tools; check the work; and maintain the surrounding service. This is an explanatory map, not a claim that every product contains six separate modules.

The responsibilities can be distributed. One application might combine several inside one service. Another might use different models, a search index, a database and a separate review interface. The important question is whether each required responsibility has a reliable owner, not whether a diagram contains an impressive number of boxes.

In our lesson example, the task owner decides the learning objective. A retrieval component locates approved material. A model drafts explanations. A file tool creates the worksheet. A teacher checks suitability. Storage preserves the approved version. Each contributes something different to the final result.

Notice what is missing from that description: the assumption that intelligence alone automatically supplies correct purpose, correct evidence and correct permission. We must specify those requirements rather than hoping they will emerge from a confident answer.

Human Intent Comes Before Machine Output

“Prepare a useful lesson” sounds clear until two people interpret it differently. One expects a five-minute introduction. Another expects a full worksheet. A third wants assessment questions rather than teaching material. The system needs enough detail to distinguish the intended outcome from these plausible alternatives.

A workable task statement names the audience, the intended result, the permitted materials, the constraints and the stopping point. For example: prepare a one-page explanation for a beginner using the supplied chapter; include two original practice questions; flag anything the chapter does not support; create a draft only.

This is not about finding a secret prompt. It is about reducing uncertainty in the assignment. The teacher should not need to supply every sentence, but the system should not silently choose the learner’s level or replace the approved material with an unrelated source.

A useful test is to imagine giving the same brief to a capable human assistant. Would that person know what completion means? Where would they reasonably ask a question? Those gaps deserve attention before we evaluate the quality of the machine’s response.

Data Is Not Yet a Usable Representation

A textbook page contains more than words. A heading groups ideas. An arrow connects two stages. A label identifies a diagram. A table keeps values beside their units. To use that page, a system must preserve enough of these relationships during processing.

Suppose a table contains “12”, “minutes” and “heating time”. If extraction separates those fragments, the downstream model may receive all the characters but lose their relationship. The problem is not solved by celebrating how many pages were uploaded. The relevant question is whether the information needed for the task survived.

For text-based language models, tokenisation converts text into model-compatible units. Token identifiers are then associated with numerical representations used by the network. Hugging Face’s text-generation documentation shows this practical sequence: prepare model inputs, generate output tokens, and decode them into text.

Do not confuse representation with understanding everything represented. A clear photograph of a difficult question does not guarantee a correct solution. A perfectly extracted paragraph does not guarantee correct interpretation. Representation makes information available; additional computation and checking must still do their jobs.

What the Model Contributes

A neural network uses learned numerical parameters to transform inputs into outputs. Training adjusts those parameters to improve performance against a learning objective. Google’s neural-network learning material explains the roles of hidden layers, activation functions and training in learning patterns beyond a simple linear relationship.

In our worksheet example, the model’s contribution might include interpreting the instruction, selecting a suitable explanation structure, recognising related concepts and generating candidate questions. These are useful capabilities. They do not establish that the model has accessed the teacher’s actual chapter unless that chapter has been supplied or retrieved.

A familiar analogy is a skilled writer entering a room. The writer brings learned language and reasoning abilities. They do not automatically know which document in the cupboard is the current approved edition. The analogy concerns task preparation, not an assertion that neural networks learn or experience the world like humans.

Model capability therefore has to meet task requirements. A system may need excellent image interpretation, careful long-document comparison, structured extraction or reliable tool selection. “More intelligent” is too broad a specification when the actual bottleneck is one of these particular operations.

Training and Runtime Are Different Processes

Training changes a model’s parameters. Runtime inference uses a trained model to process a particular input. A user’s correction can affect the next answer because it becomes part of the available context; that does not, by itself, demonstrate that the underlying model weights changed.

This distinction is visible in the research paper Language Models are Few-Shot Learners, which evaluated tasks supplied through text examples without gradient updates during those task evaluations. Examples in context and parameter training are different mechanisms, even though everyday language may call both “learning”.

Consider telling our worksheet assistant, “Use the word evaporation, not boiling, in that second question.” Three outcomes are possible in a designed system. The correction could remain only in the conversation. It could be saved as an approved editing rule. Or it could enter a separately governed training dataset. These are not interchangeable outcomes.

A responsible explanation asks which mechanism is actually present. We should not tell a learner that every conversation permanently trains the model, nor promise that an instruction will be remembered next month unless the product’s memory and retention behaviour supports that claim.

Context Is the Information Available for This Task

Context is not simply the sentence typed most recently. It may include instructions, selected conversation history, document excerpts, tool descriptions and results from earlier operations. Anthropic’s context-engineering guide treats managing this available information as a separate engineering responsibility.

For the lesson assistant, useful context might contain the chapter, the target concept, the student’s current task and an instruction to avoid revealing the answer before the practice attempt. Unhelpful context might include twenty unrelated worksheets, abandoned drafts and an old instruction for a different age group.

We can understand the design problem without treating context as a mystical resource. Put the right working papers on the desk. Label which version matters. Remove contradictory drafts when they no longer serve the task. Preserve the evidence needed to check the conclusion.

More context is not automatically better task preparation. If a system includes everything indiscriminately, it also includes material that can distract from the intended question. The appropriate amount depends on what the task requires and what the particular model can use reliably.

Retrieval Brings Missing Knowledge Into the Work

Retrieval locates external information needed for a response. In retrieval-augmented generation, retrieved material is combined with a generative model. The original Retrieval-Augmented Generation paper studied a combination of parameter-based knowledge and an external retrieval index for knowledge-intensive tasks.

In a school setting, retrieval could mean finding the approved chapter rather than searching the entire public internet. In a workplace, it could mean finding the current operating procedure rather than relying on a general explanation. The retrieval target follows the task and the user’s access rights.

Imagine two documents with the same title. One is an old draft; the other is the approved edition. A similarity search may find both. The application still needs a way to identify status, date and ownership. Relevance is not the same as authority.

Retrieval should therefore return enough context to judge what was found. A useful evidence record includes the document identity, the relevant passage and its relationship to the question. A pile of links is not equivalent to a supported answer, and a retrieved passage is not automatically true merely because the search system found it.

Memory Preserves Selected Information Across Tasks

For this guide, memory means an application mechanism that stores information and makes it available again later. That is separate from the model’s trained parameters. We also distinguish it from the temporary working context assembled for one inference request.

Our hypothetical lesson system might preserve an approved worksheet, a preference for British English, or a record that a particular explanation was rejected. Each item needs a purpose. Keeping every fragment forever is not a substitute for deciding what future work actually needs.

Suppose a learner struggled with fractions in March but demonstrates independent control in September. A memory saying “weak in fractions” should not become a permanent identity. A better educational record would preserve the observation date, the specific task and subsequent evidence that changes the interpretation.

This is a design principle rather than a claim about any particular product. Memory should help the next task, remain open to correction and respect the information’s owner. It should not silently transform a temporary difficulty into a lasting judgment about a person.

Tools Extend What the System Can Do

A tool is an interface to a capability outside the model’s immediate text generation. A calculator can perform arithmetic. A document service can create a file. A search service can retrieve material. The Model Context Protocol specification describes one standardised way for applications to connect external context and tools.

In the lesson example, writing “I saved the worksheet” is not itself a file operation. The application needs to execute a save through an available interface and inspect the result. It should return the actual document identity rather than inventing a plausible filename or link.

Tool use also changes the kinds of mistakes that matter. A poor paragraph can be revised before use. Saving over the wrong document changes an external resource. Sending that document changes who receives it. These are different consequences and should not share one undifferentiated permission.

A useful tool contract says what operation is available, which inputs it requires, what it may change and what evidence it returns. “Can work with documents” is too vague. “Can create a new draft in this folder, but cannot overwrite or share existing files” is a much clearer boundary.

A Workflow Is Not Automatically an Agent

Anthropic’s Building effective agents distinguishes predefined workflows from systems in which a model directs its own sequence of tool use. This is a useful engineering distinction, even though products use the word “agent” in different ways.

Our worksheet process could follow a fixed route: load the chapter, draft questions, check the answer key, save a draft. That may be sufficient. A more flexible system could decide that a diagram needs another inspection or that an ambiguous instruction requires clarification before drafting.

Neither arrangement wins merely by sounding more autonomous. The fixed route may be easier to inspect. The flexible route may handle unexpected problems better. The decision should follow the actual variation in the work, the cost of errors and the available supervision.

For beginners, the important question is simple: who chooses the next step? If code always chooses it, we are looking at a workflow. If the model chooses among permitted next steps, we have introduced an agentic element that needs corresponding limits and observation.

Verification Is a Separate Responsibility

A generated answer is a candidate result. In our teaching example, we should still check whether the explanation matches the chapter, whether each question is answerable, whether the answer key is correct and whether the learner can reasonably attempt the work.

Different claims need different checks. A quotation needs comparison with the source. An arithmetic result can be recomputed. A saved document needs a read-back. A teaching decision needs an educator’s judgment. Asking the model to say “verified” cannot replace these distinct forms of evidence.

Anthropic’s guide to agent evaluations distinguishes an agent’s recorded activity from the outcome produced in its environment. That distinction is valuable here: a convincing account of saving a worksheet is not the same evidence as the worksheet actually existing in the intended location.

Verification should also be proportional. We do not need an elaborate approval process for choosing a harmless heading. We do need appropriate checks before a system changes records, distributes material or makes a consequential claim that another person may rely upon.

The Physical and Operational Layers Still Matter

The discussion so far concerns information and decisions. A deployed service also needs functioning compute, storage and connections. Google’s material on production machine-learning systems provides a useful next step for understanding the engineering around the model rather than treating training code as the whole application.

Consider a lesson assistant used five minutes before class. An excellent worksheet arriving after the lesson is less useful than an adequate draft available while the teacher can still inspect it. Timeliness belongs in the task definition, not merely in a technical dashboard nobody checks.

Likewise, a save operation that fails because storage is unavailable should not be reported as success. A disconnected search service should not be disguised as completed research. Operational problems need honest status messages and a route to a simpler, still useful output.

For our example, the fallback could be a clearly labelled unsaved draft in the conversation. The teacher can still inspect it. The system has not completed the original task, but it has preserved useful work without pretending that the missing operation occurred.

A Worked Example: Building a Lesson Without Losing the Evidence

The following is an illustrative design exercise, not a report of a measured classroom deployment. A teacher supplies an approved chapter and asks for a short lesson distinguishing evaporation from boiling. The deliverable is a draft worksheet, not an automatically assigned activity.

First, establish what must remain under human control

The teacher decides the learning objective and the learner’s readiness. The assistant may propose explanations and questions, but it may not decide that a student has mastered the topic from one correct response. It may not distribute the worksheet or alter a progress record without separate authorisation.

Next, assemble a small evidence packet

The packet contains the relevant chapter section, the named distinction, the requested length and the draft-only instruction. A diagram remains attached to its labels. Any unclear sentence is flagged rather than silently repaired through invention. The assistant records which source supports the central explanation.

Then, produce and test a candidate

The model drafts a short explanation and two questions. One asks for a distinction; the other presents a new example. A check compares the explanation with the source, attempts the questions using only the supplied information and confirms that the answer key does not require an unstated fact.

Finally, save the right object and return the right status

The file tool creates a new draft with a unique identity. The application reads back its title and content. The teacher receives the real document link, the source used and any unresolved concern. Completion means a reviewable draft exists—not that learning has happened and not that the material is approved for every student.

Every stage now has a clear job. If the worksheet is unsuitable, we can inspect where the failure began. We do not need to describe the whole system as either brilliant or useless. We can repair the part that failed and retest the affected outcome.

Three Ways to Read the Same SI System

A beginner should first follow the information. Where did the source come from? What did the model receive? Which statements are directly supported? This route makes the system understandable without requiring advanced mathematics or programming.

A builder should follow the interfaces. What format enters each component? What happens when a field is missing? Which operation is read-only, and which changes something? A diagram becomes useful when these handoffs are explicit enough to test.

An educator or manager should follow responsibility. Who sets the purpose? Who can approve a change? Who sees a failure? Who maintains the source material? A highly capable model does not answer these organisational questions by itself.

These are complementary routes, not competing levels of intelligence. One person may need all three at different moments. The goal is to make the system’s behaviour inspectable from the position of the person who must use, build or take responsibility for it.

How to Diagnose the First Unstable Point

Start with the visible failure and work backwards. If the wrong document was saved, inspect the target and tool arguments. If the right document contains the wrong answer, inspect the evidence and calculation. If the correct answer addresses the wrong question, inspect the task interpretation.

Suppose the worksheet introduces a topic beyond the learner’s preparation. A larger model may generate even more elaborate material without solving the problem. The missing input may be a clear readiness boundary. Repair the boundary, then test the new draft against it.

Suppose the explanation refers to a diagram the model never received. Rewriting the prompt ten times does not restore the missing diagram. Repair ingestion or provide the relevant visual information. Then check whether the revised response actually uses it correctly.

Suppose the system repeatedly selects an outdated chapter. The repair may belong in document status, retrieval filtering or source ownership. A model upgrade can be useful, but it should not conceal an information-management failure that will recur with the next model.

What Reliable Progress Should Look Like

For the example system, progress would mean fewer unsupported statements, more suitable questions, correct document targeting and clearer escalation when evidence is missing. Those are observable outcomes. A longer answer or a more polished tone is not enough.

Keep a small collection of representative tasks: a clear chapter, an ambiguous diagram, a missing source, a conflicting instruction and a failed save. Repeat them after a meaningful change. Compare the outcomes using the same criteria, rather than selecting the most impressive demonstration.

We should also inspect failure recovery. Does the assistant preserve a useful draft? Does it identify exactly what could not be completed? Does it avoid repeating a destructive operation? Does the human know what decision is required next?

A system that stops appropriately can be more dependable than one that always produces a confident finish. The purpose of the stack is not to remove every pause. It is to ensure that pauses, actions and claims correspond to the evidence and authority actually available.

A Simple Stack Inspection Exercise

Choose one harmless task you understand well, such as summarising a short document you wrote. Before using any system, write down the correct source, the expected output, what must not change and how you would check the result.

Now draw seven boxes on paper: request, input, model, external information, tool, check and result. Mark which boxes the task actually requires. A simple summary may not need an external tool or persistent memory. Leaving those boxes unused is a sensible design choice, not a deficiency.

After the response, label each important statement as supplied, calculated, inferred or unsupported. This exercise often reveals a distinction that polished prose hides: the answer may contain several different kinds of claim, and they do not all deserve the same confidence.

Finally, change one condition. Remove a needed paragraph or provide two versions with different dates. Observe what happens. The purpose is not to trick the system for entertainment. It is to discover which boundary needs to be visible before you rely on the same arrangement for more important work.


The Complete Worked System: Build a Lesson From Source to Checked Draft

The earlier lesson example showed the responsibilities around a model. We can now make the whole Super Intelligence stack concrete by supplying the actual illustrative materials, the intermediate decisions and the final checked output. Nothing in this exercise depends on a hidden product implementation. It is a teaching model that lets us inspect what each layer receives, what it produces and what it cannot establish on its own.

Assume a teacher wants a short Secondary 1 Science practice activity on evaporation and boiling. The learning objective is narrow: students should distinguish the two processes and apply the distinction to an unfamiliar everyday situation. The teacher does not want a full chapter summary. The assistant may prepare a draft, but it may not assign grades, message students or alter any learner record.

Source packet supplied to the system

The approved source packet contains these statements: evaporation happens at the surface of a liquid and can occur below the liquid’s boiling point; boiling happens throughout the liquid when the relevant boiling condition is reached; faster-moving particles can escape from the surface during evaporation; heating can increase the rate of evaporation, but heating a liquid does not mean it is already boiling.

The packet also includes one labelled diagram: a shallow dish with arrows leaving only the upper surface, and a beaker with bubbles throughout the liquid. The teacher adds one instruction: “Use only the supplied science statements for factual claims. You may invent harmless everyday scenarios for the questions, but do not invent a new physical rule.”

This is already more useful than saying “teach evaporation”. The system now has a target, a source boundary, a learner level, a permitted creative freedom and a prohibited action. Those details belong to the task definition, not to the model’s training history.

What the ingestion layer must preserve

The document-processing stage must preserve that “surface” modifies evaporation and “throughout the liquid” modifies boiling. It must also keep the diagram labels attached to the correct image regions. If the text is extracted but the words “surface” and “throughout” are detached from their processes, the later model can receive all the vocabulary while losing the distinction the lesson is supposed to teach.

A compact evidence representation could therefore contain four labelled source statements, the diagram identity, and the teacher’s instruction. The exact internal data structure will vary. What matters is that the downstream model can tell which material is source evidence and which text is the user’s assignment.

Illustrative context packet

A human-readable version of the packet might look like this: task = produce a ten-minute practice activity; audience = Secondary 1; factual source = statements S1–S4 plus diagram D1; required output = one explanation, one comparison table, two questions and an answer key; permitted invention = everyday scenarios only; prohibited actions = grading, sending, publishing and modifying learner records.

This packet is not a “super prompt”. It is a visible representation of the work. If a requirement changes, we can point to the field that changed. If an output is wrong, we can ask whether the error began in the source, task specification, model interpretation or later checking.

Candidate draft produced by the model

A suitable candidate explanation could be: “Evaporation and boiling both change liquid into gas, but they do not happen in the same way. Evaporation occurs at the surface and can happen below the boiling point. Boiling occurs throughout the liquid when the boiling condition is reached.” This sentence uses only the supplied rules and keeps the central contrast visible.

The comparison table can be expressed in prose: evaporation — surface, can occur below boiling point, rate can increase with heating; boiling — throughout the liquid, associated with the boiling condition, visible bubbles can appear throughout the liquid. The system should not add a precise temperature unless the source packet provides one for the substance and conditions being discussed.

Question 1: “A puddle becomes smaller during a warm afternoon even though it never bubbles. Which process is occurring, and what detail supports your answer?” Expected answer: evaporation, because the liquid can change to gas from the surface below its boiling point.

Question 2: “Two beakers are being heated. Beaker A has a few particles escaping from the surface but no bubbles throughout the liquid. Beaker B has bubbles forming throughout the liquid. Which beaker is boiling?” Expected answer: Beaker B. Beaker A can still be evaporating even though it is being heated.

Verification packet

Now check the draft against the source. Claim one: both processes change liquid to gas. Supported by the framing of the supplied material. Claim two: evaporation occurs at the surface. Supported. Claim three: it can occur below the boiling point. Supported. Claim four: boiling occurs throughout the liquid. Supported. Question 1 requires only those statements. Question 2 also stays within those statements.

Next check the task rather than the science. Did the draft contain an explanation, comparison, two questions and an answer key? Yes. Did it remain at the requested learner level? That requires teacher judgment, because “Secondary 1 appropriate” is not a purely mechanical property. Did it send the activity to students? No. Did it alter a record? No.

The final result is therefore not “the learner has mastered evaporation”. The verified result is narrower: a draft activity exists, its factual claims are supported by the supplied source, the requested components are present and the prohibited actions were not part of the workflow. The teacher still owns the decision to use the activity.

The Handoff Map: What Each Layer Receives and Produces

The Clementi teaching pattern works because it shows where a mathematical step starts and ends. We can do the same for SI. The task-definition layer receives human intent and produces a bounded assignment. It cannot prove the underlying source is correct. The source layer provides evidence and provenance. It cannot decide the learner’s objective. The model receives prepared information and produces candidate interpretations or outputs. It cannot grant itself permission to act.

The retrieval layer receives an information need and a permitted collection, then returns candidate evidence. It cannot make an outdated document authoritative merely because it is similar to the query. A tool layer receives structured arguments and performs an operation. It cannot decide that the operation is legitimate just because the call is syntactically valid. The verification layer compares claims or resulting state with evidence. It cannot turn an incomplete check into universal certainty.

The human or institutional control layer sets objectives, permissions and acceptance conditions. Humans can also make mistakes, which is why important workflows need records, review and feedback. “Human in the loop” is not a magic guarantee. It is an assignment of responsibility that must be clear enough for the person to understand what they are approving.

A Second Task Shows Which Components Are Optional

Now change the job. A student asks, “Rewrite this sentence more clearly: ‘The experiment was bad because the water thing changed.’” The student supplies the sentence and wants one clearer version. There is no need for web retrieval, persistent memory, a file-writing tool or an agent loop. A language model with the sentence and a simple instruction may be enough.

A suitable response might be: “The experiment produced an unreliable result because the water level changed during the procedure.” If the original context never established that the result was unreliable, an even safer rewrite would preserve only what was stated: “The experiment was affected because the water level changed during the procedure.”

The important lesson is architectural restraint. The complete Super Intelligence stack is a menu of responsibilities, not a command to use every available component. Adding retrieval to a sentence rewrite can introduce irrelevant information. Adding memory can preserve details that the task does not need. Adding autonomous actions can create consequences where none are required.

Good system design therefore asks two questions together: what capability is required, and what is the simplest arrangement that can provide that capability with an appropriate level of evidence and control? Complexity should earn its place by solving a real problem.

Three Operating Pathways: Repair, Stabilise and Extend

The Clementi article distinguishes different learner starting points. SI systems also need different interventions depending on where the failure begins. A repair pathway is for a system that cannot reliably complete the basic task. A stabilisation pathway is for a system that usually works but fails under ordinary variation. An extension pathway is for a stable system that is being asked to handle a broader class of work.

Repair pathway

Suppose the lesson assistant repeatedly uses the wrong chapter. Do not begin by adding a second agent. Verify document identities, version metadata and retrieval filters. Supply the correct chapter directly as a control test. If the model performs well with the correct passage, the first unstable point is probably upstream of the model.

Stabilisation pathway

Suppose the assistant normally finds the right source but sometimes omits the answer key when the requested format changes. Build a representative set of formatting cases and test them after prompt, model or code changes. The goal is not merely one successful demonstration; it is dependable behaviour across the variations users actually create.

Extension pathway

Suppose the assistant reliably prepares source-grounded drafts and the next requirement is to save them automatically. Add one bounded file operation, not broad access to the entire storage account. Define the destination, naming rule and read-back check. Re-run the original content tests as well as the new save tests so that added capability does not silently damage earlier performance.

The SI Failure Ladder: Diagnose the Earliest Broken Link

When a result is wrong, start at the beginning of the route. Level 1 is task failure: the system solved the wrong problem. Level 2 is evidence failure: the wrong or incomplete source reached the task. Level 3 is representation failure: the right source was present but important structure was lost. Level 4 is interpretation failure: the model misunderstood a correctly represented task.

Level 5 is tool-selection or argument failure: the system chose an inappropriate operation or supplied the wrong inputs. Level 6 is execution failure: the operation did not complete as intended. Level 7 is verification failure: the system had evidence of a problem but did not detect or report it. Level 8 is reporting failure: the internal state was accurate but the final message overstated what had happened.

These levels are an eduKateSG diagnostic teaching device, not a universal scientific taxonomy. Their value is practical: they stop a team from calling every defect a “model hallucination”. A system can have an excellent model and still fail because the source was stale or the save operation targeted the wrong object.

Google’s current Machine Learning Crash Course describes production ML as a wider ecosystem around the model and explicitly includes testing and monitoring of surrounding components. That is the same operational habit expressed here: evaluate the whole path that creates the user-visible result, not only the learned model inside it.

Worked Diagnostic: Four Similar Wrong Answers, Four Different Repairs

Case A: the evaporation activity says boiling occurs only at the surface. Inspection shows the extracted source labels were swapped. Repair the ingestion or document representation. A prompt rewrite cannot recover information that entered the model incorrectly.

Case B: the source packet is correct, but the model still states that heating automatically means boiling. Supply the same packet in a controlled test. If the error persists, examine model suitability, instructions and verification. This is closer to a model-interpretation failure than Case A.

Case C: the content is correct, but the saved file contains yesterday’s draft. The reasoning worked; resource identity or version handling failed. Repair the save target and add a read-back check. Replacing the language model would not address the first unstable point.

Case D: the correct file is saved, but the assistant tells the teacher “the lesson has been assigned to the class”. No assignment tool exists. The system has a reporting failure. The repair is to constrain completion language to observed actions and, where appropriate, connect the final statement to actual tool results.

Independent Mapping Exercise

Try this without looking at the answers first. A parent uploads a marked mathematics worksheet and asks: “Identify the repeated error pattern and suggest three practice questions. Do not infer anything about my child’s overall ability.” Which components are necessary, which are optional, and what should count as completion?

Second task: a school administrator asks an assistant to read an approved timetable spreadsheet and create a draft email informing teachers of one room change. The system may draft the email but may not send it. Which new responsibility appears compared with the first task?

Third task: after the administrator reviews the draft, they explicitly approve sending it to the listed teachers. What additional checks become important before execution?

Worked answers

For the mathematics worksheet, the essential components are document or image ingestion, a model capable of interpreting the workings, a clear task boundary and a verification step against the actual marked examples. Persistent memory, public web search and external action tools are optional and probably unnecessary. Completion means a reviewable error pattern plus three practice questions grounded in the supplied work, without turning the pattern into a permanent judgment about the learner.

For the timetable task, reliable spreadsheet reading and row selection become important. A drafting model may prepare the email. Because sending is prohibited, no outbound communication action belongs in the authorised path. Completion means the draft exists and reflects the approved timetable source.

After explicit approval to send, the workflow gains an external action. Before execution, verify the approved draft version, recipient list, destination account and the fact that the room-change data still matches the current timetable. After sending, inspect the service result or message identifiers rather than reporting success from the model’s intention alone.

A Practical SI Stack Worksheet

For any new task, write six lines before choosing an architecture. Line 1: the human outcome. Line 2: the minimum evidence needed. Line 3: the model capability required. Line 4: the external operations, if any. Line 5: the checks that establish completion. Line 6: the conditions that must stop the workflow or return it to a person.

Then ask what can be removed. If the task can be completed safely with supplied context, retrieval may be unnecessary. If the result is a draft, action permissions may be unnecessary. If the calculation is deterministic, a calculator may be more appropriate than asking the model to reproduce arithmetic from memory. The purpose is not minimalism for its own sake; it is clarity.

Finally, test one ordinary success case, one missing-information case, one contradictory-input case and one failed-tool case. Record what the system should do before running the test. This prevents a persuasive response from redefining the expected result after the fact.

This method connects directly to the next articles in the series. From Input to Output follows the request lifecycle in detail. Model versus System shows how to isolate responsibility. Capability versus Autonomy explains what changes when the workflow is allowed to act.

What Mastery of the Whole Stack Looks Like

A reader has understood the whole stack when they can look at a new SI task and resist two shortcuts. The first shortcut is “the model did everything”. The second is “the model caused every failure”. Instead, the reader can identify the task, evidence, representation, model, retrieval, tools, verification and authority that were actually involved.

That reader can also explain absence. A sentence rewrite may not need memory. A source-grounded answer may not need an autonomous agent. A calculator can verify arithmetic without deciding which rows belong in the calculation. A human approval can authorise a specific publication without granting continuing administrator access.

This is the practical meaning of a Super Intelligence stack. It is not a tower of fashionable components. It is a chain of responsibilities whose handoffs must preserve the task. When each responsibility is explicit, the system becomes easier to understand, test, repair and extend.

Frequently Asked Questions About the Super Intelligence Stack

Is Super Intelligence the same as artificial intelligence in this series?

Yes. SI is our series label for the AI technologies being explained. It should not be confused with a scientific finding that a system exceeds human intelligence across all domains. When we discuss AGI or artificial superintelligence, we identify those concepts separately.

Does every SI system contain a large language model?

No. This article concentrates on language-model-based assistants because they make the model-versus-system distinction easy to examine. Machine learning also includes other architectures and tasks. The general questions about inputs, objectives, checks and deployment remain useful, but the mechanisms can differ.

Does a chatbot automatically search the internet?

Do not assume so. Searching requires an available retrieval capability and an actual search operation. For a source-dependent question, look for the material retrieved and whether it supports the answer. A current-looking sentence is not evidence that a live lookup occurred.

Is a larger model always the right improvement?

Not necessarily. In the examples above, the failure could be missing information, an outdated document or incorrect permission. A stronger model cannot reliably compensate for every missing system responsibility. Identify the bottleneck before choosing the repair.

Can retrieval remove every hallucination?

No such guarantee follows from adding retrieval. The wrong passage may be found, a useful passage may be misread, or a conclusion may go beyond what it supports. Retrieval supplies evidence; the application still needs appropriate interpretation and checks.

Is memory the same as training?

No. A stored preference or retrieved past document can influence a future response without retraining the model. Ask whether information is being kept in application storage, supplied in context or used in a separately managed training process.

Why does human control remain part of the stack?

Because choosing a legitimate purpose, approving an external action and accepting its consequences are not identical to generating a technically plausible answer. Our design keeps these responsibilities explicit. The NIST AI Risk Management Framework is a useful voluntary reference for considering trustworthiness across the design, use and evaluation of AI systems.

Must a useful system be autonomous?

No. A draft-only assistant can be useful when a person must remain responsible for approval. Autonomy should follow the task’s needs and tested operating boundaries. It is not a prize that every application must pursue.

From Understanding the Stack to Using It Well

The complete SI stack is not one mysterious object. It is a set of connected responsibilities. Information must arrive intact. The model must be suitable. Missing knowledge must be retrieved appropriately. Tools must act within permission. Results must be checked. Failures must remain visible.

Once those responsibilities are separated, the system becomes easier to discuss. A student can ask where an answer came from. A teacher can preserve the learning objective. A builder can test a failed interface. A manager can decide what remains under human approval.

That is the foundation of practical SI literacy: not trusting everything and not dismissing everything, but learning to identify the particular mechanism, evidence and boundary that make a result useful.

Continue through the How Super Intelligence Works hub. For the wider educational question of how people should evaluate machine assistance, read The Importance of AI Literacy.


How Super Intelligence Works Series Navigation

Series Hub · Next: 002 — From Input to Output