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 | From Input to Output — What Actually Happens After You Ask

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

How does Super Intelligence turn your input into an output? In a language-model-based SI application, the request is prepared with relevant context, converted into model-compatible representations, processed through inference and decoded into a response. Some requests also involve retrieval, tool execution and checks before the application can honestly report completion.

The words appearing on the screen are the visible end of a longer process. Understanding that process makes it easier to recognise why an answer can be fluent but unsupported, why an attachment may be missed, and why a tool operation needs more evidence than a sentence saying it happened.

This guide explains the SI input-to-output pipeline, also described through terms such as LLM inference, prompt processing, token generation and AI tool calling. We follow one small task through the entire journey so that the machinery remains connected to something a reader can inspect.

In this eduKateSG series, Super Intelligence, or SI, is our umbrella name for AI technologies. It is not a claim that the systems discussed have achieved artificial superintelligence. The pipeline below is a representative design for an LLM application, not a disclosure of the private architecture of any particular service.

For the broader architecture, begin with The Whole Super Intelligence Stack. Here, our question is narrower: what must happen between a request arriving and a result being ready to use?


The Request Is Not Always the Whole Input

Imagine writing: “Use the attached activity-room stock log to calculate the remaining exercise books. Count only completed movements. Explain the calculation and prepare a draft note. Do not change the stock record.”

The visible message contains an instruction, but the task also depends on an attachment, the meaning of “completed”, the identity of the stock record and the boundary against changing it. A useful application must preserve these relationships when preparing the model’s input.

If the stock log is missing, the correct response is not to invent a reasonable opening balance. If the attachment contains two different rooms, the application must determine which one the request concerns. If “draft note” is interpreted as “update the official record”, the system has changed the assignment.

This is why understanding input-to-output processing starts before neural computation. The first question is not how quickly the model can generate. It is whether the application has assembled the right task with the right materials and the right limits.

A Small Worked Example We Can Check Ourselves

Our example is fictional and deliberately simple. The activity room begins with 80 exercise books. Movement M01 records 35 received. M02 records 12 issued. M03 records 8 transferred out. M04 records 5 damaged books removed. All four movements are marked completed.

The attachment also repeats M02 on an export page and includes a proposed receipt of 20 books marked pending. The instruction says to count unique completed movements only. The repeated record is identified by the same movement ID; two different movements with the same quantity would not automatically be duplicates.

The expected calculation is 80 + 35 − 12 − 8 − 5 = 90 exercise books. We exclude the repeated M02 because it represents the same recorded event, and we exclude the pending receipt because it has not met the task’s inclusion rule.

This example separates several jobs that a final answer can hide: reading the source, interpreting status, identifying a duplicate event, performing arithmetic, explaining exclusions and respecting a read-only boundary. Correct arithmetic on the wrong inputs would still produce the wrong answer.

Stage One: The Application Receives and Identifies the Task

In our proposed design, the application first associates the request with the right conversation and the supplied attachment. Where account-based access is involved, it also checks which resources this user is permitted to read. These are application responsibilities; the model should not have to guess them from the tone of the message.

A request identifier helps the application keep later operations connected to the same job. The attachment needs its own identity and version. Otherwise, a later answer can accidentally refer to a newly uploaded file while claiming to describe the earlier one.

For our exercise-book task, the application records that the requested output is a calculation and a draft note. It does not add an update operation simply because the tool environment happens to contain one. Available functionality and authorised functionality remain different things.

At this stage, a useful failure message would be precise: “The attachment is unavailable” or “The file contains two room logs.” A generic statement that SI cannot help would hide the actual obstacle and make the next corrective step harder to identify.

Stage Two: The Attachment Becomes Readable Evidence

The application next obtains the content needed for the task. For a clean text table, extraction may be straightforward. For an image or a mixed-layout page, the system needs an appropriate visual or document-processing route. The design should not treat an empty extraction result as proof that the original page is empty.

In our example, every quantity must remain associated with its movement ID, direction and status. “35 received, completed” has a different meaning from “35 issued, pending”. Losing one column can change the calculation even when all the numbers survive.

We would preserve the relevant rows and their source locations, then compare ambiguous entries with the original. The repeated M02 should remain visible until the inclusion rule is applied. Removing it too early without recording why would make the result harder to audit.

The principle is simple: extract enough structure to support the reasoning that follows. A long block of disconnected text is not necessarily a better representation than a short, well-labelled table. The task determines which relationships must survive.

Stage Three: Instructions and Context Are Assembled

The model needs the user’s request alongside the evidence it must use. A practical input packet could contain the stock rows, the completed-only rule, the duplicate-ID rule and the instruction to produce a draft without changing the original record.

It should not include unrelated private files merely because they are available. It should not carry forward an abandoned instruction from a different task. Our objective is to make the relevant working state clear, not to maximise the amount of material passed to the model.

Chat applications commonly represent messages with roles and content before converting them to the model’s expected format. Hugging Face’s chat-template documentation explains how model-specific templates turn these messages into a token sequence containing the expected conversational structure.

That formatting helps the model interpret a conversation. It is not a substitute for access control. A sentence inside an attached document should not acquire permission to change the user’s account merely because it looks like an instruction.

Stage Four: Text Becomes Tokens and Numerical Representations

For a text language model, tokenisation converts the prepared text into units from the model’s vocabulary. A token can correspond to a word, part of a word, punctuation or another encoded fragment. The actual segmentation depends on the tokenizer; we should not invent a universal split for a particular sentence.

The resulting token identifiers are numerical labels, not tiny English definitions. They enter a numerical processing pipeline. A useful beginner distinction is that the identifier says which vocabulary item is present, while learned representations give the network values it can operate on.

Hugging Face’s text-generation guide demonstrates the input-tokenisation and output-decoding stages. The implementation details vary, but the underlying lesson is stable: visible text and the model’s computational input are related representations, not the same physical object.

In the stock example, a missing minus sign or a lost “pending” label is therefore not a cosmetic issue. The system is now computing over a different representation of the task. Better output wording cannot repair information that never entered the process correctly.

Stage Five: The Model Processes Relationships in the Input

In a transformer language model, attention is part of the mechanism for combining information across positions. The original Attention Is All You Need paper introduced the transformer architecture using attention rather than recurrence as its central sequence-processing approach.

For a beginner, the useful point is not that the model consciously “looks at” the table. It is that its calculations depend on relationships within the supplied representations. The quantity 20 matters differently when associated with “pending” than when associated with “completed”.

Our example makes a common misunderstanding visible. The task is not solved by recognising each word independently. The inclusion rule must apply to the correct rows, and the arithmetic must use only the selected events. Interpretation links the parts into a task-specific structure.

We should not conclude from a correct answer that every internal step matched a human’s reasoning. We can examine the supplied data, the operations performed and the final explanation. Those observations support a functional assessment without inventing a story about the model’s subjective experience.

What Prefill and Decoding Mean

In common autoregressive serving terminology, prefill refers to processing the input sequence before continuing generation. Decoding then produces further tokens. A key-value cache can retain attention-related values from already processed tokens so that later generation does not recompute all of them. Hugging Face explains this in How caching works.

The cache is not a complete personal memory of the user. It is a runtime efficiency mechanism. Whether a product stores conversations or retrieves past preferences is a separate application question, with separate rules about persistence and access.

In our worked task, an application might spend time preparing the attachment before the model begins generating an answer. The user may experience that as one pause, even though it contains several different activities. A visible delay does not identify which component is responsible.

For diagnosis, separate preparation time, model-processing time, tool time and delivery time where the application exposes them. A slow document reader and a slow generation step need different repairs. Calling both “the model thinking” makes the system harder to understand.

Stage Six: The Next Output Is Selected

An autoregressive language model produces scores for possible next tokens. A decoding method determines how an output token is selected. Hugging Face’s generation-strategy documentation distinguishes approaches such as choosing the highest-scoring token and sampling from a probability distribution.

The important practical distinction is between a likely continuation and a verified claim. A phrase can be linguistically plausible while making an incorrect statement about the attachment. Probability within the generation process is not a direct certificate of real-world truth.

For our example, “The remaining balance is 110” could look perfectly normal as a sentence. It would still violate the rule excluding the pending receipt. A fluent explanation is not enough to detect that error; we must compare the selected inputs with the task.

Likewise, lowering randomness does not transform a wrong interpretation into a correct one. A system can be consistently wrong. Decoding settings affect generation behaviour, while evidence selection and validation address different parts of reliability.

Not Every Model Output Is a Final Answer

In a tool-enabled application, an intermediate output may request an operation rather than address the user directly. The model might propose a calculation, a file read or another allowed action. The application must interpret that request and decide whether it is valid and authorised.

Hugging Face’s tool-use documentation describes the distinction between a model requesting a tool and the surrounding code executing it. This matters because a generated tool call is not evidence that the operation has already run.

In our example, the application could send the selected expression to a calculator. The expression should contain the opening balance and the four unique completed movements. The calculator can check the arithmetic, but it cannot independently know whether the application chose the right rows.

That gives us two separate checkpoints: validate the meaning of the inputs, then validate the calculation. Combining them into one vague “maths check” would conceal the difference between a reasoning error and an arithmetic error.

Stage Seven: The Application Validates the Requested Operation

A well-bounded version of our example would allow reading the supplied log and running arithmetic. It would not permit editing the official stock record, because the user expressly prohibited that action. The application should enforce that limit even when the model proposes an update.

Before execution, check the operation name, the required fields, the target resource and the relevant permission. A valid-looking request can still point to the wrong file. A correct file identity can still be paired with an unauthorised operation. Both dimensions need attention.

This is also where generated content meets conventional software security. OWASP’s Improper Output Handling guidance warns against passing model output into downstream systems without appropriate validation. A model-produced string should not automatically become trusted executable instruction.

For the reader, the lesson is practical rather than alarmist. We can make tools useful without giving every generated suggestion the right to act. Narrow interfaces and checks turn a broad language capability into a bounded operation with a clear purpose.

Stage Eight: The Tool Returns Evidence, Not a Victory Statement

The calculator returns 90 for the selected expression. That is evidence about arithmetic under those inputs. It does not prove the attachment was complete, the duplicate rule was correct or the opening balance reflected the physical cupboard.

The application should retain that scope when using the result. A careful final note would say that 90 books remain according to the supplied log and the stated inclusion rules. It should not claim that somebody physically counted the books.

Now consider a tool error. The calculation service might be unavailable, or a requested document might not be found. The returned failure belongs in the system’s working state. It should not be converted into a success merely because a successful story would be easier to present.

A tool result is therefore best read as a bounded observation: this operation produced this response for these arguments. The model can use that observation in the next step, but the application must preserve what it does and does not establish.

The Conversation May Continue Through Several Internal Steps

A single user request can lead to more than one model invocation. The first may identify needed information. Another may interpret a tool result. A later one may formulate the response. The user-facing conversation and the application’s internal sequence are not always one-to-one.

In our proposed design, the model first selects the relevant rows, the calculator evaluates the expression, and the model then prepares the explanatory note. A second read may be needed only when a source field remains unclear. Additional steps should serve a defined uncertainty rather than continue indefinitely.

We would set a stopping rule: produce the draft when the source selection and calculation are checked; otherwise identify the unresolved source problem. Repeating the same failed read without new information is not progress.

This is an important habit for anyone learning about agents. Activity is not the same as advancement. A useful sequence reduces uncertainty, produces evidence or completes a permitted operation. Extra steps that do none of these can make a simple task less dependable.

Stage Nine: The Final Response Is Composed

The user needs the answer, the reason for the answer and the status of the requested work. For our stock-log example, those are three different pieces of information. The balance is 90. The calculation excludes a duplicate movement and a pending receipt. The original record has not been changed.

A suitable draft note might read: “According to the supplied log, 90 exercise books remain after the four unique completed movements. The repeated M02 entry and pending receipt were excluded. This note is a draft; the stock record has not been updated.”

The note is deliberately modest. It does not claim an independent physical inspection. It does not hide the inclusion rule. It does not turn a calculation into a completed administrative update. Each sentence stays within the evidence produced by the task.

This is what good synthesis means in practice: bring the pieces together without erasing their boundaries. The response becomes easier to use because the reader can see which part is the result, which part is the explanation and which part still requires a human decision.

Stage Ten: Delivery Does Not Automatically Mean Completion

A user may see text arrive gradually, in batches or all at once. Presentation behaviour should not be mistaken for a direct view of the model’s internal computation. The application may be buffering, formatting or waiting for another operation before showing the response.

For our design, the draft can be delivered as text because that is what the task requested. If the user instead requested a saved file, the system would need an additional file-creation operation and evidence that the saved object contains the intended note.

Similarly, a response cut off after the calculation may leave out the exclusion rule. The visible number is correct, but the deliverable is incomplete. A good application should recognise interrupted output or a missing required section rather than treating any text as a finished job.

Completion belongs to the task definition. It is not simply the moment generation stops. The final checkpoint asks whether the requested result is present, whether the limits were respected and whether the user can identify what remains unresolved.

Where the Pipeline Can Break

Our example allows a precise failure map. At ingestion, a status column may disappear. At context assembly, the completed-only instruction may be omitted. At interpretation, the duplicate event may be counted twice. At calculation, the expression may be entered incorrectly. At reporting, a draft may be described as an update.

These failures can produce similar-looking wrong answers but require different repairs. Rechecking the arithmetic will not recover a missing status column. Improving extraction will not fix an application that permits unauthorised writes. Better prose will not establish that a file exists.

Work backwards from the discrepancy. When the answer is 110, inspect whether the pending receipt was included. When it is 78, inspect whether M02 was counted twice. When it is 90 but the official record changed, inspect the permission and execution path.

These alternative numbers are deductions from our fictional data, not measured error rates for any model. Their purpose is to show how a small, checkable example can reveal distinct failure mechanisms that a general question about “AI accuracy” would leave mixed together.

What an Honest Execution Record Would Contain

For a consequential version of this workflow, an execution record should identify the source version, the task constraints, the operations attempted and the observations returned. It should also record whether the final deliverable was produced and whether any requested step failed.

It need not contain private internal model reasoning. A long generated explanation of “what I thought” is not a substitute for the source row, the actual tool arguments and the returned result. These are different kinds of evidence.

For our example, a compact record could say: source log version A; unique completed movements M01–M04; pending receipt excluded; calculation result 90; no update operation permitted or executed; draft note delivered. That is enough to begin a meaningful review.

Recording should remain proportionate and privacy-conscious. Keep what is needed to investigate the task, not an unrestricted copy of every accessible document. An audit trail should make responsibility clearer without creating an unnecessary new store of sensitive information.

Three Reader Pathways Through Input and Output

For a student, focus on the difference between a supplied fact and a generated claim. Ask which part of the answer can be checked against the question. In the stock example, the opening balance is supplied, the ending balance is calculated, and a physical stock count is not available.

For a regular user, focus on task preparation. Supply the correct document, state the output required and separate drafting from acting. You do not need to write a technical specification for every harmless request, but important boundaries should not be left implicit.

For a builder, focus on handoffs. Validate extracted structure, preserve message roles, inspect tool arguments and check outcomes. A model can only be evaluated fairly when the surrounding pipeline is not silently changing the task or misreporting its result.

All three readers benefit from the same habit: follow one claim from source to output. Where did it begin? What transformation happened? What check supports it now? This habit is more durable than memorising the names of whichever products are currently prominent.

A Practical Exercise: Change One Input at a Time

Recreate the fictional stock task using information you are comfortable sharing. Start with the clean four-movement version. Write the expected result before testing the system so that the generated answer does not become your only reference.

Next, add the duplicate M02. Then add the pending receipt. Finally, add a second room’s log with a different title. Each change introduces a different selection problem. Keep the instruction stable so that you can see which change affects the outcome.

Ask the system to identify included and excluded records before presenting the total. Do not evaluate only whether it reaches 90. A correct number obtained from offsetting mistakes is not the same as a correctly interpreted task.

For the final variation, remove the opening balance. A useful response should identify the missing input or express the remaining quantity in terms of that unknown balance. Inventing a starting value to preserve a neat numerical answer would fail the exercise.


The Full Source Table: What the System Is Actually Asked to Read

The stock-log example becomes more useful when the complete source is visible. The fictional record below is deliberately small enough to verify by hand. Opening balance: 80 exercise books. M01: +35 received, completed. M02: −12 issued, completed. M03: −8 transferred out, completed. M04: −5 damaged and removed, completed. M02 appears again on an export page with the same movement ID. M05: +20 received, pending.

The task rule is: “Calculate the remaining stock from the opening balance and unique completed movements. Treat repeated movement IDs as the same recorded event. Exclude pending movements. Explain which records were included and excluded. Do not change the source record.”

The expected selection is therefore M01, M02, M03 and M04 exactly once each. The duplicate M02 is excluded because its identity repeats an event already counted. M05 is excluded because its status is pending. The correct expression is 80 + 35 − 12 − 8 − 5, which gives 90.

Notice that the arithmetic is the final easy part. The harder work is preserving identity, status and direction. If the word “pending” disappears during extraction, 110 becomes a plausible but wrong result. If the duplicate is counted twice, 78 becomes another plausible but wrong result. These errors arise before or around the calculation, not from addition and subtraction alone.

A Human-Readable Input Packet Before Tokenisation

Before discussing tokens, it helps to see the information as an application might organise it for the model. A human-readable packet could contain five fields: task, source records, inclusion rule, output requirement and action boundary. The exact serialisation differs across products, but the responsibilities are stable.

Task: compute remaining exercise-book stock. Source records: opening balance plus M01–M05 and the repeated M02 row. Inclusion rule: unique completed movements only. Output: total, equation and explanation of exclusions. Action boundary: read-only; no stock update is authorised.

This is the stage where an application can accidentally change the job. It might omit the duplicate rule, truncate the table, attach the wrong file or include a stale conversation instruction. A model cannot faithfully solve a task that has already been misrepresented before it reaches the model.

For chat-oriented language models, frameworks often convert role-and-content messages into the model’s expected token sequence using a chat template. Hugging Face’s current documentation explains that chat histories are ultimately converted into token sequences with model-specific control tokens. The important teaching point is that the visible chat interface is translated into another representation before inference begins.

From Text to Tokens Without Inventing a Tokenisation

We should resist a common teaching shortcut: inventing exact token IDs for a sentence without naming and running a real tokenizer. Token boundaries and IDs depend on the tokenizer associated with the model. “Exercise books” might be one pattern under one tokenizer and a different sequence under another.

The safe explanation is this: the prepared text is converted into a sequence of token identifiers from a vocabulary. Those identifiers are mapped into learned numerical representations that the network can process. Special tokens may help represent message roles or other structure. Exact token counts should be measured with the actual tokenizer when they matter.

Why does this matter to the stock example? Because tokenisation is not the place where the application decides that M05 is pending. That semantic relationship must be present in the input. Tokenisation converts the prepared representation into model-compatible units; it does not repair a missing status field.

A useful diagnostic sequence is therefore: first inspect the source table, then inspect the text or structured packet prepared from it, then inspect tokenizer behaviour only if the failure plausibly involves truncation, formatting or model compatibility. Do not jump to token details when the wrong spreadsheet was selected.

An Illustrative Generation Example With Made-Up Scores

We can demonstrate next-token generation without pretending that we observed a real model’s hidden scores. Suppose the model has already generated the phrase “The remaining stock is”. Imagine, purely for teaching, that the next candidate tokens correspond to “90”, “110”, “78” and “approximately”. Assign illustrative probabilities 0.70, 0.15, 0.10 and 0.05.

Those numbers are invented. They are not measurements from a real system. Their purpose is to show the difference between token selection and factual verification. Even if “90” has the highest illustrative probability, the truth of the stock total comes from the selected records and arithmetic, not from the probability alone.

Now imagine the input packet wrongly includes M05 as completed. The model could strongly favour “110”. Lowering generation randomness might make the system more consistently produce 110. Consistency would not repair the upstream interpretation. A deterministic wrong pipeline is still wrong.

This is why decoding controls, evidence quality and verification must not be collapsed into one idea called “accuracy”. Generation strategy influences which continuation is selected. Evidence selection influences what problem is being answered. A calculator or source check addresses yet another responsibility.

A Complete Tool Call: Meaning First, Arithmetic Second

Assume the application offers a calculator function that accepts an arithmetic expression. The model or orchestration layer first has to produce the correct expression from the interpreted records. For our valid selection, the proposed arguments are equivalent to “80 + 35 – 12 – 8 – 5”.

The application validates that the requested tool is a calculator rather than a stock-editing function. It then executes the calculation. The tool returns 90. That result establishes that the expression evaluates to 90. It does not independently establish that the expression contains the right movements.

Now consider a malformed request: “80 + 35 – 12 – 8 – 5 + 20”. The calculator can correctly return 110. The tool has behaved perfectly while the task has failed. This distinction is crucial in tool-using SI: reliable software execution cannot rescue incorrect semantic inputs.

The application therefore needs two checks. Selection check: the expression contains the opening balance and each unique completed movement exactly once. Arithmetic check: the expression evaluates correctly. Only after both pass should the total be described as supported by the supplied log and rule.

A Complete Final Response and Why Each Sentence Is There

A good final response could say: “According to the supplied stock log and the rule to count unique completed movements only, 90 exercise books remain. Calculation: 80 + 35 − 12 − 8 − 5 = 90. The repeated M02 row was excluded because it has the same movement ID as an already counted event. M05 was excluded because it is pending. The source record was not changed.”

The first sentence states the result and its evidence boundary. The second exposes the calculation. The third and fourth explain the two exclusions. The fifth reports the action status. None of those sentences needs to say “I thought deeply” or “I verified everything”. The useful evidence is the traceable route from source to result.

If the task instead asked for a saved note, the response would need another piece of evidence: the actual saved object or verified link. Text saying “I saved it” is weaker than a tool result followed by a read-back confirming that the object exists and contains the intended content.

Four Failure Classes Using the Same Source

Ingestion error

The application reads M05 as “completed” because the status column is shifted during extraction. The resulting total is 110. The correct repair is to fix the representation and compare the extracted row with the original source. Telling the model “be careful” does not restore the lost column alignment.

Interpretation error

The table arrives correctly, but the model interprets “unique completed movements” as “all completed rows”, counting the repeated M02 twice. The total becomes 78. Here the source representation is sound; the rule application failed. A controlled test can supply the correct table and ask the model to list included movement IDs before calculating.

Calculation error

The model selects M01–M04 correctly and displays the correct expression, but gives 92. The semantic work is sound and the arithmetic is wrong. A calculator or deterministic arithmetic routine is an appropriate repair because the failure has been isolated to computation.

Completion-reporting error

The total is 90 and the explanation is correct, but the assistant says the inventory has been updated even though the task was read-only and no update tool ran. The mathematical answer is correct while the workflow report is false. Repair the completion logic and tie action claims to observed tool outcomes.

The Interrupted Operation Problem

Now extend the task. The user asks the system to save the calculation as a draft note. The application sends a create request to a document service, but the network connection drops before a response arrives. We do not know whether the document was created.

This is not the same as a confirmed failure. Repeating the create operation blindly could make a duplicate. A well-designed workflow needs the service’s documented way to check the outcome, or an idempotency mechanism that allows the same intended request to be retried safely.

The correct status at the moment of uncertainty is “save outcome unknown”, not “save failed” and not “saved successfully”. The user can still receive the calculation in the conversation while the application resolves the document state. Honest status language protects the boundary between generated explanation and external reality.

This is one reason tool-enabled systems need a stronger model of completion than ordinary text generation. Generation stops when the model finishes producing tokens. A workflow completes only when the task’s required external outcomes are known and the evidence for them is available.

What Prefill, Cache and Decoding Do Not Mean

Prefill, caching and decoding are useful runtime concepts, but they should not be confused with long-term application memory. A key-value cache supports efficient autoregressive generation by reusing attention-related computations from already processed tokens. Hugging Face’s current cache documentation describes this as an inference optimisation.

If the user returns next week and the application recalls the stock-room preference, that continuity comes from a persistence mechanism or retrieved history, not from assuming the previous inference cache remained a personal memory. Different layers can all be described informally as “remembering”, which is why precise vocabulary matters.

Likewise, a chat template helps convert structured messages into the form expected by a chat model. It does not decide which documents the user is allowed to read. Formatting, access control and model inference are different responsibilities even when they occur in rapid succession.

Worked Transfer Example: A Student Score Table

Consider a second fictional source. Four quizzes are recorded: Q1 = 14/20 completed, Q2 = 16/20 completed, Q3 = absent and therefore unscored, Q4 = 18/20 completed. A duplicated export row repeats Q2 with the same quiz ID. The task is to compute the average percentage across unique completed scored quizzes only.

Correct record selection gives Q1, Q2 and Q4. The points earned are 14 + 16 + 18 = 48. The available points are 20 + 20 + 20 = 60. The result is 48/60 = 0.8, or 80%. The absent quiz is excluded because it is unscored, and the repeated Q2 row is excluded because it is the same event.

This transfer example proves that the method is not tied to exercise books. The reusable pipeline is: preserve source identity and status; apply the inclusion rule; construct the correct calculation; execute or verify the calculation; state the evidence boundary; report what actions did or did not occur.

Independent Practice: Trace the Failure Before Reading the Answers

Exercise 1: the source table is correct, but the prepared model input accidentally omits the word “pending” from M05. The system returns 110. Which failure class appears first? What should you inspect before changing the model?

Exercise 2: the prepared input is correct. The model lists M01, M02, M03 and M04, but the calculator request is “80 + 35 − 12 − 8 + 5”. The tool returns 100. Where is the error?

Exercise 3: the total and explanation are correct. The task asked for a draft note to be saved, but the document service times out and no status check is available. What should the final response say about the save?

Exercise 4: a later run returns 78. The prepared packet shows the repeated M02 row twice, both with the same movement ID, and the model lists both as included. Is this primarily an ingestion error or an interpretation error?

Answers and explanations

Exercise 1: the first visible failure is in representation or context assembly because a meaningful status value was dropped before the model interpreted the task. Compare the prepared packet with the original table and repair the extraction or assembly route. A model change should not be the first response.

Exercise 2: the selected records are correct, but the expression gives the damaged removal the wrong sign. This is a tool-argument construction error. The calculator correctly evaluates the expression it was given. Fix the expression generation or validate directions before execution.

Exercise 3: report the calculation as complete and the save outcome as unresolved or unknown. Preserve the draft content so the user does not lose useful work. Do not claim success, and do not claim confirmed failure unless the document service establishes it.

Exercise 4: the source representation is acceptable because both rows are visible and retain the same identity. The rule says repeated movement IDs represent the same event, yet both were included. The primary failure is interpretation or rule application.

A Reader’s Checklist for Any SI Answer

Ask five questions in order. First: what source or user input supports this claim? Second: what transformation or selection happened before the model saw it? Third: is this sentence generated, calculated, retrieved or observed from a tool? Fourth: what check supports the result? Fifth: is the final message claiming an external action that actually occurred?

If you can answer those questions, the input-to-output pipeline becomes visible. You no longer have to choose between “trust the AI” and “never trust the AI”. You can inspect the particular route that produced the particular claim.

That is the completion test for this article. A reader should be able to distinguish an ingestion error from an interpretation error, a calculation error from a tool-execution error, and a correct answer from an overstated completion message. The next article, Model versus System, uses the same discipline to decide which component deserves the repair.

Frequently Asked Questions About LLM Input and Output

Does SI read my prompt exactly as I see it?

A text model receives a prepared numerical representation rather than the screen itself. The application may combine your prompt with instructions and other context before tokenisation. Attachments can require additional processing. The visible message is therefore not always the complete computational input.

Are tokens always whole words?

No. Token boundaries depend on the tokenizer. Words may be divided, and punctuation or other fragments may have separate representations. For practical work, preserve the original information and use the model’s actual tokenizer when an exact token count is required.

Does every answer involve a search?

No. A system may answer from supplied context and model capability without external retrieval. Searching is an additional operation. For source-dependent work, inspect whether appropriate evidence was actually obtained rather than inferring a search from the wording of the response.

Does a tool call mean the action succeeded?

No. Distinguish the proposed call, the executed request and the returned outcome. A request can fail, time out or target the wrong resource. A success claim should match the evidence returned by the relevant operation and, where needed, a read-back of the changed state.

Why can the same question receive different wording?

Generation settings can affect token selection, and the actual context or model version may also differ. Different wording is not automatically a problem. For a fixed factual task, inspect whether the facts, constraints and supported conclusion remain correct across the variations.

Does asking for an explanation prove the reasoning is correct?

No. An explanation can make a claim easier to inspect, but it still needs checking. In our example, compare the selected records, exclusion rule and arithmetic. Do not substitute a persuasive narrative for evidence that those operations were handled correctly.

Will a correction permanently change the model?

A correction can affect subsequent output when it is included in context. Persistent application memory and parameter training are separate processes. Their availability and retention rules depend on the system; a single improved answer does not demonstrate either one.

What is the most useful first check when an answer is wrong?

Check whether the model received the right question and evidence. Then examine the interpretation and operations. This sequence avoids spending time adjusting output style when the real problem is a missing page, a wrong source version or an omitted constraint.

The Important Journey Is From Evidence to a Usable Result

The input-to-output pipeline is more than text entering a box and text leaving it. A task must be identified. Information must survive preparation. A model must process it. External operations, when needed, must be bounded and checked. The response must describe what actually happened.

Our fictional stock log is small, but the lesson travels. The same distinctions matter when reviewing a chapter, comparing documents, writing software or preparing a report. Correctness depends on preserving meaning through the whole journey, not merely producing an impressive final paragraph.

Return to the How Super Intelligence Works hub for the full series. Revisit The Whole Stack to see how this request lifecycle fits into the larger SI architecture.


How Super Intelligence Works Series Navigation

Previous: 001 — The Whole Stack · Series Hub · Next: 003 — Model versus System