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 Complete SI Guide to Models, Reasoning, Tools, Agents and Human Control

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

How does Super Intelligence work? A useful starting point is to separate the model from the system around it. A model supplies learned computational capability. An application prepares the task, provides context, retrieves information when needed, invokes permitted tools and checks what happened before delivering a result.

The answer on a screen is only the visible part of that arrangement. To understand it properly, we need to follow the data, the training, the inference, the evidence and the permissions—not simply admire the speed or fluency of the response.

This How Super Intelligence Works hub is the entry point to a 100-article curriculum on AI architecture, machine learning, large language models, generative AI, retrieval, memory, tools and AI agents. It also includes the evaluation, security, infrastructure and human decisions that make these technologies usable.

A note on terminology: eduKateSG uses “Super Intelligence”, or SI, as the series name for the field commonly called artificial intelligence. This is an editorial convention. It is not a claim that every present-day system possesses artificial superintelligence. Conventional technical terms—including AI, LLM, AGI and ASI—remain visible so readers can connect the explanations to research.

Start reading: All 100 numbered curriculum positions now have published reading routes, 001–100. Some positions intentionally use an existing comprehensive specialist guide rather than a redundant duplicate. Every numbered entry below links to a live article. Begin with the foundations, choose a specialist branch, or go directly to the published 100. Civilisation-Scale SI Stack capstone to assemble the complete mechanism.

New to AI? Start with the complete beginner guide

How Artificial Intelligence Works | The Complete AI Guide for Beginners explains AI from the first principles through data, machine learning, neural networks, language models, tools, agents and practical verification. Its 50 chapters, 12 worked laboratories, beginner questions and plain-English glossary provide a foundation for the specialist curriculum below. Choose a reading route, try an example and check what you can explain independently.


Begin With the Four Foundations

001. The Whole Stack — From Human Intent to Machine Action explains how the pieces fit together. Follow a teaching task through information preparation, model capability, tools, checking and a reviewable result.

002. From Input to Output — What Actually Happens After You Ask follows one request through the machinery. A fictional stock-log calculation separates correct source selection from correct arithmetic and honest completion.

003. Model versus System — Why the Model Is Only One Part of SI compares hypothetical applications using the same model. Learn to identify whether the bottleneck lies in capability, evidence, retrieval, permissions or delivery.

004. Capability versus Autonomy — Being Smart Is Not the Same as Being Allowed to Act explains bounded delegation. A publishing example shows why a good draft, permission to publish and evidence of publication are different things.

Explore the History of Super Intelligence

Where did these ideas come from? The History of Super Intelligence — From Early AI to Modern Systems is a 60,000-word companion to this hub, organised into 30 conversational chapters. It follows mechanical calculation, mathematical logic, early AI, expert systems, machine learning and modern models, alongside the arguments about machines that might exceed human intellectual capability.

Read the complete account from the beginning, or choose a starting point:

This historical companion sits alongside the 100-article curriculum. The hub explains how the pieces work; the history shows how people developed them, what changed after setbacks and why demonstrated achievements must be distinguished from predictions about superintelligence.

Why the Model Alone Is Not the Whole Answer

Imagine asking an assistant to explain a difficult paragraph. Now imagine asking it to find the current approved document, compare two versions, calculate a quantity, create a draft and leave the original record unchanged. The second task needs more than a fluent explanation.

It needs the correct source, the right access, appropriate operations and a way to check their results. Google’s production ML overview places the model inside a wider engineering system. That is the perspective adopted throughout this curriculum.

When a system fails, the distinction helps us investigate. A missing attachment is not the same as an arithmetic error. An outdated source is not the same as a malformed tool request. An unauthorised action is not made acceptable by the quality of the generated text.

Our aim is to make these mechanisms understandable enough to inspect. A student should be able to ask where a claim came from. A teacher should be able to preserve the learning objective. A builder should be able to identify a failed handoff. A user should be able to distinguish a suggestion from an action.

Three Processes to Keep Separate

Training develops model capability

Training adjusts learned parameters using data and a learning objective. The specific method depends on the model and task. Google’s neural-network introduction provides a foundation for understanding how layers and training contribute to learned prediction.

Inference applies a trained model to a current input

Inference is the computation performed when the model is used. For an autoregressive text model, generation involves continuing a token sequence. The application around that model may add retrieval, formatting, tool calls or further model invocations. Not every AI system uses this same generation mechanism.

An agentic workflow connects decisions to observations and actions

An agentic application may let a model choose among permitted steps, inspect results and continue. Anthropic’s workflow-and-agent distinction is useful here. The choice to add flexibility should follow the task, not the assumption that greater autonomy is always better.

These processes can interact without becoming identical. Correcting a response in conversation does not automatically demonstrate a weight update. Saving a preference is not the same as retraining. Calling a tool is not the same as proving that the operation succeeded.


How Super Intelligence Works in One Complete Example

A directory of 100 article titles is useful only if the reader already understands the machine those titles belong to. This section supplies the missing teaching core. We will follow one complete task from human request to checked result and identify where the major SI mechanisms enter.

Imagine a teacher asks: “Use the approved chapter on heat transfer to create a one-page revision sheet for Secondary 1 students. Include a short explanation, two practice questions and answers. Use only the supplied chapter for factual claims. Save a private draft for review; do not send it to students.”

The request sounds simple, but it contains several jobs. The application must identify the source, preserve the learner level, distinguish factual material from invented practice scenarios, create a useful document, respect the draft-only boundary and report whether the save actually succeeded.

Layer 1: Human intent becomes a task

The first layer is not a neural network. It is the assignment. The system needs to know the audience, output, source boundary, permitted action and stopping point. If the task is ambiguous, more model capability can produce a more polished version of the wrong job.

A useful task representation is: audience = Secondary 1; output = one-page revision sheet; evidence = approved heat-transfer chapter; creative freedom = original practice scenarios that do not invent new scientific rules; action = create private draft; prohibited = sending, grading and changing learner records.

Layer 2: Source material becomes usable information

The chapter may contain paragraphs, diagrams, captions and tables. The system must preserve relationships that matter to the lesson. If a diagram label is detached from the wrong arrow, the model can receive the right words in the wrong structure. This is a representation problem before it is a reasoning problem.

For a text model, the prepared material is eventually converted into tokens and numerical representations. Google’s current Machine Learning Crash Course describes tokens as the units used by language models and introduces the Transformer as an important architecture for modern LLMs. The curriculum later develops these mechanisms separately rather than compressing them into one metaphor.

Layer 3: The model applies learned capability

The model can interpret the instruction, recognise relationships in the supplied material and generate a candidate revision sheet. Its learned parameters provide broad capability. They do not establish which chapter is approved today, which learner is using the sheet or whether the teacher authorised publication.

This is why the hub keeps model mechanics and system architecture separate. The model is essential, but a deployed SI application has other responsibilities. Google’s production ML material makes the same general point: real production systems contain data, serving, testing, monitoring and other components around the model.

Layer 4: Context tells the model what matters now

The teacher’s request, the selected chapter and any relevant system rules become part of the current working context. Context is not a magical second brain. It is the information made available for this inference or sequence of inferences.

A strong context contains what the task needs and keeps unrelated material out. Twenty old worksheets, an abandoned draft and a different student’s notes do not become useful merely because they fit inside a large context window.

Layer 5: Retrieval may bring in missing evidence

If the approved chapter was not attached directly, a retrieval layer may locate it from an authorised collection. The retrieval job is not simply “search for heat transfer”. It is “find the current approved source for this task”. Relevance, authority and freshness are separate properties.

Retrieval-augmented generation combines external retrieved material with a generative model. It can make current or local evidence available without retraining the model. It can also fail by retrieving the wrong version or an incomplete passage, which is why retrieval itself needs evaluation.

Layer 6: Reasoning and decomposition organise harder work

The task can be decomposed into smaller requirements: identify the chapter’s core distinction, draft the explanation, create two applications, produce answer keys, check each factual claim, then format the sheet. Decomposition is useful when the subproblems preserve the dependencies of the original task.

The system may spend additional computation on difficult questions, compare candidate outputs or run checks. That extra work is not valuable merely because it is longer. It is valuable when it improves a task-relevant outcome that can be measured.

Layer 7: Tools perform operations outside text generation

A document tool can create the private draft. A calculator could verify numerical examples if the lesson contains them. A search service could retrieve evidence. These tools extend the system, but a model proposing a tool call is different from the application executing it.

The 2026-07-28 Model Context Protocol specification is one current example of an open protocol for connecting AI applications with tools and resources. A protocol can standardise the connection; it does not replace the need to define which user is authorised to perform which operation.

Layer 8: Autonomy determines how much work continues without intervention

The system might be allowed to draft, check and save privately without asking after every step. It should still stop before sending the sheet because sending was excluded. Capability and autonomy are related but different variables.

An agentic workflow can choose among permitted next steps and continue after observing results. A fixed workflow can follow predetermined steps. Neither architecture automatically deserves more trust. The task, variability, consequences and available controls determine which arrangement is suitable.

Layer 9: Verification decides what the result actually proves

The revision sheet should be checked against the chapter. The answer keys should be attempted. The saved document should be read back. The final status should distinguish a completed draft from a sent assignment or a demonstrated learning outcome.

NIST’s AI Risk Management Framework and Generative AI Profile treat AI risk and trustworthiness as system-lifecycle concerns rather than properties of a single output. That broader perspective matches the structure of this series: design, use, evaluation and operating context all matter.

Layer 10: Human and institutional responsibility closes the loop

The teacher decides whether the revision sheet is suitable for the class. The school decides which source is approved, which records are private and who may distribute material. SI can assist those decisions without silently inheriting their authority.

The final result is therefore precise: a source-grounded private revision-sheet draft exists and is ready for teacher review. It is not “the class has learned heat transfer”, “the lesson has been sent” or “the model knows the school’s curriculum forever”.

The Ten Questions That Let You Inspect Any SI System

When you meet a new SI product, workflow or agent, ask ten questions. What outcome is the human trying to achieve? What evidence is required? How is the information represented? Which model capability is involved? What context is supplied? Does the system retrieve anything external?

Then ask: which tools can it use? How much of the work may continue autonomously? What verifies the result? Who owns the final decision and the consequences? These ten questions are the portable map behind the 100-article series.

A product can be impressive while still leaving several answers unclear. That does not automatically make it unusable. It tells you what to investigate before relying on it for a more consequential task.

Prerequisites: What You Need Before Going Deeper

You do not need advanced mathematics to begin this series. The first requirement is the ability to separate evidence from conclusion. If a system says a file was saved, ask what confirms the file exists. If it cites a document, ask whether that document supports the nearby claim.

The second prerequisite is basic probability intuition: a likely prediction is not automatically a verified fact. Later articles will introduce probability, logits, sampling and calibration more carefully.

The third prerequisite is basic computing language. A file, database record, API request, model input and model parameter are different things. The series explains each concept when needed, but keeping these categories separate prevents many early misunderstandings.

The fourth prerequisite is willingness to inspect examples. The curriculum is not designed as a vocabulary list. Each major mechanism should eventually be traceable through a worked problem, an error case and a transfer exercise.

Five Reader Routes Through the 100 Articles

Beginner route

Read 001–004 first, then 011 Tokens, 015 Neural Networks, 016 Transformers, 031 Inference, 041 Context Engineering, 046 Retrieval-Augmented Generation, 051 Tool Use, 054 Agents, 071 Hallucinations and 073 Evaluations. This route builds a complete mental model before adding specialised detail.

Builder route

After 001–004, prioritise 020 Context Windows, 026 Post-Training, 031 Inference, 041 Context Engineering, 044 Retrieval, 046 RAG, 052 Function Calling, 053 Connectors, 054 Agents, 060 Orchestration, 073 Evaluations and 089 Deployment. This route follows a system from model capability into a production application.

Student and educator route

Begin with 001–004, then study 005 Uncertainty, 038 Verification, 047 Memory, 050 Provenance, 071 Hallucinations, 073 Evaluations, 078 Privacy and 091 Education. The focus is not turning every learner into an ML engineer. It is developing judgment about what an SI output shows and what it does not show.

Agent route

Read 004 carefully, then move through 036 Planning, 041 Context Engineering, 047 Memory, 051 Tool Use, 052 APIs, 053 Connectors, 054 Agents, 055 Workflows versus Agents, 056 Agent Loop, 057 Computer Use, 059 Multi-Agent Systems, 060 Orchestration, 073 Evaluations and 077 Permissions.

Infrastructure and leadership route

Begin with the system distinction in 001–004, then read 073–080 and 081–090 before the sector applications in 091–100. This route emphasises operating conditions, evaluation, governance, resources and the institutional responsibilities surrounding deployment.

Comprehension Checkpoint 1: Can You Separate the Layers?

Question: a model gives the correct answer when the right passage is pasted into the chat, but gives the wrong answer when an application retrieves the passage automatically. Is that enough evidence to say the model is the main problem?

Answer: no. The controlled condition shows that the model can handle at least those examples when given the correct evidence. Inspect retrieval and context assembly first. The model could still have limitations, but this failure has not isolated them.

Question: an assistant writes an excellent email but was asked only for a draft. It then sends the email because a mail tool is available. Is this primarily a writing-quality problem?

Answer: no. The content can be excellent while the action exceeds the task authority. This is an autonomy, permission or tool-control problem.

Comprehension Checkpoint 2: Can You Trace a Claim?

Suppose an SI answer says, “The policy changed in September.” A traceable system should let you determine whether September came from the user, a retrieved document, a calculation or the model’s own generation. The method of checking depends on that origin.

If the date comes from a retrieved policy, inspect the document and effective date. If it comes from a calculation, inspect the inputs and arithmetic. If it is generated without evidence, treat it as unsupported until a source is found.

This is one of the most useful SI literacy habits because it works across products. Interface design, model names and tool ecosystems can change; the distinction between supplied, retrieved, calculated, observed and generated claims remains valuable.

Comprehension Checkpoint 3: Can You Recognise Unnecessary Complexity?

Task: rewrite one paragraph for clarity using only the paragraph itself. Do you need an autonomous agent, persistent memory, web retrieval and five external tools? Probably not. A bounded language-model call may be the simpler design.

Task: monitor a changing public dataset, compare new releases, update a report and notify a person when a threshold is crossed. Now retrieval, scheduling, state, tools, verification and a repeated workflow may be justified.

The mature question is not “How much SI can we add?” It is “Which responsibilities does this task actually need, and what evidence will show that each responsibility is working?”

Common Misconceptions This Series Will Correct

Misconception 1: the chatbot is the model. The visible product can include retrieval, tools, memory, orchestration and policy layers around one or more models. Misconception 2: more context is always better. Irrelevant or conflicting information can make a task harder to manage.

Misconception 3: tool use proves the model knew the answer. A model can delegate arithmetic or search to external systems. Misconception 4: a citation automatically proves the claim. The source must actually support the nearby statement and be the appropriate version.

Misconception 5: autonomy and intelligence are the same scale. A highly capable model can be given no authority to act, while simple software can have dangerous permissions. Misconception 6: a longer reasoning trace guarantees a better answer. The relevant test is the quality of the result under the task conditions.

Misconception 7: current information must be inside the model. Retrieval and tools can supply current evidence during use. Misconception 8: one successful demonstration proves reliability. A reliable claim needs representative evaluation and failure testing.

The Core Vocabulary of the Hub

Model: a learned computational component. Inference: running a trained model on input. Context: task-relevant information supplied for the current inference or sequence. Retrieval: obtaining external information needed for the task. Tool: an external capability the application can invoke.

Agent: in this series, a system in which model-guided decisions can select among permitted steps over a task loop. Workflow: an orchestrated sequence whose control may be more predefined. Evaluation: a defined method for testing behaviour or outcomes. Autonomy: the amount of work that proceeds without additional human intervention.

Provenance: where information came from. Grounding: connecting an answer to relevant external evidence or observation. Verification: checking a claim, calculation or resulting state. Permission: the authority to perform a particular operation on a particular resource.

What the Hub Will Not Pretend

The series will not present every AI system as a language model. It will not equate token prediction with the whole of intelligence. It will not treat human learning and model training as identical. It will not call a proposed future capability an established present fact.

It will also avoid using article length as evidence of authority. The purpose of the Clementi floor is completeness: hidden transitions, worked examples, diagnostic distinctions, practical methods, observable progress and independent transfer. Repetition does not satisfy that standard.

The hub therefore serves two jobs at once. It is a directory for the 100 supporting articles, and it is a first-principles lesson that lets a reader understand why those articles belong together before opening any of them.

Your First Independent SI Mapping Exercise

Take a harmless task you know well. Example: “Summarise this two-page note and create three questions I can use to check whether I understood it.” Write down the outcome, source, model capability, optional tools, verification and authority boundary.

A reasonable answer is: outcome = concise summary plus three questions; source = the supplied note; model capability = reading, synthesis and question generation; retrieval = unnecessary unless external facts are requested; tools = unnecessary unless saving a file is requested; verification = compare summary claims with the note and attempt the questions; authority = no external action required.

Now change one condition: “Save the final questions to my study folder.” A file tool and target identity become relevant. Change another: “Use the latest school notice too.” Retrieval or an approved document source becomes relevant. The architecture changes because the task changed.

If you can perform that mapping, you already understand the central logic of How Super Intelligence Works. The remaining articles deepen each component until the reader can move from a simple mental map to technical and operational detail.

A Reading Map for the Complete Curriculum

The ten parts follow a practical sequence: understand the whole system; understand its representations; study learning and inference; add knowledge and tools; examine other media and physical action; then study reliability, infrastructure and applications.

Jump to system foundations, representations and model mechanics, training, inference and reasoning, context and memory, tools and agents, multimodal systems, reliability and control, infrastructure or applications and the frontier.

Every supporting title belongs to the “How Super Intelligence Works” series. The numbering identifies its place in the curriculum, not a ranking of importance. Several ideas will be revisited from different angles, but each article has one principal explanatory job.


Part 1: The Complete SI System — Articles 001–010

Begin with the boundaries. What is the system meant to do? Which component supplies the capability? What information is available? What can change outside the conversation? These questions create the framework for the technical material that follows.

001. The Whole Stack — From Human Intent to Machine Action. Published foundation. The complete architecture, explained through a task whose input, output, evidence, permission and human responsibilities can be traced.

002. From Input to Output — What Actually Happens After You Ask. Published foundation. Follow one request from input preparation through computation, retrieval, tools and a checked result.

003. Model versus System — Why the Model Is Only One Part of SI. Published foundation. Compare application design, connected evidence and task reliability when the underlying model may be unchanged.

004. Capability versus Autonomy — Being Smart Is Not the Same as Being Allowed to Act. Published foundation. Distinguish task performance from permissions, authorisation, delegation and human control.

005. Prediction, Probability and Uncertainty. Published. Explain logits, token probability, thresholds, calibration, sampling, uncertainty and why likely output is not the same as verified truth.

006. Why Language Models Can Do More Than Language. Published. Examine how token sequences can represent code, tables, labels, instructions and structured tasks, and how tools extend the wider system.

007. SI versus Traditional Software. Published. Compare learned behaviour with explicit rules, authoritative state, deterministic validation and hybrid system design.

008. SI versus Search Engines. Published. Distinguish crawling, indexing, ranking, retrieval, RAG, generation, freshness and evidence.

009. SI versus Databases. Published. Separate learned representations from stored records, exact queries, transactions, vector retrieval and authoritative state.

010. The SI Failure Map — Where the Full Pipeline Can Break. Published. Trace failures across task definition, sources, representation, retrieval, models, tools, permissions, execution, verification and reporting to their first unstable point.

Part 2: Representation and Model Mechanics — Articles 011–020

This part moves inside the computational representation. Its purpose is to make numerical processing understandable without pretending that a token is a thought or that a neural-network layer is a literal map of a human mind.

011. Tokens — The Units a Language Model Processes. Published. Explain vocabulary items, token IDs, subwords, special tokens, context budgets and why tokens do not correspond neatly to words.

012. Tokenisation — How Text Becomes Model Input. Published. Follow normalization, pre-tokenization, BPE, WordPiece, Unigram, special-token processing, padding, truncation and decoding.

013. Embeddings — Turning Information Into Numerical Representations. Published. Explain token, sentence and document embeddings, learned vector geometry, cosine similarity, semantic search, retrieval evaluation and representation-version discipline.

014. Vector Space — How Similarity Becomes Geometry. Published. Introduce dimensions, norms, dot products, cosine similarity, distance, projections, high-dimensional neighbourhoods and the limits of interpreting geometric closeness.

015. Neural Networks — How Layers Learn Patterns. Published. Build from weighted sums and nonlinear activations through loss, backpropagation, gradient descent, optimisation, regularisation and generalisation.

016. Transformers — An Important Architecture for Language Models. Published. Assemble embeddings, positional information, QKV attention, multi-head attention, feed-forward networks, residuals, causal masks and KV caching into a complete sequence model.

017. Attention — Combining Information Across Positions. Published. Introduce queries, keys, values, masks, softmax, multi-head attention, cross-attention and KV cache while keeping attention separate from conscious human attention.

018. Parameters and Weights — What Training Changes. Published. Explain learned numerical tensors, checkpoints, trainable versus frozen state, fine-tuning, LoRA, quantisation and why parameter count alone does not specify system usefulness.

019. Layers — How Representations Transform. Published. Follow information through successive layers, residual blocks, probes, ablations and causal interventions while avoiding one-concept-per-layer interpretations.

020. Context Windows — The Information Available for an Inference. Published. Explain token budgets, history, retrieval, truncation, long-context evaluation, KV-cache constraints and why fitting information into a window does not guarantee reliable use.

Part 3: Training and Machine Learning — Articles 021–030

Training is where model parameters are developed or adapted. This part asks what signal the model is trained against, where the examples come from and how improvements should be tested beyond the training material.

021. Pretraining — Learning Before the User Arrives. Published. Explain prediction objectives, loss, batches, checkpoints, validation, transfer, scaling and how broad capability is learned before a user’s task begins.

022. Training Data — What the Model Learns From. Published. Examine collection, filtering, coverage, deduplication, provenance, contamination, synthetic data, privacy, bias and dataset governance.

023. Self-Supervised Learning — Learning Signals From Data. Published. Explain next-token prediction, masked modeling, contrastive learning, denoising, representation learning and downstream transfer.

024. Backpropagation and Gradient Descent. Published. Connect forward passes, loss, chain rule, gradients, learning rates, optimisers, numerical stability and parameter updates through worked examples.

025. Scaling — Models, Data and Compute. Published. Study scaling laws, model-data-compute balance, Chinchilla-style compute allocation, diminishing returns, inference cost and deployment-optimal scale.

026. Post-Training — Adapting a Model for Useful Behaviour. Published. Explain supervised fine-tuning, instruction tuning, RLHF, DPO, RLAIF, tool-use training, safety shaping and regression testing.

027. Instruction Following — Learning to Respond to Requests. Published. Separate instruction tuning from runtime prompting and examine constraints, hierarchy, ambiguity, tool schemas, prompt injection and stop conditions.

028. Preference Learning — Comparing Candidate Outputs. Published. Explore pairwise preferences, reward models, RLHF, DPO, AI feedback, rater bias, reward hacking and the difference between preference and truth.

029. Synthetic Data — Machine-Generated Training Material. Published. Examine generation, filtering, verification and diversity, including why producing more examples does not by itself establish better learning.

030. Distillation and Specialisation. Published. Explain transferring behaviour into smaller or focused models, and the evaluations needed to determine which capabilities survive the change.

Part 4: Inference, Reasoning and Planning — Articles 031–040

This part studies the work performed during use. It distinguishes producing a candidate, exploring alternatives, checking constraints and verifying an answer. Describing a process as reasoning does not remove the need to inspect its results.

031. Inference — Running a Trained Model. Published. Explain runtime inputs, computation and outputs, including the difference between model execution and the full application request lifecycle.

032. Next-Token Prediction — A Mechanism, Not the Whole System. Published. Connect autoregressive generation to complex outputs while avoiding the claim that every AI architecture works this way.

033. Machine Reasoning — Working Through a Problem. Published. Examine decomposition, search, verification and structured problem solving without treating generated explanations as complete access to internal computation.

034. Test-Time Compute — Additional Work at Inference. Published. Study sequential reasoning, candidate sampling, verifier-guided selection, search, adaptive budgets and stopping rules.

035. Problem Decomposition — Dividing a Difficult Task. Published. Explain task graphs, dependencies, subproblem boundaries, parallel work, recombination and global verification.

036. Planning — Choosing and Revising Steps. Published. Connect goals, state, actions, preconditions, resources, constraints, replanning, execution monitoring and approval.

037. Search — Exploring Possible Solutions. Published. Explain BFS, DFS, A*, beam search, MCTS, heuristics, pruning, Tree of Thoughts and verifier-guided solution search.

038. Verification — Checking Rather Than Merely Generating. Published. Verify sources, calculations, code, schemas, tool outcomes and resulting state with claim-matched evidence and regression tests.

039. Mathematics and Code — Working in Checkable Domains. Published. Connect model reasoning to calculators, symbolic algebra, tests, compilers, solvers and proof assistants while preserving the original specification.

040. Confidence and Calibration. Published. Separate token probability, model scores and calibrated reliability through reliability diagrams, proper scoring rules, drift monitoring and selective prediction.

Part 5: Context, Retrieval, Knowledge and Memory — Articles 041–050

This part follows information into the current task and across tasks. The central questions are what is available, where it came from, whether it is still valid and who is permitted to use it.

041. Context Engineering — Preparing the Working Information. Published. Engineer the task environment across instructions, evidence, memory, retrieval, tool schemas, current state, compression and trust boundaries.

042. Instructions — Goals, Rules and Task Boundaries. Published. Study instruction roles and conflicts, including why text inside an external source should not acquire the user’s authority.

043. Long Context — Reading More Without Losing the Task. Published. Examine document length, relevance, evidence placement and the checks needed when large inputs contain competing versions or distractions.

044. Retrieval — Finding Missing Information. Published. Follow query formation, source selection and returned evidence, including the difference between finding something relevant and finding something authoritative.

045. Semantic Search — Retrieving Beyond Exact Words. Published. Explain embedding-based retrieval and its relationship to keyword search, metadata filtering and the particular information need.

046. Retrieval-Augmented Generation — Evidence Before an Answer. Published. Assemble a RAG pipeline and diagnose failures in retrieval, context preparation, interpretation and citation support.

047. Memory — Carrying Selected Information Forward. Published. Separate application storage, retrieved history and model parameters. Examine correction, purpose and the risks of preserving obsolete conclusions.

048. Working, Episodic and Semantic Machine Memory. Published. Use these functional categories to compare designs while explaining where analogies with human memory become misleading.

049. Knowledge Freshness — Keeping Evidence Current. Published. Explain dates, versions, live queries and update paths, including how an unchanged model can receive newly available information.

050. Provenance and Citations — Tracing a Claim. Follow a statement to its supporting source, distinguish quotation from inference and identify when a citation does not support the claim.

Part 6: Tools, Agents and Machine Action — Articles 051–060

The moment an application can act through software, the analysis must include permissions, target identity and resulting state. A generated instruction is not an executed operation, and an executed request is not always a confirmed success.

051. Tool Use — Extending Capability Beyond the Model. This topic shares the practical SI tools guide. Explain calculators, search, file operations and other external functions through the evidence they return and the boundaries they require.

052. Function Calling and APIs — Structured Software Interaction. This topic shares the practical API guide. Follow a proposed call through argument validation, execution and result handling, keeping generated text separate from trusted authority.

053. Connectors and Context Protocols. Start with the complete connection-to-result exercise in the shared connector guide. Explain interoperable access to data and tools, including why connecting a service does not authorise every available operation.

054. Agents — Models Inside Repeating Work Loops. This topic shares the practical agent guide and its complete action-and-observation case. Define an operational agent through its environment, choices, observations, state and stopping conditions rather than through a marketing label.

055. Workflows versus Agents. This topic shares the practical agent guide. Compare fixed orchestration with model-directed steps and identify when each arrangement fits the variation and consequences of the task. For the companion workflow comparison, read choosing fixed boundaries and adaptive steps.

056. The Agent Loop — Observe, Decide, Act and Check. Follow the complete action-and-observation traces, repairs and stopping tests in the shared agent guide. Trace progress across steps, including how to recognise repeated activity that is not reducing uncertainty or completing work.

057. Computer Use — Working Through an Interface. Published. Examine screenshots, interface state, action selection and verification, with attention to ambiguity and changing layouts.

058. Research Agents — Finding and Comparing Evidence. Published. Follow source discovery, reading, synthesis, claim ledgers and verification through a complete fictional device-selection case. Learn why an extensive search can still yield an unsupported conclusion.

059. Multi-Agent Systems — Delegation, Evidence Handoffs and Shared Errors. Published. Follow a complete fictional school-library research desk through a source agent, calculator, evidence auditor and coordinator; distinguish forty attendance events from twenty-eight different pupils, inspect conditional reliability and independently solve an overlap case. For broader theory, read Multi-Agent Systems and Collective SI.

060. Orchestration — Coordinating Models, Tools and Tasks. Use the worked workflow guide to understand routing, dependencies, state ownership, error handling and the control layer that keeps a larger workflow coherent.

Part 7: Multimodal and Embodied SI — Articles 061–070

Text is only one kind of input and output. This part examines images, sound, documents, video, spatial information and physical systems. Each introduces its own representation problems and its own ways to check whether the result matches reality.

061. Vision — Interpreting Images. Follow pixels and preprocessing into task-dependent interpretation, then inspect two complete scenes, exact crops, masks and worked repairs.

062. Image Generation — Producing Pictures From Representations. Compare documented generation mechanisms, calculate a reconstruction, and repair supplied visual specifications while keeping illustration separate from evidence.

063. Speech and Audio. Distinguish recognition, turn labels, sound events and synthesis through complete fictional records, uncertainty repairs and answered transfer exercises.

064. Video — Information Across Space and Time. Inspect complete timelines, sparse and dense samples, changed offsets and event order, with worked duration bounds and independently answered transfer exercises.

065. Documents — Pages, Tables and Mixed Layouts. Reconstruct two complete document packets, repair extraction errors, and preserve units, footnotes, missing values and source locations through worked answers.

066. Code Execution — Running and Checking Generated Work. Published. Separate code generation from sandboxed execution and readback, then use a complete fictional reading-log programme to diagnose duplicate records, data contracts and checked results.

067. Spatial Reasoning — Position, Objects and Environments. Published. Follow coordinate frames, image points, object relations and a complete route-planning grid with independent doorway and rotation checks.

068. Robotics — Perception, Control, Feedback and Verified Physical Action. Published. Work through a fictional cart grid, a five-step obstacle-avoiding detour, success probabilities, observation delay, state estimation and an independent changed-map exercise. For the wider physical-world discussion, read Robotics and Embodied Intelligence.

069. Sensors and Edge Intelligence. Published. Examine sensing, local computation, missing data, intermittent connections, packet budgets and evidence boundaries through complete greenhouse and museum teaching cases.

070. World Models and Simulation. Published. Follow a state-and-action model through fictional cart transitions, calculate joint success probabilities, compare independence with correlated failures and distinguish simulated futures from actual observations.

Part 8: Reliability, Evaluation, Safety and Security — Articles 071–080

A useful system needs more than a successful demonstration. It needs appropriate tests, visible limits and a repair route. NIST’s AI Risk Management Framework provides a voluntary reference for considering trustworthiness across an AI system’s lifecycle.

071. Hallucinations — Diagnosing and Repairing Unsupported Claims. Published. Audit an invented seminar evidence packet, compare superseded documents, expose fabricated details and repair the final answer at the level of each claim.

072. Grounding — Connecting Answers to Evidence. Published. Match workshop capacities, eligibility and historic price notices to the exact claims they justify, then independently test whether the same logic transfers to equipment specifications.

073. Evaluations — Testing the Real Task. Published. Work through a forty-message classification packet, full precision/recall calculations, threshold trade-offs, grader limits and a second solved feedback-checking exercise.

074. Benchmarks — What Scores Measure, Hide and Miss. Published. Compare fictional library leaderboards, calculate how task mixtures reverse rankings and learn what a score cannot prove about real-world use.

075. Red Teaming — Finding Failures, Repairing Controls and Retesting. Published. Practise authorised adversarial checks, observe what actually fails, classify the consequence and test the repaired controls before wider use.

076. Prompt Injection and Tool Manipulation. Published. Follow untrusted text through a fictional notice-summarising workflow, separate source content from authority, and see why deterministic tool permissions and action readback are necessary.

077. Permissions, Sandboxes and Containment. Published. Work through a two-identity access matrix, scratch-space boundaries, scoped approvals and expiry rules, then transfer the method to a fictional museum cataloguing task.

078. Privacy and Data Security. Published. Follow a fictional reading-club attendance packet through purpose, restricted access, aggregate calculations, logs and disclosures, then transfer the method to museum attendance.

079. Bias, Fairness and Representation. Published. Compare invented eligibility-review channels using complete confusion matrices, precision, recall, false-positive rates, reference-label checks and an independent third-channel case.

080. Alignment, Oversight and Human Control. Published. Trace an invented school bulletin from source comparison and AI proposal to bounded approval, possible publication and independent verification, with explicit stop and recovery conditions.

Part 9: Compute, Infrastructure and Operating Costs — Articles 081–090

Digital intelligence still depends on physical and operational resources. This part asks what keeps a service available, how work is distributed and how performance should be assessed against the result the user actually needs.

081. GPUs and Accelerators — Parallel Computing, Memory and Real Bottlenecks. Published. Use the fictional Number Tiles laboratory to compare kernel time, host–device transfers, memory budgets and verified whole-task outcomes. For a complementary independent calculation, read GPUs and Accelerators — Parallel Arithmetic, Memory and Bottlenecks, which works a 2,048-by-4,096 array, exact MiB storage and a memory-bandwidth transfer exercise. Both are published specialist reading routes.

082. Data Centres — Power, Cooling, Reliability and the Real Cost of Compute. Published. Follow IT power, facility overhead, cooling and resilience through a complete fictional facility audit. For a contrasting worked case where the PUE improves but total electricity rises, read The Data Centre Efficiency Paradox; it is a specialised companion, not a second numbered chapter.

083. Distributed Training — Replicas, Gradients, Sharding and Coordination. Published. Calculate a four-worker shared gradient and the true global batch size, then compare synchronised data parallelism, sharded memory, communication, failures and an independent three-worker transfer case.

084. Inference Infrastructure — How Model Requests Are Served. Published. Follow a request through model selection, worker queues, scheduling, batching and verified delivery; calculate six fictional request-completion times and memory limits before attempting an independent arrival-pattern transfer.

085. Latency and Throughput — Queues, Tail Delays and Real User Experience. Published. Work through a ten-request timing packet, calculate mean, median, nearest-rank p90 and p95, then compare streaming first-token time, total completion and overload.

086. The Cost of Intelligence — Tokens, Rework and Complete Results. Published. Compare two fictional feedback systems: the cheaper token bill can be the costlier completed workflow once human correction is counted. Includes original cost ledgers, sensitivity cases and transfer practice.

087. Energy, Water and Environmental Load — What AI Resource Numbers Mean. Published. Distinguish facility electricity, PUE, WUE, direct and upstream water and modelled emissions through two annual fictional facilities and a verified energy–water trade-off calculation.

088. Quantisation, Caching and Compression — Smaller Models, Reused Work and Quality Checks. Published. Compare lower-precision representations with caching and compression, then inspect a complete numerical Decimal Tiles example and Twelve Requests prefix-reuse laboratory with independent checks and limits.

089. Deployment, Monitoring and Versioning — Release, Detect and Recover. Published. Follow an invented Cedar Tutor release, compare overall gains with important regressions, then examine rollout gates, canary testing, drift, independent monitoring, versioned evidence and rollback.

090. Open, Open-Weight and Proprietary Models — Access, Rights and Real Trade-offs. Published. Use the Four Model School decision case to separate downloadable weights from software and training information, licences, commercial rights, local operation, adaptation, maintenance, task quality and the OSI Open Source AI Definition.

Part 10: Applications and the Intelligence Frontier — Articles 091–100

The final part applies the mechanism map to real kinds of work. These articles will explain how systems function in their domains; they are not promises that every proposed use is reliable, appropriate or ready for unsupervised deployment.

091. Education — From AI Answers to Independent Learning and Transfer. Published. Follow a complete fictional Algebra Bridge lesson through negative-bracket diagnosis, first-principles explanation, graduated hints, error checking, retrieval, independent Mathematics and Science transfer, feedback and teacher oversight.

092. Science — Literature, Hypotheses, Experiments and Evidence. Published. Follow a full fictional Alto Light Lab study from a falsifiable prediction through controlled readings, independently checked averages, a contradicted hypothesis and a changed-baseline transfer exercise. Learn why literature, simulations and generated explanations are not observed experimental results.

093. Healthcare and Medicine — Evidence, Workflows and Qualified Oversight. Published. Trace the distinction between an AI’s information processing and authorised clinical decisions through a fictional nonclinical forms-checking packet, complete confusion-matrix calculations, WHO and FDA governance and a changed-context exercise.

094. Software Engineering — From Code Suggestions to Tested Changes. Published. Diagnose a fictional Scorebook denominator bug, distinguish missing values from genuine zero scores, build meaningful unit and regression tests, and follow the change from source code to reviewed, verified software.

095. Creativity and Media — Human Authorship, AI Generation and Evidence. Published. Follow a fictional six-frame museum storyboard through human direction, candidate selection, continuity checks, rights and source provenance, accessibility and independent learning; distinguish generated illustration from documented fact.

096. Business and Institutions — Handoffs, Approvals and Verified Outcomes. Published. Follow a fictional tutorial office through forty enquiries, source ownership, staff review, missing information and confirmed outcomes; calculate workflow progression and a hypothetical time budget, then transfer the method to a museum.

097. Cybersecurity — Defensive AI, Trust Boundaries and Verified Incidents. Published. Work through a sixty-event synthetic detection matrix with precision, recall and false-positive rates, then examine prompt injection, tool scope, incident-state verification and a changed eighty-event transfer packet.

098. Government and Public Systems — Verified Information, Human Decisions and Accountability. Published. Follow a fictional civic information desk through thirty enquiries, current official notices, caseworker decisions, missing records, accessibility, transparency, appeal routes and independently checked public-service statuses.

099. AGI, ASI and Recursive Improvement — Definitions, Evidence and Limits. Published. Separate performance, generality and autonomy, then evaluate a fictional four-version AI development loop whose standard scores improve while transfer results regress. Learn why a mathematical feedback model does not prove unlimited self-improvement.

100. The Civilisation-Scale SI Stack — People, Institutions, Infrastructure and Verified Outcomes. Published. Close the full curriculum by tracing a fictional cross-sector learning network from human intent and sources to permissions, multi-agent coordination, human review, infrastructure and actual outcomes. Includes one-hundred-case completion, conditional reliability, resource-allocation and independent transfer laboratories.

Specialist companion articles beyond the 100 numbered chapters

Protocol engineering: MCP and A2A Protocols — Tools, Tasks, Artifacts and Trust Boundaries explains what differs between an external-tool call and an agent-to-agent task. Its fictional museum case follows source lookup, task states, permissions, failure handling and independent source verification. It is an unnumbered companion to 059. Multi-Agent Systems, not a duplicate numbered topic.

Other advanced reading: The Data Centre Efficiency Paradox expands the facility-energy ratio case in topic 082; Multi-Agent Systems and Collective SI examines collaboration at a broader theoretical level; and Robotics and Embodied Intelligence complements the bounded grid-control exercise in topic 068. Follow the linked topic owners first when learning a new mechanism.

Agent Systems Engineering — Four Applied Companion Laboratories

The 100 numbered chapters provide the foundations. These four newer, unnumbered technical guides continue from MCP and A2A Protocols into the engineering of an accountable tool-using agent. They are distinct worked laboratories rather than replacements for the numbered chapters.

Learning sequence: First define an acceptable result, then establish who may act, make repeated actions safe, and finally reconstruct what happened with independent evidence. Connect this route back to 059. Multi-Agent Systems, 073. Evaluations and 089. Deployment, Monitoring and Versioning. The Gold Standard of Education provides the transfer-into-life learning rationale.

Agent Runtime Reliability — Four New Specialist Companion Laboratories

Continue from the completed numbered SI curriculum and the earlier MCP/A2A protocols and Contract-First Agents companions. These four distinct articles focus on how a real task survives interruptions, reacts to events, recovers from partially completed operations and meets a measurable reliability goal. They are unnumbered additions, not replacements for chapters 001–100.

Suggested progression: preserve trusted workflow state, accept only supported event changes, reconcile or compensate multi-service effects, and assess the complete service against a user-centred reliability objective. For evidence and monitoring, connect to Agent Observability and Deployment, Monitoring and Versioning. The immutable Clementi reference article remains unchanged.

Agent Runtime Resilience — Four New Specialist Learning Laboratories

These four unnumbered articles continue the Durable Workflows, Agent Sagas, Reliability and Observability branch. Each uses its own original worked example, so the existing numbered chapters 001–100 remain intact.

Suggested sequence: protect the overloaded dependency, test faults within authorised bounds, reconcile source versions and user-visible state, then coordinate human recovery and verify corrective action. This connects back to How X Works and The Gold Standard of Education. The Clementi editorial reference remains unchanged.


How to Use the Hub Without Reading Everything in Order

A beginner should start with the four published foundations. They explain what the system contains, what happens during a request, why the model is not the whole application and why capability does not automatically grant authority.

A builder can then follow the curriculum through context, retrieval, tools and evaluation. The important exercise is to map a real task to specific components and tests. A fashionable architecture is not a substitute for knowing which problem the application must solve.

An educator can follow the distinction between generated output and learning. Ask what the student must still retrieve, explain, apply and check independently. SI can be part of a learning activity without becoming the evidence that learning has occurred.

A manager or researcher can follow responsibility across the system: who owns the data, who authorises action, who evaluates the result and who repairs failures? These questions remain useful as individual models and products change.

A Reality Check Before Trusting an Answer

Choose one important claim in a response and follow it backwards. Was it supplied by the user? Retrieved from a source? Calculated by a tool? Inferred by the model? Each route calls for a different kind of check.

Then inspect the claimed action. Was a document only drafted, or was it saved? Was a page merely prepared, or was it published? Does the returned link identify a real result? A completion statement should not exceed the evidence available.

Finally, identify what remains uncertain. A missing source, unresolved ambiguity or untested assumption should remain visible. The goal is not to demand impossible certainty from every interaction. It is to make the confidence and the action appropriate to the task.

Frequently Asked Questions About How Super Intelligence Works

Is SI a different technology from AI?

In this series, SI is the editorial name used for AI technologies. It is not a new scientific category or a claim of achieved artificial superintelligence. Standard technical vocabulary remains alongside it so that readers can find and understand the underlying research.

Does every SI system use a transformer?

No. The curriculum includes transformer-based language models because they are important to the systems being discussed, but it does not reduce all machine learning or all AI applications to one architecture. Each mechanism article will state its scope.

Does an SI system automatically know current information?

Do not assume so. Current information needs an appropriate source and an actual update or retrieval route. A model’s learned knowledge, the current conversation and an external database are different sources of information with different limitations.

Do I need advanced mathematics to begin?

No. Begin with the system-level examples. Later technical articles will introduce the mathematics needed for particular mechanisms rather than assuming that every reader already understands vectors, gradients or probability.

Are all 100 supporting articles already published?

Yes. All 100 numbered topics, 001–100, now have verified published reading routes. Positions 059, 068 and 100 have been filled with distinct full-length chapters and are linked above. Selected other topics link to previously published comprehensive guides where that avoids duplicating existing material. Each numbered reading route leads to actual content rather than an invented or unpublished URL.

How is this different from the general intelligence series?

This hub owns the engineered machine-intelligence explanation: representations, models, applications, tools and controls. The wider How Intelligence Works series considers intelligence more broadly. Related ideas can connect without treating human learning and model training as identical processes.

From an Impressive Answer to an Understandable System

Understanding how Super Intelligence works begins when we stop treating the final answer as the whole event. There was a task, an information route, a computation and sometimes an external action. Each stage has conditions under which it can succeed or fail.

The purpose of this curriculum is to make those conditions legible. When readers can distinguish capability from authority, retrieval from knowledge, generation from verification and a model from its application, they can ask better questions and build more dependable uses.

Begin with The Whole Stack, then follow one request from input to output. For the educational habits behind responsible use, continue to The Importance of AI Literacy.

For the wider framework that connects this topic to learning, work, agents, verification, human judgment and the future, continue through the Super Intelligence master guide.

For the wider framework connecting this topic to learning, work, agents, verification, human judgment and the future, continue through the Super Intelligence master guide.

Continue through the SI knowledge web with Super Intelligence master guide. For the complete map, return to the Super Intelligence master guide.

Applied Agent Engineering — Recovery, Changes, Reviews and Routing

When an AI assistant starts taking real actions, useful questions move beyond the answer on a screen: Can work recover without duplicate effects? How should a changed instruction be released? When does a person need to decide? Which kind of reasoning is enough for this particular task? These four practical chapters extend the foundations above with original, fully explained exercises and checkable decision routes.

For the surrounding reliability sequence, also read incident response, controlled fault testing and data consistency. The distinction throughout is between a proposed step and an independently verified result.

Applied Agent Engineering — Evidence, Credentials, Tool Integrity and Data Erasure

Continue the practical agent-engineering sequence with four questions that connect technical mechanisms to genuine accountability: What evidence supports an action? Does the tool still have the right access? Can its executable be trusted? And what happens when information must be removed across active and retained copies?

Return to the earlier model routing, change control and disaster recovery lessons for the surrounding context. The central method is to distinguish what an agent proposed from the user authority, trusted source evidence and independently verified effects.

Applied Agent Engineering: Fairness, Reasoning, Evidence and Time

These specialist companions extend the practical system design route. They address distinct decisions: who gets scarce service, how much computational work is justified, whether multimedia claims are aligned to evidence, and which source or approval was valid at the relevant instant.

Build from the previous model routing, human review queue and evidence ledger chapters. Keep a model proposal, authorised operation and independently checked result separate throughout.

Applied Agent Engineering: Migration, Evidence and Testing

Continue from workflow durability and human oversight into four practical specialist guides. Each gives first-principles mechanisms, worked cases, source notes and a way to test a changed situation. These describe safeguards for present-day AI-assisted systems, not a claim that artificial superintelligence already exists.

For prerequisites, read durable workflows, evidence ledgers, reviewer calibration and evaluations. Compare proposed answers with authorised actions and independently observed outcomes.

Applied Agent Engineering: Ownership, Assurance, Access and Feedback

These four specialist routes follow the core agent engineering lessons. They connect safe resource handoffs, evidence-based release decisions, meaningful user control and the difficulty of measuring outcomes that arrive later. Each has original worked examples, explicit limits and independently checkable methods for present-day AI-assisted systems; none assumes artificial superintelligence already exists.

Read the adjacent foundations in workflow migrations, test oracles, reviewer calibration and evidence ledgers. Keep model proposals, authorised operations and independently verified user outcomes distinct.

Applied Agent Engineering: Isolation, Coordination and Verification

These new specialist readings connect distributed resource coordination with confidential multi-tenant data boundaries, genuinely independent judgement and formal workflow safety. Each teaches its own mechanism through original worked cases, honest limitations and practical transfer. The methods concern current AI-assisted systems rather than a claim that hypothetical artificial superintelligence already exists.

Read related foundations in Cross-Agent Resource Ownership, Agent Identity and Delegation, Agent Test Oracles and Workflow Migrations. Always distinguish an AI proposal, a valid human authority, a checked source and the actual final operation.

Specialist Agent Engineering: Numeric Results, Files, Complete Collections and Streams

These four practical lessons follow different integrity boundaries in AI-assisted workflows. Choose the guide that matches the failure you need to prevent: numeric meaning, untrusted uploaded bytes, incomplete paginated reads or provisional streaming output. Each chapter separates a convincing AI explanation from independently checked final evidence.

  • Agent Numeric Integrity — Units, Decimal Rounding and Reconciliation
  • Agent File Ingestion — Untrusted Uploads, Archive Limits and Parser Isolation
  • Agent API Pagination — Cursors, Snapshots and Complete Retrieval
  • Agent Stream Integrity — Partial Outputs, Event Ordering and Commit Barriers
  • For the wider context, continue through the applied-agent chapters on idempotency, state-machine verification and multi-tenant permissions. A useful system must preserve both what the data says and who may act on it.

    Applied Agent Engineering — Trustworthy Partial-Answer Streaming

    Agent Partial-Answer Streaming — Provisional Text, Commit Boundaries and Recovery explains why visible chunks are not finished tasks. Follow source verification, distinct tool-effect receipts, revisions, network reconnection and final user-facing status through a worked eighty-intention case. This specialist complements the existing durable workflows and safe retry guides.

    Applied Agent Engineering: Service Quality, Data Location and Real Costs

    These specialist chapters show how useful AI-agent work depends on human attention, truthful partial service, bounded information flow and accountable economics. Each guide has a practical reader route, worked reasoning and precise limits. These mechanisms apply to present-day AI-assisted systems; none assumes artificial superintelligence exists.

    For prerequisites, read service-level objectives, backpressure, multi-tenant isolation and outcome feedback. Preserve the difference between a generated proposal, currently authorised action and independently verified real result.

    Specialist workflow control: Agent Cancellation — Stop Signals, In-Flight Actions and Verified Quiescence explains how to halt new AI-agent work, reconcile in-flight external actions, and prove the final stopped state without erasing or inventing previous outcomes.

    Specialist geospatial agent verification: Coordinate order, distance, location uncertainty and antimeridian-safe boundaries explains why automated map decisions require tested numerical and spatial operations.

    Applied Agent Engineering: Evidence, Permissions, Data Portability and Freshness

    Continue into four practical questions that appear as AI systems take on more real work: what may be exported, who must approve a consequential effect, how controlled cases can test safety without exposing pupils, and when cached answers become invalid. These are evidence-based safeguards for present-day AI-assisted systems, not claims that artificial superintelligence currently exists.

    For connected foundations, read data erasure, human review queues, test oracles and authoritative data consistency. Keep each user intention separate from model suggestions, trusted permissions and independently observed final effects.

    Applied Agent Engineering: Trusted Tools, Queries and Service Offboarding

    Four specialist lessons connect the technical interfaces that AI-assisted workflows trust with the human and operational controls needed when those interfaces change or close. Explore exact API contracts, signed incoming callbacks, permission-aware database reads and the verified end of a retired agent’s authority. Each guide includes practical examples, explicit limits and sources for further verification.

    For prerequisites, read Workflow Migrations, Event-Driven Agents, Multi-Tenant Isolation and Agent Cancellation. A model proposal, trusted current permission and independently verified external result remain distinct.

    Applied Agent Engineering: Safe Connections, Complete Evidence and Verified Interfaces

    These new specialist chapters explain four distinct ways an AI assistant can appear helpful while missing an essential boundary: connecting to a prohibited URL, omitting relevant evidence, losing a continuing user restriction or assuming that a browser click completed an external task. Follow their worked examples and testing methods to distinguish a proposed action from a permitted, independently verified user outcome.

    Foundation reading: Multi-Tenant Agent Isolation, Agent Test Oracles, Conflicting Evidence and Tool Contract Drift. The methods apply to present-day AI-assisted systems without assuming artificial superintelligence already exists.

    Applied Agent Engineering: Versioned Editing, Spreadsheet Proof, Citations and Email

    These four specialist guides connect the same important habit across different everyday tools: check exactly what is authorised, what source or revision governs the operation, and what the destination actually saved or accepted. They apply to today’s AI-assisted services without assuming hypothetical superintelligence has been achieved.

    Related foundations include Cross-Agent Resource Ownership, Numeric Integrity, Conflicting Evidence and Dual Control. Treat proposed text, genuine user permission and independently observed outcomes as distinct evidence.

    Specialist agent output safety: Agent Markdown Rendering — Untrusted HTML, Links, Remote Media and Safe Previews shows how to display generated answers without granting untrusted markup executable power, loading tracking images silently or hiding external link destinations; its checked laboratories connect browser safety with accessible presentation.

    For controlled multi-item actions and version-sensitive review, follow Agent Batch Writes — Partial Commits, Atomic Requests and Verified Reconciliation to separate request-wide success from each item’s outcome, and Agent Material Change Detection — Document Diffs, Effective Dates and Reapproval to distinguish cosmetic edits from changes that affect evidence, permission or the reader’s next action. Both use checked worked cases and independent readback rather than treating a tool response as proof of completion.

    For interrupted large-file retrieval and safe recovery, read Agent Download Resumption — HTTP Byte Ranges, Version Checks and Verified Files. It explains offsets, response validation and the requirement to commit only a complete, verified artifact.

    For outbound large-file transfers, study agent multipart uploads, ordered parts, checksum verification and safe abort recovery. This specialist guide treats final-object commit as different from successful part transfers.

    For agent workflows extracting structured facts from web pages, read Agent HTML Table Extraction — spanning headers, hidden rows and verified cells to preserve labels, units and reliable data provenance.

    For AI agents handling meeting invitations and revisions rather than simply running scheduled jobs, see Agent Calendar Invitations — UID, Sequence, RSVP and Safe Event Updates. It covers authenticated organiser changes, recurrence instances, cancellation scope and readback verification.

    To fill interactive PDF forms reliably, distinguish logical field values from rendered widget appearances, verify checkbox and radio export states, and preserve signatures and consent boundaries. Read Agent PDF Forms — Field Values, Widget Appearances and Safe Submission for a solved form example and release checks.

    For AI agents sending mobile alerts, read Agent Push Notifications — Delivery Uncertainty, Stale Actions and Verified Outcomes to distinguish provider acceptance from human action, enforce expiry, and verify current task state when a user taps an old message.

    For an agent running on a device with limited browser input, read OAuth device login with user codes, polling, expiry and safe authorisation to distinguish a person’s verified consent from a pending code or a privileged API action.

    Applied Agent Engineering: Privacy-Safe Logs and Reliable Database Events

    A trustworthy automation pipeline records what happened without duplicating private data and can recover correctly when a database commit, broker event or external result is uncertain. These new guides show how to protect sensitive traces, tie source changes to durable events and read back the user’s actual completed outcome.

    Continue with the companion chapters on Batch Writes, Material Change Detection and Agent Sagas. Each keeps actual user authorisation, source revision and target-state verification distinct.

    Applied Agent Engineering: Queue Recovery, Search Cutovers and Controlled Release

    These new specialist chapters follow four different boundary conditions for useful AI agents: messages that cannot finish normal queue processing, search collections rebuilt while sources change, temporary files that must stay within authorized paths, and new capabilities introduced gradually under trusted permissions. Each illustrates a worked example, current technical source guidance and the distinction between a tool action and the user’s independently verified outcome.

    Continue with Transactional Outbox, Cache Invalidation and Agent Change Control. All controls are described for present-day engineered systems, without assuming artificial superintelligence already exists.

    For the specialist integration problem where a server returns HTTP 202 Accepted rather than a finished result, read Agent Long-Running Operations — HTTP 202, Polling and Verified Completion. It explains durable operation handles, safe retries, cancellation uncertainty and proof of the final artifact without mistaking acceptance for success.

    For a practical account of how automated agents prove that an Internet naming change reached the authoritative sources, rather than trusting a control-panel acknowledgement, read Agent DNS Change Verification — Authoritative Records, Cache Divergence and Safe Cutovers. It distinguishes positive and negative caching, secure cutover gates, resolver sampling and confirmed downstream effects.

    For agent-controlled browser sessions that must not cross account boundaries, read Agent Session Cookies — SameSite, CSRF and Identity-Safe Browser Contexts. It explains how HTTP cookies accompany requests, where SameSite does and does not help, and why every mutation needs an independent identity and permission check.

    To distinguish a successful email API call from verified per-recipient delivery, and to handle bounce reports, delayed DSNs, suppression and human acknowledgement without double-counting, read Agent Email Delivery States — Bounces, DSNs and Recipient-Safe Recovery.

    Notification-driven agents can become silently stale if a watch expires while the callback remains healthy. See Agent Change-Notification Subscriptions — Renewals, Missed Events and Delta Recovery for a fully checked subscription timeline, provider-authorisation boundaries, replay-safe reconciliation and an honest explanation of what cannot be recovered.

    Browser-hosted agents must distinguish a successful server operation from a response that JavaScript is authorised to read. The specialist guide Agent CORS Decisions — Origins, Preflight Requests and Credential-Safe Responses explains the browser sharing boundary, preflight, cookies, error-path headers and a worked 12-request audit, with explicit checks for real business effects.

    When AI coding agents prepare changes to shared repositories, Agent Git Merge Safety explains dirty worktrees, verified commit ancestry, protected-branch review and why local merge success is not verified publication or deployment.

    For agents generating bounded SQL against changing databases, Agent SQL Schema Discovery explains why permitted metadata is not a complete global catalog, how reflection caches become stale and when a query must stop rather than guess an unavailable field.

    When AI agents exchange versioned records, Agent Protocol Buffer Compatibility explains stable field numbers, unknown data, ProtoJSON differences, mixed-version consumers and how to confirm a safe rollout without discarding meaning.

    For reliable AI-agent email workflows, Agent IMAP Mailbox Sync explains stable mailbox identity, UIDVALIDITY, expunge recovery, flag changes, CONDSTORE and QRESYNC without inventing send authority.

    For inbox and email assistants, Agent Email Authentication — SPF, DKIM, DMARC and Trusted Sender Boundaries explains how authenticated domains differ from visible From addresses and why even passing mail checks cannot authorise sensitive actions.

    How should research agents respect web crawling preferences? Agent Robots Exclusion — robots.txt Rules, Error States and Polite Crawling explains RFC 9309, user-agent groups, longest matching rules, unreachable policies and separate access and rate controls.

    When an AI agent must edit only part of an existing API record, Agent JSON Patch — Pointer Escapes, Atomic Edits and Safe Preconditions explains RFC 6902 operations, field identity tests, version guards and independent readback.

    For reliable HTTP retrieval, see Agent HTTP Digest Fields — Content-Digest, Repr-Digest and Verified Transfers, which separates payload integrity, partial representations, compressed bytes and sender authentication under RFC 9530.

    For API-connected coding and research agents, Agent OpenAPI Reference Resolution — URI Bases, Cycles and Safe Contract Loading explains how to interpret multi-document schema references, avoid incorrect pointer targets and keep external document retrieval within a verified tool boundary.

    For delegated account connections from input-constrained coding assistants and other current AI agents, read Agent OAuth Device Authorization — User Codes, Safe Polling and Phishing Boundaries, including RFC 8628 consent, expiry and independent token verification.

    For gRPC-based AI agents, Agent gRPC Deadlines — Status Codes, Propagation and Ambiguous Writes explains why a timeout does not prove rollback, how to propagate call budgets and verify original effects after uncertain responses.

    Agent UUIDv7 Identifiers — Time Ordering, Collision Budgets and Privacy explains RFC 9562 timestamps, random collisions, clock drift, safe retries and why an identifier never proves permission or exact chronology.

    For agent APIs using sender-constrained OAuth credentials, Agent DPoP Tokens — Signed Proofs, Nonces and Replay-Safe APIs explains proof JWTs, key binding, the RFC 9449 checks and how authenticated requests still require independent write-outcome reconciliation.

    For identity lifecycle engineering, Agent SCIM Provisioning — Identity Joins, Group Drift and Verified Deactivation explains durable identity matching, RFC 7643/7644 group operations, and why a successful disable request is not independently verified loss of access.

    For file and document agents using WebDAV, WebDAV Multi-Status — Per-Resource Outcomes, PROPFIND and Safe Reconciliation explains why HTTP 207 is not blanket success and how to verify individual property and resource results.

    When automated SFTP transfers must verify the actual remote endpoint rather than merely encrypt a connection, Agent SFTP Host Identity explains approved host keys, safe rotation, unverified key scans and honest delivery receipts.

    For cryptographically verified HTTP requests, HTTP Message Signatures — Covered Components, Replay Windows and Verified Requests explains RFC 9421 signature bases, required coverage, Content-Digest checks, replay protection and authorisation boundaries.

    When present-day AI agents exchange typed HTTP header values, learn how Agent HTTP Structured Fields — Items, Lists, Dictionaries and Safe Parsing keeps parsing separate from units, permissions and actions under RFC 9651.

    For browser-driven and web-reading agents, Agent HTTP 103 Early Hints explains provisional responses, safe resource preloading, final-status authority and cache confidentiality. A checked timing example shows when early resource announcements can help, while the safety discussion explains why hints are not instructions or permission to fetch unknown destinations.

    For safe human-approved account connections, read Agent OAuth PAR — Pushed Requests, Client Binding and Expiring Request URIs, which distinguishes a successful authorization-request push from actual user consent and token issuance.

    For remote-data agents that must distinguish authentic DNS replies from signed-chain failures, read Agent DNSSEC Validation — Trust Chains, Bogus Answers and Signed Denials, covering DS, DNSKEY and RRSIG checks, insecure delegations, NSEC proofs and fail-safe resolver policies.

    For agent-assisted website operations, ACME Certificate Renewal — Challenges, ARI Windows and Verified Deployment explains why issued certificates, installed files and live TLS-serving results need separate evidence, with current IETF and Let’s Encrypt guidance.

    Calendar-integrated agents need recurrence-aware write protection: Agent CalDAV Calendar Sync — Recurrence Exceptions, ETags and Conflict Recovery explains single-occurrence edits, collection reconciliation, time-zone semantics and verified calendar state.

    For device-connected AI agents, Agent MQTT Session Recovery — QoS, Retained Messages and Stale Commands explains why a successful reconnect does not establish fresh evidence or authority to repeat a command.

    For agents importing streamed JSON records, Agent NDJSON Streams — Record Framing, Partial Lines and Safe Replay explains UTF-8 line boundaries, incomplete network chunks, validation, replay cursors and truthful acknowledgement of committed results.

    For AI agents connecting to privileged APIs, OAuth mTLS, Certificate-Bound Tokens and Gateway Trust explains RFC 8705 client-certificate binding, key rotation, trusted proxy boundaries and safe verification of sender-constrained access.

    How should an AI agent handle HTTP 425 Too Early without accidentally duplicating a real action? Read Agent HTTP Early Data — Replay Boundaries and Safe Retries for RFC 8470, gateway propagation and outcome verification.

    For binary signed messages handled by real AI agents, see Agent COSE Signatures — Protected Headers, Detached Payloads and Verified CBOR, including RFC 9052 signature inputs, trusted keys, external AAD and separate replay/authorisation checks.

    For AI agents connecting to more than one API or tenant, OAuth Resource Indicators — Audience-Bound Tokens and Safe API Routing explains RFC 8707 resource URIs, wrong-audience rejection, tenant boundaries and verified credential destinations.

    For certificate-issuance auditing rather than basic TLS authentication, read Agent Certificate Transparency — SCT Promises, Merkle Proofs and Monitoring, explaining signed log commitments, inclusion evidence, suspicious issuance and safe agent trust boundaries.

    Browser-driven agents need reliable HTTPS navigation and cautious policy rollouts. Learn how agent HSTS boundaries, browser HTTPS upgrades and subdomain scope work, including first-visit limits, preloading and certificate-error recovery.

    For AI agents that receive a routing-authority rejection despite valid HTTPS, read Agent HTTP 421 Misdirected Requests — Origin Authority, Connection Coalescing and Safe Retries. It explains why a shared connection may be unsuitable for one hostname, how to test a fresh origin-specific route and how to keep write retries bounded.

    When a present-day AI agent edits JSON resources without replacing unrelated object fields, read Agent JSON Merge Patch — Null Deletes, Array Replacement and Safe Preconditions. It explains RFC 7396 deletion semantics, why arrays replace whole, and how strong ETag checks prevent stale writes; for element-level alternatives, compare the separate JSON Patch guide.

    For AI agents that need verifiable updates from public feeds without constant polling, read Agent WebSub Subscriptions — Challenge Verification, Signed Delivery and Lease Recovery, including callback intent checks, HMAC body authentication, renewal arithmetic, duplicates and missed-update reconciliation.

    For a present-day AI agent that must locate an approved service without guessing a hostname or bypassing identity checks, read Agent DNS SRV Discovery — Priority, Weight, TTL and Safe Failover. It explains service priorities, within-tier weights, DNS cache lifetimes, authenticated connections and safe retry decisions using the original IETF rules.

    To understand a different present-day AI-agent login boundary, read Agent SSH User Certificates — trusted CAs, role principals, expiry and revocation; this covers authenticating the worker rather than merely verifying a remote SFTP host.

    For agents deciding whether an HTTP API should finish synchronously, acknowledge queued work or return a complete updated resource, read how the HTTP Prefer header, wait budgets and Preference-Applied checks work. The guide distinguishes optional response choices from authoritative task completion, safe retries and cache variation.

    When an automated certificate workflow must check which certificate authority is permitted to issue for ordinary and wildcard hostnames, see How Superintelligence Works | Agent DNS CAA Policy — Authorized CAs, Wildcard Rules and Issuance Checks. It explains relevant DNS record sets, issue and issuewild boundaries, critical flags, DNS caches and verified repair without confusing issuance permission with TLS validation.

    For practical agent HTTP clients learning to choose a faster connection without changing the authorized origin, read How Superintelligence Works | Agent HTTP Alt-Svc — Protocol Discovery, Origin Authority and Safe HTTP/3 Migration. It explains alternative-service freshness, original-host TLS checks, QUIC reachability, clear rollback, and safe fallback with worked measurements.

    For present-day AI agents that must call a second protected service without reusing a token intended for the first, read Agent OAuth Token Exchange — Subject, Actor and Audience Boundaries. The guide explains RFC 8693, safe delegation, audience restrictions and failure recovery.

    For the difference between a signed authorization request and a granted agent capability, read How Superintelligence Works: Agent OAuth JWT Request Objects — Signed Intent, Audience and Validation, covering RFC 9101, JAR versus PAR, client-bound keys and rejection tests.

    For a practical guide to choosing encrypted DNS resolvers for present-day software agents without leaking internal names, read Agent DNS over HTTPS Resolver Policy — Identity, Split DNS and Cache Freshness. It explains RFC 8484, split DNS, TTL and HTTP Age checks, and bounded recovery with worked denominators.

    For a practical guide to applying the evolving HTTP RateLimit and RateLimit-Policy fields in present-day agent systems, including weighted quotas, shared schedulers and safe throttling decisions, read How Superintelligence Works | Agent RateLimit Fields — Quota Policies, Safe Scheduling and Throttling.

    For narrowly specified present-day agent permissions beyond broad OAuth scopes, read Agent OAuth Rich Authorization Requests — Permissions, Consent and Transaction Boundaries. It explains RFC 9396 authorization_details, permission multiplication, human review and resource-server enforcement with a worked example.

    Agent DNS HTTPS and SVCB Records — Priorities, ALPN and Safe Endpoint Binding explains how automated clients discover transport choices while preserving origin identity, TLS verification and safe fallback.

    To coordinate signed session invalidation across an identity provider and connected applications, read Agent OIDC Back-Channel Logout — Signed Events, Session Scope and Verified Invalidation, including token validation, sub/sid scope, replay controls and honest handling of partially completed logouts.

    To secure real-time agent connections before any command is trusted, read Agent WebSocket Handshakes — Origin Checks, Subprotocols and Upgrade Boundaries, including the RFC 6455 nonce check, browser-origin policy, application-protocol selection and HTTP/2 or HTTP/3 differences.

    For the separate-device authentication flow in which an AI-assisted application requests permission through an OpenID Provider and checks poll, ping or push results, read Agent CIBA Authorization — Separate Devices, Poll/Ping/Push and Consent Boundaries, with expiry, consent and token-binding examples.

    For the practical protocol behind response urgency, incremental streaming and fair client scheduling, see Agent HTTP Priorities — Urgency, Incremental Delivery and Fair Scheduling, including RFC 9218 rules, an original bandwidth calculation, unsafe shortcuts and honest outcome checks.

    For sensitive API actions that require the user to authenticate again at a stronger or newer level, read Agent OAuth Step-Up Authentication — ACR, Max-Age and Verified Authorization, with RFC 9470 challenge handling, worked time calculations and safe agent retry boundaries.

    To verify that an OAuth authorization callback genuinely belongs to the intended issuer, client and browser transaction, read Agent OAuth JARM Responses — Signed Redirects, Issuer Binding and Safe Callbacks, including signed claims, response modes, state, PKCE and reconciliation of ambiguous token exchanges.

    To understand how an application requests central logout through the browser without confusing it with signed notifications, read Agent OIDC RP-Initiated Logout — ID Token Hints, Redirect Trust and Session State, including registered return URIs, user confirmation and independently verified sessions.

    To see how a delegated worker can narrow an existing authorisation without inheriting a master credential, read Agent Macaroon Capabilities — Chained HMACs, Caveats and Attenuated Delegation, including first- and third-party conditions, replay and revocation limits, and fully worked access cases.

    Learn how client-side secret material may be derived with the WebAuthn PRF extension in Agent WebAuthn PRF — Credential Secrets, Salts and Safe Recovery, covering the exact extension outputs, encryption boundaries, multiple credentials and tested recovery needs.

    For verified changes in session, device and user risk across cooperating services, read Agent CAEP Security Events — Risk Changes, Session Revocation and Verified Access, including signed Security Event Tokens, Shared Signals streams, scope and concrete enforcement checks.

    For signed XML inputs in AI-agent workflows, read Agent XML Signatures — Canonicalization, Wrapping Attacks and Verified References to distinguish a valid digest from approval of the exact signed business object.

    For standards-based authentication of a tool-using agent’s TLS service, read Agent DANE TLSA Identity — Signed DNS, Certificate Matching and Safe Rotation. It explains validated DNSSEC TLSA records, precise 3 1 1 public-key matching, a staged key-change timetable and the failures that must not silently downgrade a protected connection.

    For agents responsible for email-system trust decisions, read Agent SMTP DANE TLSA — DNSSEC Evidence, Certificate Matches and Safe Deferral to distinguish secure record states, certificate matches, mail transport acceptance and human notification.

    For the DNS routing and privacy implications of an AI application’s resolver, read Agent EDNS Client Subnet — DNS Routing, Privacy Caps and Cache Scope. This RFC 7871 guide explains the binary option, worked IPv4 and IPv6 source prefixes, safe response-scope caching, zero-prefix disclosure limits, resolver-chain checks and an explicit privacy-first deployment decision.

    For a connection-bound method of authenticating an additional certificate identity after TLS is established, read Agent TLS Exported Authenticators — Post-Handshake Identity, Request Contexts and Connection Binding. It explains RFC 9261’s client/server roles, TLS exporter secrets, unique challenges, certificate validation, replay boundaries and the distinction between proof and authorisation.

    To understand how safe AI-agent workflows carry optional diagnostic context between services, read Agent Baggage Context — Distributed Hints, Byte Budgets and Trust Boundaries. It explains the W3C header grammar, worked 64-member and 8192-byte limits, untrusted values, privacy-first gateway policy and transfer tests.

    For a precise account of limited off-path DNS query and reply assurance in software-agent infrastructure, read Agent DNS Cookies — Off-Path Spoofing, Anycast Secrets and Safe Resolver Fallback. It explains RFC 7873 and RFC 9018, eight-byte Client Cookies, interoperable 16-byte Server Cookies, timestamp checks, NAT, anycast rollout, BADCOOKIE retries and why DNS Cookies are not DNSSEC.

    For DNS-based agent tools that must handle validated nonexistent names without unnecessary upstream queries, read Agent DNSSEC Aggressive Caching — NSEC Proofs, TTL Limits and Safe Fallback. This guide separates ordinary negative caching from RFC 8198 proof-range synthesis and explains RFC 9077 expiry limits, NSEC3 Opt-Out, wildcard conditions and hand-checked TTL cases.

    For a privacy-preserving agent request pathway, read Agent Oblivious HTTP — Relay Privacy, HPKE Envelopes and Replay Boundaries. It explains IETF RFC 9458, authenticated HPKE key configurations, binary HTTP, separation of network identity from request content, hand-checked byte and latency budgets, log-correlation risks and why uncertain side-effecting requests must not be retried blindly.

    For a practical security explanation of how modern AI-agent services establish process identities and validate authorised peers, read Agent SPIFFE Workload Identity — SVIDs, Trust Domains and Safe Rotation. The guide distinguishes cryptographic authentication from tool permission, with exact trust-domain checks, token expiry arithmetic, rotation, federation, failure diagnosis and a changed-domain exercise.

    For a focused guide to how agent-operated network services can interpret Resource Public Key Infrastructure (RPKI) authorisations without confusing them with complete route or endpoint trust, read Agent RPKI Route Origin Validation — ROAs, VRPs and Safe BGP Routing. It explains Valid, Invalid and NotFound, checked IPv4 prefix cases, router-cache synchronisation, explicit BGP policy and defensible failure repair.

    For a precise TLS 1.3 transport optimisation, read Agent TLS Certificate Compression — Negotiation, Byte Savings and Decompression Safety. It explains RFC 8879’s advertised algorithms, CompressedCertificate framing, exact output-size limits and worked bytes-per-handshake calculations without relaxing normal certificate verification.

    To understand how a TLS 1.3 gateway may authenticate with a short-lived delegated signing key rather than copying the parent certificate private key to every edge, read Agent TLS Delegated Credentials — Short-Lived Keys, Client Negotiation and Expiry. It explains RFC 9345, exact seven-day arithmetic, client support, chain and algorithm verification, compromise boundaries, deployment and changed-context tests.

    For current TLS 1.3 record-layer key maintenance, read Agent TLS 1.3 KeyUpdate — Traffic Secrets, One-Way Rekeying and Safe Connection State. It uses the July 2026 RFC 9846, practical direction-specific state traces, authenticated old-key notices, checked record budgets, QUIC differences, incident limitations and independent transfer exercises.

    For a precise DNS resolver privacy mechanism, see Agent DNS QNAME Minimisation — Resolver Privacy, Zone Cuts and Query Budgets. It explains RFC 9156’s iterative delegation queries, parent-side DS records, changing QTYPEs, checked 18-label work limits, DNSSEC distinctions, privacy exposure and resolver failure repairs.

    For a precise HTTP MASQUE datagram transport and proxy-authorisation problem, read Agent CONNECT-UDP Tunnels — MASQUE Datagrams, Target Rules and Proxy Safety. It explains RFC 9298 and HTTP Datagrams, the March 2026 RFC 9931 optimistic-upgrade restriction, target filtering, request-stream framing, exact packet budgets and recovery when UDP relay or application delivery fails.

    For an HTTP request-safety boundary at an AI-agent gateway, read Agent HTTP 425 Too Early — TLS 0-RTT Replay, Safe Retry and Gateway Boundaries. It explains RFC 8470’s replayable early data, Early-Data request-field propagation, safe post-handshake retries, per-route side-effect decisions and checked gateway examples.

    For a precise real-world QUIC transport security mechanism, read Agent QUIC Address Validation — Retry Tokens, NEW_TOKEN and Amplification Limits. It derives RFC 9000’s three-times received-byte rule, compares immediate Retry and future NEW_TOKEN paths, checks original byte budgets, token integrity, replay privacy, path migration and correct failure recovery without confusing address reachability with application authorization.

    For designing confidential communication among present-day software agents, read How Superintelligence Works | Agent MLS Group Messaging — KeyPackages, Epoch Commits and Removed Members. It explains RFC 9420 and RFC 9750 group key agreement, validated KeyPackages, epoch transitions, Welcome processing, cryptographic removal, delivery failures, and the separate authorization needed for real agent tools.

    For engineering privacy-preserving, authorised access in real agent systems, read How Superintelligence Works | Agent Privacy Pass Tokens — Blind Issuance, Redemption and Replay Boundaries. The guide separates RFC 9576–9578 token issuance, PrivateToken redemption, one-use replay checks and the surrounding permission boundaries.

    For a concrete security boundary in present-day agent notification systems, read How Superintelligence Works | Agent Web Push VAPID — Application Server Keys, Audience Claims and Subscription Safety. It explains signed ES256 claims, push-service audience and expiry, restricted subscriptions, encryption boundaries, key rotation, consent, bounded retries and exact delivery denominators without treating speculative AI superintelligence as an existing capability.

    For a precise failure-recovery mechanism in today’s agent tool services, read How Superintelligence Works | Agent gRPC Retry Pushback — Service Config, Token Throttling and Commit Rules. It explains millisecond server pushback, per-method retry policies, throttle-token arithmetic, committed RPC boundaries, transparent retries and the evidence required before reissuing a side-effecting action.

    For the encrypted DNS transport used by real software agents, read How Superintelligence Works | Agent DNS over QUIC — Encrypted Queries, Stream Mapping and Trust Boundaries, including RFC 9250 stream framing, authenticated resolver selection and failure-safe privacy policy.

    HTTP field parsing and trustworthy agent coordination: How Superintelligence Works | Agent HTTP Structured Fields — Typed Headers, Strict Parsing and Signature Boundaries explains RFC 9651 Items, Lists and Dictionaries, strict interpretation, signature coverage and downstream authorization boundaries.

    Authenticated time for real agent systems: Agent Network Time Security — NTS-KE, rotating cookies and trustworthy clock limits explains RFC 8915, protected NTP responses, replay checks and the remaining dangers of packet delay or an inaccurate time source.

    To diagnose an AI agent’s failed HTTP call without mistaking a proxy timeout for proof that an action never happened, read Agent HTTP Proxy-Status — Hop Diagnostics, Error Tokens and Safe Logging. The guide explains RFC 9209’s ordered intermediary reports, upstream errors, privacy boundaries and why safe retry decisions need application-level evidence.

    For a practical routing-policy companion, read Agent BGP Roles — OTC Attributes, Route Leaks and Safe Propagation, which explains RFC 9234 role negotiation, the Only to Customer boundary, the peer/customer export checks and hand-verified diagnostics for service-dependent agents.

    For an existing DNS transaction-authentication mechanism used by today’s infrastructure agents, read Agent DNS TSIG — Shared-Key MACs, Time Windows and Update Authorisation. The chapter explains RFC 8945 HMAC verification, authenticated replies, signed clock tolerance, replay limitations, DNS UPDATE permissions, multi-message zone transfers, independent record readback and why TSIG is not DNSSEC or transport encryption.

    For the security boundary between an AI-enabled certificate agent and a certification authority’s existing customer record, see Agent ACME External Account Binding — Nested JWS, MAC Keys and Account Registration. This specialist guide derives RFC 8555’s external-account MAC proof, explains the matching outer and inner JWK checks, and works through registration failures, tenant isolation, secret custody and renewal boundaries.


    Human Intelligence and the Future of Education: From the Centre to the Edge

    Understanding how Super Intelligence works leads to a larger question: how should education change when AI can increasingly help people perform tasks once used to practise and demonstrate human capability? The answer is not to abandon foundational knowledge or independent learning. It is to use those foundations to move beyond reproducing established answers. This companion series explores how students, teachers and institutions can use AI to extend human intelligence, investigate unanswered questions and develop a culture of discovery. The central idea is a movement from the centre of established knowledge towards the edge of new possibilities.

    Continue the AI, Education and Civilisation series

    Follow the argument from human learning into the institutions that shape shared life. Each article develops its own questions through practical examples and clear evidence limits.

    Learning and human capability

    Culture and shared life

    Knowledge and public institutions

    Economics, organisations and work

    Learning design and participation

    Assessment, feedback and school practice

    Subject reasoning and inquiry

    Expression, place and creative practice

    Shared decisions, systems and practical learning

    Return to How Super Intelligence Works.