AI Academy · 2026 edition · capability-first

From first prompt
to systems that deserve trust.

A free, practical curriculum for educators, researchers and builders. Learn the durable layers behind every AI product: context, retrieval, tools, skills, evaluation, security and governance. Product names are examples; the principles are the curriculum.

Start at Level 1 See the capability atlas

4 levels90+ durable conceptsHuman skill-transfer labLive research

Start here

Choose the route that fits your work.

You do not need to read every section in order. Start with the route closest to your responsibility, then use the labs and reference sections when you need them.

Route 01

Educator

Design learning, assess with evidence and give feedback that students can use.

Level 1 · foundations →Transfer lab →Evidence lab →

Route 02

Researcher

Build a source-grounded review, trace citations and document provenance.

Source-grounded notebooks →Retrieval & evaluation →Evidence lab →

Route 03

Builder

Own a local stack, connect retrieval and tools, and evaluate the system.

Level 2 · own your stack →Build & evaluate →Capability atlas →

Route 04

Leader

Design oversight, security and a stop rule before scaling.

Level 4 · governance →Capability atlas →Primary sources →

The durable stack

The stack that outlives the tools.

Products change every quarter. The layers below are where durable skill lives. Learn the layer, then choose a tool that fits your context, budget and risk.

Intent & task design

Define the decision, audience, evidence and definition of done before choosing a model.

Turn a vague request into an executable brief.

Context & memory

Decide what the model sees, what it remembers and what it must never retain.

Context budgets, source packs, state and permissions.

Retrieval & evidence

Bring private, current or citable knowledge into the answer instead of trusting recall.

Chunking, hybrid search, reranking, citation and faithfulness.

Reasoning & generation

Decompose hard tasks, choose effort, compare candidates and verify intermediate results.

Sampling, test-time compute, structured output and calibration.

Tools & action

Connect the model to calculators, databases, browsers and APIs through narrow, auditable interfaces.

Tool schemas, MCP, sandboxing and idempotency.

Skills & procedures

Package expert workflows as versioned instructions, examples, scripts and tests.

SKILL.md, progressive disclosure, gold sets and maintenance.

Evaluation & observability

Measure correctness, groundedness, cost, latency and harm on real tasks.

Task evals, traces, regression tests and human review.

Governance & accountability

Assign purpose, permissions, oversight, redress and a stop rule.

Risk tiers, documentation, audit and human decision.

What changes

Model names, versions and prices
Context-window sizes and interfaces
Benchmark leaders and media formats
Which product is fashionable this quarter

What lasts

Problem framing and source quality
Context design and retrieval
Verification and evaluation
Permissions, security and accountability
The ability to capture and transfer expertise

Level 1 · Beginner

Think clearly, verify relentlessly.

AI is a probabilistic reasoning partner, not a database and not an oracle. This level builds the mental models, context habits and evidence discipline that make every later system safer.

1.1

What the model is actually doing

A language model generates a sequence of tokens conditioned on context. It can be useful without being right, and confident without being calibrated. Start with the mechanism, not the marketing.

It predicts continuations. Training on text teaches statistical structure, not guaranteed facts. Ask for sources and verify the claims that matter.
Context is a budget. Everything the model knows about your task is in the prompt, retrieved evidence, tool outputs or stored memory. More text is not always more signal.
Context rot is real. Long, repetitive contexts can dilute attention and hide the signal. Prune, order and summarise the evidence instead of filling the window.
Reasoning is computed. Some systems spend more test-time compute on hard problems. Ask for a plan, a critique and a second path — but still verify the result.
Fluency is not calibration. A polished answer can be wrong. Ask what would change the answer, what evidence is missing and where the uncertainty lives.
Sycophancy is a failure mode. Models often agree with the user. Ask for disagreement, counterexamples and a hostile review.
Memory is state you provide. Unless a product explicitly stores memory, assume a new session starts blank. Treat stored memory as data with permissions and an expiry date.
Modality changes the failure. Images, audio and video add OCR, perception and generation errors. Verify each channel independently.

Working rule. Use the model to expand the option space and accelerate the first draft. Keep truth, judgement and accountability in a human process.

1.2

Write an executable brief

A prompt is a short specification. The goal is not clever wording; it is enough context for another competent person — or an agent — to execute the task without asking five clarifying questions.

01
Situation
What is happening, why now and what has already been tried?
02
Audience
Who will read or use the output? What do they already know?
03
Sources
Which documents, data or examples are authoritative? What must be ignored?
04
Task
Use one clear verb: compare, diagnose, design, extract, critique, summarise.
05
Constraints
Length, language, reading level, budget, tools, privacy and what to preserve.
06
Output
Table, memo, JSON schema, lesson plan, slide outline or decision record.
07
Evidence
Require citations, a confidence note, a counterargument or a verification step.
08
Definition of done
What test would prove the output is useful, complete and safe enough to use?

Weak promptVague

Write a lesson plan about AI.

Strong prompt

You are an experienced teacher trainer in Morocco. Design a 90-minute lesson for 30 trainee teachers with mixed digital confidence. Topic: using generative AI to prepare formative assessment. Constraints: no paid tools, one offline fallback, include a 10-minute critical discussion of hallucination and privacy. Output: a table with time, activity, teacher moves, materials and evidence of learning. Add a short exit ticket. If a requirement is impossible, say so before drafting.

The strong prompt names the situation, audience, sources, task, constraints, format, evidence and definition of done. That is the whole trick.

If the brief would confuse a competent colleague, it will confuse the model. Clarity is not a constraint on creativity; it is what makes creativity usable.

1.3

Verify before you trust

Verification is a workflow, not a vibe. Build a claim ledger for anything that matters: names, numbers, dates, citations, causal claims and recommendations.

Separate claims from style. Extract the factual claims into a table before you admire the prose.
Trace to primary evidence. Prefer the paper, law, dataset or official document over a summary of a summary.
Check independence. Five articles quoting one press release are one source, not five.
Test the arithmetic. Recompute totals, percentages, units and dates. Fluency is not arithmetic.
Inspect quotations. Open the cited passage; check that it exists and actually supports the claim.
Record uncertainty. State what is unknown, contested, inferred or based on weak evidence.
Disclose material use. Follow the rules of the journal, school, employer or publisher.

Claim	Evidence	Status	What would change it
The policy applies to all schools.	Official decree, article 3	Verified	A newer amendment or a scope exception
The intervention improved results.	Preprint, n=42, no control group	Weak	A controlled study or a replication
The model is 97% accurate.	Vendor blog	Unverified	Independent evaluation on your data
The quote supports the argument.	Original source, p. 14	Verified	Missing context on the same page

A claim ledger is deliberately boring. It is also the fastest way to catch a confident error before it reaches a student, a journal or a public decision.

Watermarks and provenance are evidence, not truth. An imperceptible watermark can indicate that content was generated or edited by a compatible system. A signed content credential can record origin and edits. Neither proves that a claim is true, and the absence of a mark does not prove human origin. Treat provenance as one signal in a chain of evidence.

1.4

Source-grounded notebooks

A source-grounded notebook restricts answers to a set of documents you choose, then shows citations back to the source. It is one of the most useful research patterns — and one of the easiest to over-trust.

Capability

Ask your sources

Upload papers, notes, transcripts or web pages and ask questions. Require inline citations and open every citation before using the answer.

Examples Gemini Notebook (formerly NotebookLM), Elicit, Consensus, SciSpace.

Capability

Turn sources into study artifacts

Generate a briefing, mind map, audio overview, flashcard set or slide outline to support learning. Check every claim against the underlying passage.

Examples Source-grounded notebook tools; the artifact is a draft, not a source.

Capability

Build an evidence matrix

Extract question, method, sample, finding, limitation and citation into a comparable table. Use it to see disagreement, not to average it away.

Examples A spreadsheet plus a notebook; no single tool required.

01
Define the question
Write the decision, scope and inclusion criteria before collecting sources.
02
Curate the source set
Prefer primary, recent and independent sources. Record why each source is included.
03
Extract evidence
Fill one row per source: claim, method, sample, result, limitation and page.
04
Synthesise with citations
Ask for a synthesis that cites only the selected sources and flags disagreements.
05
Audit the citations
Open every citation. Check that the quote exists, is in context and supports the sentence.
06
Log the gaps
Record missing sources, unanswered questions and the decision that follows.

A notebook can only reason over what you give it. It will not tell you which sources you forgot. Source selection, inclusion criteria and the final judgement remain human work.

1.5

Choose capability, not brand

Every product is an implementation detail. Map the task to a capability first, then choose a tool that fits your data, language, budget and risk.

Teach-back: explain X at three levels, then name one common misconception.
Critique first: list weaknesses and rank risks before rewriting anything.
Structured extraction: claim, evidence, confidence and missing information in a table.
Few-shot transfer: give two examples of the tone or format you want, then ask for a third.
Red-team: ask for the strongest counterexample and the evidence that would defeat your draft.
Plan, approve, execute: require a plan and a human checkpoint before irreversible actions.

Retrieve

Current knowledge

Search, browse and cite recent information when the model's training data is not enough.

Examples Search-grounded assistants and research engines.

Analyse

Private documents

Extract, compare and synthesise documents that never leave your controlled environment.

Examples Local RAG stacks and source-grounded notebooks.

Reason

Plans and decisions

Decompose a problem, compare options, expose assumptions and stress-test a plan.

Examples General reasoning assistants; the method matters more than the logo.

Create

Media and structure

Draft text, images, audio, video, code, tables or slides — then verify rights, facts and fidelity.

Examples Multimodal generators with provenance and consent checks.

Act

Tools and workflows

Read data, call APIs, run code, update records or send messages with bounded permissions.

Examples Tool-using agents and workflow engines.

Evaluate

Quality and safety

Measure whether the system works on your tasks, not only whether the demo looks impressive.

Examples Task-specific test sets, rubrics and trace review.

Durability test. If the product disappears tomorrow, can you still describe the capability, the workflow and the evidence standard? If not, you learned a button, not a skill.

CheckpointCan you turn a real task into an executable brief, verify its claims and explain which capability you used?

↑ Back to map NextOwn your stack. →

Level 2 · Intermediate

Own your stack.

Local and private AI is a design choice: control, privacy and latency in exchange for hardware, maintenance and model limits. The durable skill is knowing what runs where, with which permissions and which evidence.

2.1

Local, hosted or hybrid?

There is no universal best stack. There is a best fit for the data, latency, quality, budget and maintenance capacity of a specific workflow.

Criterion	Local	Hosted API	Hybrid
Data control	Strongest: data can stay on device	Depends on contract and retention	Route sensitive data locally
Quality ceiling	Limited by hardware and open models	Usually highest and fastest-moving	Use each where it is strongest
Latency	Low and predictable; no network	Network + provider queue	Cache and route deliberately
Cost	Hardware, energy, maintenance	Pay per token or subscription	Optimise the expensive path
Operational burden	You own updates and security	Provider manages the model	Two systems to monitor
Exit risk	Low if formats are open	Vendor and pricing risk	Design a portable core

Use local when data cannot leave, latency matters or connectivity is unreliable. Use hosted when frontier quality, elasticity or multimodal coverage matters. Hybrid is often the honest answer.

2.2

The local stack, layer by layer

Keep five layers separable: runtime, interface, model, data and evaluation. Separating them lets you replace one without rebuilding everything.

Parameter count is a rough capability signal, not a quality guarantee.
Quantisation reduces memory and can reduce accuracy; test the trade-off on your tasks.
Context length is not free: longer prompts cost memory, latency and attention quality.
Language coverage matters for Arabic, French, Darija and mixed-language work.
Licence and provenance decide whether you can deploy the model at all.
Tool support and structured output determine whether it can be part of a workflow.

Memory	Comfortable local models	What to expect
8 GB RAM	1B–4B quantised	Fast basic chat, summaries and extraction; limited reasoning.
16 GB RAM	7B–9B quantised	Practical laptop sweet spot for writing, tutoring and coding help.
24 GB VRAM	13B–14B, some 20B+	Longer context and faster iteration; better coding agents.
48 GB+ VRAM	30B–70B quantised	Strong local reasoning; workstation or multi-GPU territory.
Apple Silicon	Unified memory is the budget	Efficient for 8B–30B; watch memory pressure and context length.

Example stack · commands are illustrative, not a recommendation

# 1. Runtime: run a model on your machine
runtime pull <model>
runtime run <model>

# 2. Interface: chat, documents and users
#    (desktop app or self-hosted web interface)

# 3. Model: choose by task, language and memory budget
# 4. Data: a folder of trusted documents + access rules
# 5. Evaluation: 20 real tasks with expected answers
#
# Before adding tools or memory, write down permissions.

A model that fits in memory and answers quickly teaches you more than a giant model that swaps to disk. Benchmark on your language and your tasks.

A leaderboard is not an eval. Build a small gold set from your real documents and decisions; measure accuracy, refusals, latency and cost.

2.3

From chat to agent

An agent is a loop: observe, plan, act, check. Autonomy is a permission decision, not a product feature. Move one step at a time.

Least privilege: give read access before write access; never share admin credentials.
Sandbox: run untrusted tools in a disposable environment with no personal files.
Approval gates: require confirmation for payments, publishing, deletion and external messages.
Audit trail: log tool calls, inputs, outputs, approvals and the model version.
Idempotency: make repeated runs safe; retries should not duplicate actions.
Kill switch: be able to stop the agent, revoke credentials and roll back its work.
Memory review: inspect, correct and expire what the agent remembers about people.

01
Answer
The system generates text from context. No data access, no side effects.
02
Retrieve
It reads selected sources and must cite them. Access is read-only.
03
Call tools
It runs calculations, queries databases or uses an API. Inputs and outputs are logged.
04
Remember
It stores useful state across sessions. Memory has an owner, a scope and an expiry.
05
Schedule
It runs on a trigger. Jobs are idempotent and failures are visible.
06
Act with approval
It sends, publishes, pays or deletes only after a human gate — and only with a rollback path.

The exfiltration triangle. Private data + untrusted content + an external communication channel is a high-risk combination. Break at least one leg before deploying an agent. A document can contain instructions; a web page can contain an attack; a tool can leak.

2.4

Skills as portable files

A skill is a folder of instructions, examples, scripts and references that an agent loads only when relevant. SKILL.md is emerging as a portable interface for procedural knowledge.

Layer	What it is	When it loads	Good for
Prompt	Instructions for one conversation	Every request	Immediate context and style
Skill	A versioned folder with SKILL.md and optional files	When the task matches	Reusable expert workflows
Tool	A function with a schema and permissions	When the model calls it	Deterministic actions and data access
Agent	A loop that plans, calls tools and checks results	For a whole task	Multi-step work with oversight

SKILL.md · minimal anatomy

---
name: rubric-feedback
description: Review a student draft against a rubric and produce prioritised feedback. Use when a teacher asks for formative feedback on a written assignment.
---

# Rubric feedback

## Inputs
- The draft
- The rubric with criteria and levels
- The course level and language

## Procedure
1. Check that the rubric covers the task.
2. Quote evidence from the draft for each criterion.
3. Give one strength, one priority fix and one next step.
4. Do not invent evidence or rewrite the whole draft.

## Output
A table: criterion, level, evidence, feedback, next step.

## Verification
Every judgement must point to a quotation from the draft. If the rubric is ambiguous, ask before grading.

## Failure modes
- Flattery without evidence
- Grading criteria not in the rubric
- Exposing student data outside the approved environment

## Permissions
Read the draft only. Do not publish, email or modify the original.

Progressive disclosure: the agent sees the name and description first, reads SKILL.md when relevant, and opens scripts or references only when needed.

A skill is software. Version it, review every file, test it on a gold set and never install one from an untrusted source without auditing scripts and network calls.

2.5

Small automations that survive

Automation is not connecting everything to everything. Start with one repeated decision, one source of truth and one human checkpoint.

Example

Inbox triage

Classify an academic message, extract a deadline, create a task and draft a reply for approval.

Examples Email + rules + model + task manager.

Example

Research digest

Watch a preprint feed, filter by criteria, summarise with citations and email a weekly digest.

Examples OpenAlex/arXiv + model + email.

Example

Course lead router

Validate a form, enrich the organisation, score fit, assign a track and draft a personalised follow-up.

Examples Webhook + rules + model + CRM.

Example

Weekly studio brief

Aggregate forms, compute trends, summarise, archive and notify the owner.

Examples Cron + database + model + email.

01
Trigger
A form, email, schedule, webhook or file change starts the workflow.
02
Validate
Check required fields, permissions and data quality before spending model tokens.
03
Retrieve
Load the smallest evidence pack needed for the decision.
04
Decide
Use deterministic rules where possible; use a model only for ambiguity.
05
Draft
Create a reply, task, summary or recommendation — not an irreversible action.
06
Approve
A human reviews high-impact or low-confidence cases.
07
Log
Record inputs, outputs, model version, approval and outcome for review.

Deterministic where possible, probabilistic where necessary. Use code for rules, totals, permissions and dates. Use the model for ambiguity, language and synthesis. Keep human approval for anything that cannot be undone.

CheckpointCan you explain where your data runs, what the model can access and which action requires human approval?

↑ Back to map NextBuild, automate, evaluate. →

Level 3 · Advanced

Build, automate, evaluate.

Move from using models to engineering with them. The advanced level is about systems: retrieval, adaptation, agents, evaluation and the cost of being wrong. Every component must be measurable.

3.1

The AI engineering foundation

Depth beats breadth. Learn enough mathematics to reason, enough machine learning to debug and enough engineering to ship a system that someone else can maintain.

Foundation

Maths and Python

Linear algebra, probability, calculus, NumPy, pandas, APIs, environments, Git and testing.

Examples Notebooks are for exploration; tests and version control are for production.

Classical ML

Models that still win

Regression, trees, gradient boosting, cross-validation, leakage, calibration and baselines.

Examples A simple baseline often beats an expensive model on tabular data.

Deep learning

Neural networks

Tensors, autograd, attention, training loops, GPUs, mixed precision and evaluation.

Examples Understand the loss before tuning the architecture.

LLM systems

The system around the model

Embeddings, retrieval, reranking, LoRA, serving, agents, observability and cost.

Examples Most quality gains come from data and retrieval, not a larger model.

A minimal training loop · read the loss, not only the accuracy

import torch
from torch import nn

model = nn.Sequential(
    nn.Linear(768, 256),
    nn.GELU(),
    nn.Dropout(0.1),
    nn.Linear(256, 4)
)

optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
loss_fn = nn.CrossEntropyLoss()

for batch in train_loader:
    x, y = batch["features"], batch["label"]
    optimizer.zero_grad(set_to_none=True)
    logits = model(x)
    loss = loss_fn(logits, y)
    loss.backward()
    optimizer.step()

The code is simple. The hard parts are the data, the split, the metric and the decision the model is meant to improve.

3.2

Retrieval that cites

Retrieval-augmented generation is an evidence pipeline, not a vector database. Evaluate retrieval separately from generation: a perfect generator cannot rescue the wrong document.

01
Ingest
Clean text, preserve headings, page numbers, source IDs and access rules.
02
Chunk
Split by meaning and structure, not only by character count. Keep enough context to be intelligible.
03
Index
Use embeddings plus keyword or hybrid search. Store metadata for filtering by rights, date and audience.
04
Retrieve + rerank
Fetch candidates, then select the smallest evidence pack that answers the question.
05
Generate + cite
Answer only from the evidence pack. Say when evidence is missing or conflicting.
06
Evaluate
Measure retrieval recall, citation accuracy, groundedness and usefulness on a task-specific set.

Metric	Question	Failure it catches
Retrieval recall	Did the right evidence appear?	Missing document, bad chunking, weak index
Citation accuracy	Does the cited passage support the sentence?	Decorative or fabricated citations
Groundedness	Is every material claim supported by the pack?	Confident extrapolation beyond evidence
Answer relevance	Does it answer the user's actual question?	Correct but useless answers
Cost and latency	What does one successful answer cost?	An elegant system that cannot scale
Refusal quality	Does it stop when evidence is insufficient?	Unsafe guessing under uncertainty

Build 50–100 real questions before choosing a chunk size or a model. If you cannot measure retrieval, you are tuning by anecdote.

3.3

The adaptation ladder

Do not fine-tune until you have tried to retrieve. Move up the ladder only when the lower rung has been measured and still fails.

Data quality beats data quantity. A small, curated, consented set often outperforms a large noisy one.
Separate train, validation and test. Never evaluate on examples the model has seen.
Synthetic data needs provenance. Record the generator, prompt, date and human review status.
Watch for collapse and homogenisation. Diverse human examples and independent evaluation reduce the risk.
Distillation is an evaluation problem. A smaller model is useful only if it preserves the behaviour that matters.

01
Prompt + context
Can a clear brief, examples and the right documents solve the task?
02
Retrieval
Does the model need private, changing or citable knowledge?
03
Tools
Does it need to calculate, browse, query a database or call an API?
04
Fine-tune
Do you need a consistent style, schema or domain behaviour that prompting cannot deliver?
05
Distil / compress
Can a smaller, cheaper model reproduce the behaviour on your narrow task?
06
Pre-train
Almost never the first answer. Only with unique data, compute and a clear reason.

LoRA sketch · parameter-efficient adaptation, not a shortcut

from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer

model_id = "your-base-model"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)

lora = LoraConfig(
    r=16, lora_alpha=32, lora_dropout=0.05,
    target_modules=["q_proj", "v_proj"],
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora)

trainer = SFTTrainer(
    model=model, tokenizer=tokenizer,
    train_dataset=load_dataset("json", data_files="train.jsonl")["train"],
    dataset_text_field="text", max_seq_length=2048
)
trainer.train()

The dataset is the product. Document consent, licence, PII, duplicates, label quality and the evaluation set before training.

3.4

Agent architecture

An agent is a controlled loop around a model. The architecture is mostly about state, permissions, tools and failure handling — not about the prompt.

Prompt injection: untrusted content can contain instructions. Mark external text as data and never let it grant permissions.
Tool abuse: validate arguments, constrain scopes and rate-limit destructive actions.
Loop failure: cap steps, detect repetition and define an escalation path.
State corruption: keep memory typed, versioned and reviewable; never store secrets in plain text.
Silent partial success: require an explicit completion check, not just a plausible final message.
Supply chain: audit tools, packages and skills; pin versions and monitor changes.

Component

Planner

Breaks the task into steps and decides when to stop. Prefer explicit state machines for repeatable workflows.

Examples Plan → act → observe → check → stop.

Component

Tools

Typed functions with narrow scope and clear errors. A tool schema is an API contract and a security boundary.

Examples MCP is one open protocol for exposing tools and data.

Component

Memory

State across steps or sessions. Separate working memory, long-term facts and user preferences.

Examples A memory needs an owner, scope, expiry and review path.

Component

Guardrails

Input filters, permission checks, output validation and approval gates around the model.

Examples Do not rely on the model to enforce its own permissions.

Component

Observability

Traces of prompts, tool calls, retries, cost, latency and human approvals. Without traces you cannot debug or audit.

Examples OpenTelemetry-style traces; task-level outcomes.

Component

Evaluation

Task success, tool correctness, safety, cost and time. Evaluate the whole loop, not only the final text.

Examples A trajectory can be wrong even when the final answer looks right.

Protocols reduce lock-in. Open interfaces for tools and skills — such as MCP for tool connectivity and SKILL.md for procedures — make capabilities portable across agents. The protocol is not the product; it is the escape route.

3.5

Evaluation and LLMOps

Evaluation is how an AI system becomes engineering. Build a release gate, not a demo. Measure what users need, what can go wrong and what it costs.

Trace-level review: sample real trajectories, not only final answers.
Failure taxonomy: classify errors so fixes target causes, not symptoms.
Drift: monitor input distribution, retrieval quality and user corrections over time.
Cost of failure: include human review and recovery time, not only tokens.
Stop rule: define in advance which evidence would make you pause or withdraw the system.

01
Define the decision
What action does the system support? Who is accountable? What is the cost of a false positive and a false negative?
02
Build a task set
Collect real inputs with expected outcomes, edge cases, adversarial cases and refusals.
03
Write a rubric
Make criteria observable: correctness, evidence, completeness, tone, safety and actionability.
04
Calibrate judges
Compare automated judges with human ratings. LLM-as-judge has biases; use it for triage, not final accountability.
05
Measure the system
Track groundedness, tool success, latency, cost per successful task, refusal quality and harm.
06
Gate releases
Run regression tests on every model, prompt, retrieval or tool change. Keep a canary and a rollback.

3.6

Edge AI and automation

Edge means intelligence where the data lives: privacy, offline operation and low latency. The trade-off is memory, power, model size and update complexity.

Run

Local inference

Runtime, quantisation and hardware acceleration. Keep the model and the application separable.

Examples llama.cpp, ONNX Runtime, LiteRT, ExecuTorch, OpenVINO.

Compress

Fit the device

4-bit quantisation, pruning, distillation, smaller context and speculative decoding.

Examples Measure accuracy loss on your tasks, not only size.

Measure

Real conditions

Tokens per second, p95 latency, memory peak, thermal throttling, battery and accuracy delta.

Examples A laptop benchmark is not a classroom-device benchmark.

Operate

Fleet reality

Update path, model licence, device diversity, safety filters, retention and remote revocation.

Examples Design for devices you cannot physically reach.

The smallest system that works. Use deterministic code for rules and arithmetic. Use a small local model for ambiguity and language. Use a hosted frontier model only when the task genuinely needs it. The cheapest, safest system is often the smallest one that passes the eval.

CheckpointCan you build a cited retrieval prototype, measure it, explain its failure modes and justify why fine-tuning was or was not needed?

↑ Back to map NextDesign systems that deserve trust. →

Level 4 · Expert

Design systems that deserve trust.

The expert level is not about a bigger model. It is about architecture, measurement, security, governance, economics and the judgement to know when not to deploy.

4.1

Architecture before models

Start with the decision and the failure modes. Then choose the smallest architecture that can be evaluated, audited and maintained.

Architecture

Bound the system

Define users, decisions, data flows, permissions and the human accountable for the outcome.

Examples A diagram with trust boundaries is more useful than a model shortlist.

Architecture

Design for failure

What happens when the model is unavailable, slow, wrong, manipulated or overconfident?

Examples Fallback, refusal, human escalation and rollback.

Architecture

Keep state explicit

Separate conversation state, retrieved evidence, tool results, memory and approvals.

Examples Typed state machines beat hidden prompt state for repeatable work.

Architecture

Compose, do not monolith

Small models, deterministic services and narrow tools are easier to test and replace.

Examples One provider is a risk; one protocol is an escape route.

4.2

Security and adversarial thinking

Treat every model, tool, document and skill as a potential attack surface. Security is not a filter added at the end; it is the permission model.

Prompt injection: external text can contain instructions. Separate data from control; never let content grant authority.
Data exfiltration: private data + untrusted content + outbound channel is the high-risk triangle. Break one leg.
Tool abuse: validate arguments, scope credentials, rate-limit and require approval for destructive actions.
Supply chain: audit models, packages, MCP servers and skills. Pin versions and watch for silent updates.
Poisoning: training and retrieval data can be manipulated. Verify provenance and monitor anomalies.
Secrets: never place credentials in prompts, memory, logs, skills or repositories.
Red team: test jailbreaks, indirect injection, data leakage, tool misuse and denial of service before launch.

Least privilege is an AI safety control. An agent that cannot delete, pay or send cannot cause those harms, even if it is manipulated. Design permissions so the worst possible action is still recoverable.

4.3

Governance that is usable

Governance is how an institution decides, documents, monitors and corrects AI use. It should reduce harm without making useful work impossible.

Data protection: map personal data, lawful basis, retention, cross-border transfer and subject rights.
Transparency: tell people when AI materially shapes a decision, and offer a human review path.
Documentation: model, version, data, prompts, evals, known limits, approvals and changes.
Procurement: ask for evals, security evidence, data-use terms, portability and exit assistance.
Incident response: detect, contain, notify, remediate and learn. Practice the process before you need it.

Framework

NIST AI RMF

Govern, map, measure and manage risk across the lifecycle. The generative-AI profile adds risks such as confabulation, data privacy and information integrity.

Examples Use it as a structured checklist, not a certificate.

Regulation

EU AI Act

Risk tiers from prohibited practices to high-risk systems, with transparency and literacy obligations. Check current implementation dates and your role.

Examples A high-risk education or hiring tool has different duties from a writing assistant.

Ethics

UNESCO

Human dignity, human rights, transparency, fairness, privacy, sustainability, oversight and accountability. The teacher framework adds 15 competencies across five dimensions.

Examples Use the principles to ask better questions; use local law for binding duties.

Practice

Policy and redress

Purpose, permitted data, human oversight, incident reporting, appeal, audit and a named owner.

Examples A one-page policy that people follow beats a 60-page policy they ignore.

4.4

Economics, sovereignty and the long game

The cheapest system is often the one with the smallest scope. The most sovereign system is the one whose data, skills and evaluations you can take elsewhere.

Cost per successful task beats cost per token. Include retrieval, human review, rework and failure.
Build vs buy: buy the commodity layer; build the data, workflow and evaluation that differentiate you.
Vendor exit: keep prompts, data, skills and eval sets portable. Avoid proprietary formats for the core.
Open standards: protocols and file formats reduce lock-in and make capability reusable.
Local language: evaluate Arabic, French, Darija and mixed-language performance explicitly; do not assume transfer.
Public interest: education, health and public services need accessibility, redress and sustainability, not only accuracy.

The stop rule. Before deployment, write the evidence that would make you stop. If no evidence could stop the project, it is not a pilot; it is an irreversible commitment.

4.5

Capstone: a domain assistant that earns trust

Choose a real workflow: course advising, research synthesis, formative feedback or institutional knowledge. Ship a narrow system with citations, logs, human approval and an evaluation report.

Self-assessment: What decision does this improve, and who is accountable when it is wrong?
Minimalism: What is the smallest model, scope and architecture that could work?
Evidence: How will you measure groundedness, not just fluency?
Resilience: What happens when the tool is unavailable, slow or confidently wrong?
Data: Which data must never leave the institution, and how is that enforced?
Stopping: What evidence would make you pause or withdraw the system?

01
Week 1 — Define
Users, decisions, data boundaries, success metric, failure modes and stop rule.
02
Week 2 — Prototype
Retrieval or tools first. Build a baseline and a task-specific eval set before polishing the interface.
03
Week 3 — Harden
Permissions, citations, logging, rate limits, fallback, red-team tests and human review.
04
Week 4 — Measure and publish
Report results, limitations, cost and the next experiment. Invite external review.

CheckpointCan you defend an architecture, an evaluation plan and a stop rule in front of a sceptical committee?

↑ Back to map NextEncode expertise, not just prompts. →

Transfer lab · Human → AI

Encode expertise, not just prompts.

The scarce asset is not a model. It is the encoded judgement of an expert. This lab shows how to capture tacit knowledge, turn it into a tested skill file and keep it alive as the work changes.

The five-step transfer method

Do not start with a tool. Start with a task that has a real output, a real cost and an expert who can explain their judgement.

01
Select a bounded task
Choose something repeated, observable and costly enough to matter — but not high-stakes enough to automate without review. Good first candidates: feedback on a draft, literature triage, meeting synthesis, course-lead qualification.
02
Capture the work
Shadow the expert, ask them to think aloud, collect real artifacts and interview them about exceptions. Record what they notice, not only what they do.
03
Structure the judgement
Write the trigger, inputs, decisions, rules of thumb, exceptions, output, proof, failure modes and permissions. This is the transfer canvas.
04
Encode as a skill
Create SKILL.md with examples, scripts and references. Use progressive disclosure: metadata first, instructions when triggered, resources only when needed.
05
Evaluate and maintain
Build a gold set, rubric and regression tests. Assign an owner, a version, a review date and a deprecation path.

The transfer test. A new colleague should be able to produce an acceptable output from the skill, the examples and the verification rules — without calling the expert for every case.

Cognitive task analysis

Experts often cannot explain their own expertise. The interview has to surface cues, thresholds, exceptions and ethical boundaries that are invisible in a procedure manual.

What do you notice first? Perceptual cues, red flags and signals that a novice misses.
What makes you slow down or stop? Thresholds, uncertainty, risk and the point where the expert escalates.
Which exceptions override the rule? The cases where the standard procedure would be wrong.
What does good look like? A concrete exemplar, a weak example and the difference between them.
What would you never automate? Judgement, relationships, ethics and accountability.
Where do experts disagree? Encode disagreement as an escalation path, not a fake consensus.
What evidence proves the output? The citation, calculation, observation or approval that makes it trustworthy.

Capture the exception, not only the average. The value of expertise is often in the edge cases. A skill that works only on the easy 80% is a demo; a skill that knows when to stop is a system.

The skill-transfer canvas

Fill this before writing instructions. If a field is empty, the skill is not ready.

Field	Question	Example: formative feedback
Trigger	When should the skill activate?	A teacher submits a draft against a rubric
Inputs	What must be provided?	Draft, rubric, course level, language, deadline
Decisions	What judgements are made?	Criterion level, evidence quality, priority fix
Rules of thumb	What does the expert check first?	Does the evidence actually support the claim?
Exceptions	When should it stop or escalate?	Ambiguous rubric, suspected misconduct, missing context
Output	What exactly is produced?	Table: criterion, level, evidence, feedback, next step
Proof	How is quality verified?	Quotation from the draft for every judgement
Failure modes	What are the predictable errors?	Flattery, invented evidence, criteria drift
Permissions	What may it read, write or send?	Read-only; no email; no publication

A skill file that an agent can use

Keep the main file short enough to load when relevant. Move detailed references into separate files and deterministic operations into scripts.

SKILL.md · a complete first draft

---
name: formative-feedback
description: Review a student draft against a rubric and produce prioritised formative feedback. Use when a teacher provides a draft, a rubric and a course level.
---

# Formative feedback

## When to use
Use for written assignments where the rubric is available and the goal is improvement, not final grading.

## Inputs
- Student draft
- Rubric with criteria and levels
- Course level and language
- Any accessibility or confidentiality constraints

## Procedure
1. Confirm the rubric matches the task.
2. For each criterion, find the strongest evidence in the draft.
3. Assign a level only when the evidence supports it.
4. Give one strength, one priority fix and one next step.
5. Ask for clarification if the rubric or context is ambiguous.

## Output
A table with: criterion, level, evidence quote, feedback, next step.
End with two sentences: the main strength and the single highest-leverage improvement.

## Verification
- Every level must cite a quotation from the draft.
- Do not invent evidence, sources or rubric criteria.
- Do not rewrite the whole draft.
- If confidence is low, say what is missing and stop.

## Failure modes
- Praise without evidence
- Grading against criteria not in the rubric
- Exposing student data outside the approved environment
- Overwriting the student's voice

## Permissions
Read-only. Do not email, publish or modify the original. Store no student data outside the approved system.

## Examples
See `references/examples.md` for one strong and one weak feedback set.

## Tests
See `references/eval.md` for the 12-case gold set and pass criteria.

The description says what the skill does and when to use it. The body is a procedure, not an essay. References and tests are loaded only when needed.

Evaluate, version and maintain

A skill without an evaluation is a hope. Build a small gold set, define pass criteria and review the skill whenever the task, model or policy changes.

Gold set: 10–30 real cases with expert-approved outputs, including easy, ambiguous and adversarial examples.
Rubric: observable criteria for correctness, evidence, completeness, tone, safety and actionability.
Pass criteria: the minimum bar for release, plus a separate bar for high-stakes cases.
Human calibration: compare the skill's judgments with expert judgments; record disagreements.
Regression tests: rerun the set after every prompt, model, tool or reference change.
Canary: deploy to a small group with review before broad use.
Ownership: a named owner, a version, a changelog and a review date.
Deprecation: a path to retire the skill when the workflow or the law changes.

Do not automate judgement you cannot explain. If two experts disagree, capture the disagreement as a rule for escalation. A system that pretends to resolve legitimate disagreement is not trustworthy; it is merely confident.

Download

Start with the canvas, then write the skill.

A fillable Markdown canvas with the trigger, decisions, exceptions, proof, failure modes and permissions fields. Use it with the SKILL.md example above.

Download the skill-transfer canvas

Evidence lab · Knowledge & provenance

Verify the signal, not the surface.

AI has made content cheap to produce and harder to verify. The durable skill is an evidence protocol that works even when the generator, detector or platform changes.

From sources to evidence

A source-grounded notebook is a reading and synthesis environment. It is not an authority. The evidence pipeline makes the difference between a summary and a defensible claim.

01
Frame the question
Write the decision, scope and inclusion criteria. Decide what would count as evidence before you search.
02
Curate the corpus
Prefer primary, independent and recent sources. Record why each source is in the set and what it cannot establish.
03
Extract, do not summarise
For each source, capture claim, method, sample, result, limitation and exact location.
04
Compare and contest
Look for disagreement, replication, conflicts of interest and missing populations. Do not average away a real dispute.
05
Synthesise with citations
Write the smallest synthesis that answers the question. Every material sentence should point to evidence.
06
Audit and archive
Open every citation, check the quoted passage, record the search date and archive the source set.

Source-grounded notebooks — for example Gemini Notebook, formerly NotebookLM, or research tools such as Elicit and Consensus — can accelerate the pipeline. They cannot choose your inclusion criteria or take responsibility for the conclusion.

Provenance signals

Provenance tells you something about origin and edit history. It does not tell you whether the content is true, fair or useful. Read the signal, then do the verification.

Signal

Imperceptible watermark

A watermark can be embedded in generated images, audio, text or video and detected by compatible tools. It is designed to survive some edits, not all of them.

Examples Google SynthID is one example; detection is available through compatible products and a verification portal.

Signal

Signed content credential

A cryptographic manifest can record who created or edited a file, with what tool and when. It is a chain of signatures, not a truth claim.

Examples C2PA Content Credentials are one open standard; check the signer and the full edit history.

Limit

Absence is not proof

A missing watermark or credential does not prove human origin. Content can be re-encoded, cropped, screenshotted or generated by a system that does not mark it.

Examples Treat detection as probabilistic evidence, never as a verdict.

Limit

Synthetic does not mean false

A synthetic image can illustrate a true event; a real image can be captioned falsely. Evaluate the claim, the context and the source independently.

Examples Reverse image search, original upload, geolocation and direct contact.

Detection is not accountability. Do not build a disciplinary or editorial process on a single detector score. Use provenance as one signal, document the chain of evidence and give the person a chance to respond.

A verification protocol that survives new tools

The protocol is deliberately tool-agnostic. It works for text, images, audio, video, datasets and citations.

Find the original. Trace the file or claim to the earliest available source, not the most viral copy.
Check the context. Read the full document, page, transcript or video around the excerpt.
Check the date. A real source can be outdated, superseded or applied to a different population.
Check independence. Multiple outlets quoting one origin are one source. Look for independent methods and data.
Recompute. Verify totals, percentages, units, baselines and statistical claims.
Inspect the media. Look for inconsistencies, but do not rely on visual intuition alone. Use reverse search and provenance tools.
Contact the source. For consequential claims, ask the author, institution or dataset owner.
Record the uncertainty. Publish what is known, what is inferred and what remains unknown.

Synthetic media, consent and dignity

Voice, image and video generation can support learning, accessibility and creativity. It can also impersonate, sexualise, defame or erase consent. The policy question comes before the prompt.

Consent: do not clone a person's voice, face or style without explicit, informed permission.
Disclosure: label synthetic media where it could be mistaken for evidence or a real person.
Minors: extra protection, no sexualised content, no identifiable student data, no unnecessary retention.
Cultural context: respect local norms, language and religious sensitivities; do not use synthetic media to erase or parody vulnerable groups.
Copyright: model outputs can reproduce protected styles or content; check licences and institutional policy.
Redress: provide a route to report impersonation, correct errors and remove harmful content.
Education: teach verification and creation ethics together; do not only ban the tool.

Capability atlas · 2026

Learn the capability, not the category leader.

The same capability appears under many product names. Use this atlas to recognise what a tool actually does, what it cannot do and what you need to learn to evaluate it.

Reason

Planning & problem decomposition

Turn a goal into steps, expose assumptions, compare alternatives and decide when to stop.

Learn Task decomposition, test-time compute, self-critique and verification.

Examples Reasoning assistants; the method matters more than the logo.

Retrieve

Search & current knowledge

Find recent or niche information and return it with citations.

Learn Query design, source ranking, freshness, triangulation.

Examples Search-grounded assistants and research engines.

Ground

Source-grounded notebooks

Restrict answers to a selected corpus and show evidence back to the source.

Learn Corpus curation, evidence tables, citation audits.

Examples Gemini Notebook (formerly NotebookLM), Elicit, Consensus, SciSpace.

Act

Tool use & protocols

Let a model call narrow, typed functions to read data, calculate or change state.

Learn Tool schemas, permissions, idempotency, MCP, audit logs.

Examples MCP is one open protocol for tools and data.

Act

Computer & browser use

Operate a graphical interface when no API exists, with observation and recovery.

Learn Sandboxing, screenshots, retries, action limits, human takeover.

Examples Browser agents and desktop automation; high risk without isolation.

Remember

Memory & personalisation

Carry useful state across sessions while respecting scope, consent and expiry.

Learn Working vs long-term memory, retrieval of memories, user control.

Examples Persistent assistants; always review what is remembered.

Encode

Skills & procedures

Package expert workflows as versioned instructions, examples, scripts and tests.

Learn SKILL.md, progressive disclosure, gold sets, ownership.

Examples Agent Skills open format; portable across compatible agents.

Create

Multimodal generation

Generate or edit text, images, audio, video, code and structured files.

Learn Prompting per modality, fidelity, rights, accessibility, provenance.

Examples Image/audio/video generators; verify consent and watermark.

Verify

Provenance & watermarking

Read signals about origin and edit history; understand their limits.

Learn C2PA, SynthID, metadata, reverse search, chain of custody.

Examples SynthID and Content Credentials; neither proves truth.

Measure

Evaluation & observability

Measure task success, groundedness, safety, latency and cost on real inputs.

Learn Gold sets, rubrics, LLM-as-judge caveats, traces, regression.

Examples Task-specific evals and trace review; tools change, the method lasts.

Secure

Security & guardrails

Prevent prompt injection, exfiltration, tool abuse and supply-chain attacks.

Learn Least privilege, sandboxing, input/output validation, red teaming.

Examples Security is an architecture, not a filter.

Govern

Governance & accountability

Assign purpose, oversight, redress and a stop rule that people can enforce.

Learn Risk tiers, documentation, audit, data protection, human decision.

Examples NIST AI RMF, EU AI Act, UNESCO principles; local law decides.

Names are examples, not endorsements. Verify licence, security, data terms, language quality and fit before adopting any product. If a tool disappears, the capability and the evaluation should remain.

Frontier map · what to watch

Follow the capability, not the launch.

A frontier theme matters when it changes what you can evaluate, automate or govern. Ignore announcements that do not change a decision you are responsible for.

Test-time reasoning

More compute at inference, verifier models, parallel attempts and self-consistency improve hard tasks — at a cost in latency and tokens.

Watch the accuracy gain per extra second and per extra dollar.

Agent memory and skills

Persistent state, reusable skill files and long-horizon evaluation are turning assistants into maintainable workers.

Watch whether memory is inspectable, correctable and portable.

Multimodal and world models

Image, audio, video and interactive environments are converging; generation and perception fail in different ways.

Watch provenance, consent and the ability to verify synthetic media.

Small and on-device models

Distillation, quantisation and better architectures bring useful capability to laptops, phones and offline classrooms.

Watch quality on your language, not just parameter count.

Provenance and watermarking

Embedded signals and signed credentials make origin more legible, but detection remains partial and can be removed.

Watch interoperability and whether the signal survives real editing workflows.

Evaluation science

Benchmarks saturate; the frontier is task-specific evals, adversarial testing, human calibration and production telemetry.

Watch whether a claim comes with a reproducible evaluation, not a leaderboard rank.

Human-AI skill transfer

The most valuable systems encode expert judgement, exceptions and escalation — not just generic instructions.

Watch the quality of the skill file and the gold set.

Multilingual and sovereign AI

Arabic, French, Darija and low-resource contexts need local data, local evaluation and local institutions.

Watch who owns the data, the model and the evidence.

Live capability pulse

Signals, not a buying guide.

Repository activity and research are signals. Use them to discover capabilities; verify maturity, licence, security and fit before adopting anything.

Syncing…

Loading the live ecosystem…

↗

Frontier research, without the hype

Auto-ranked from Semantic Scholar and the latest arXiv submissions. Read the method, evaluation and limitations — not only the abstract.

Loading frontier papers…

Latest arXiv preprints

Browse cs.AI →

Loading…

Primary sources

Read the source, not the summary.

These links support the curriculum and the claims that are most likely to change. Check dates and local law before applying them.

StandardAgent Skills

Open format for SKILL.md, progressive disclosure and portable procedures.

ProtocolModel Context Protocol

Open standard for connecting agents to data, tools and workflows.

Research toolGemini Notebook Help

Source-grounded chat, citations, audio/video overviews and limits.

ProvenanceGoogle SynthID

Imperceptible watermarking for AI-generated content and its limits.

ProvenanceC2PA

Open technical standard for content origin and edit history.

EthicsUNESCO AI Ethics

Human rights, oversight, transparency, fairness and sustainability.

EducationUNESCO AI Competency Framework for Teachers

15 competencies across five dimensions and three progression levels.

RiskNIST AI RMF

Govern, map, measure and manage AI risk; generative-AI profile.

RegulationEU AI Act

Risk tiers, transparency and implementation timeline.

EvidenceStanford AI Index

Annual evidence base on capability, adoption, cost and policy.

Sources checked 21 October 2026. Product names and links are examples; the principles, methods and evaluation standards are the durable content.

Questions people actually ask

Do I need to code to start?

No. Level 1 is for anyone who uses AI through chat, documents or office tools. Coding begins in Level 3, after you understand context, evidence and evaluation.

Can I run useful AI locally?

Yes. Small quantised models run on 8–16 GB of RAM for summaries, extraction and tutoring. A GPU helps with larger models, longer context and faster iteration. Benchmark on your language and tasks.

Is a source-grounded notebook always reliable?

No. It is reliable only relative to the sources you provide. Check citation accuracy, source quality, missing context and conflicts of interest. It cannot choose your inclusion criteria.

Does a watermark prove that content is true?

No. A watermark or content credential is evidence about origin and edits, not truth. Absence of a mark does not prove human origin. Use a chain of evidence and give people a right of reply.

What is SKILL.md?

A portable file that packages a procedure for an agent: metadata, instructions, examples, references and sometimes scripts. Agents load it only when relevant. Treat it as software: review, version, test and limit permissions.

How do I transfer expertise into a skill?

Select a bounded task, observe the expert, capture tacit cues and exceptions, structure the judgement, encode it as SKILL.md, then evaluate against a gold set and maintain an owner, version and review date.

How do I keep an agent safe?

Use least privilege, a sandbox, approval gates for irreversible actions, logs, idempotency, a kill switch and memory review. Break the exfiltration triangle: private data, untrusted content and an outbound channel.

Will this page name products?

Only as examples. Products change or disappear. The page is organised around capabilities, evaluation and governance so you can transfer the knowledge to whatever tool exists next year.

Keep going

Build something useful.
Then measure it.

The best way to learn AI is to ship a small, evaluated system that solves a real problem for real people — and to know when to stop.

Contact Dr. Housni Explore presentations

From first promptto systems that deserve trust.

Educator

Researcher

Builder

Leader

Intent & task design

Context & memory

Retrieval & evidence

Reasoning & generation

Tools & action

Skills & procedures

Evaluation & observability

Governance & accountability

What the model is actually doing

Write an executable brief

Situation

Audience

Sources

Task

Constraints

Output

Evidence

Definition of done

Verify before you trust

Source-grounded notebooks

Ask your sources

Turn sources into study artifacts

Build an evidence matrix

Define the question

Curate the source set

Extract evidence

Synthesise with citations

Audit the citations

Log the gaps

Choose capability, not brand

Current knowledge

Private documents

Plans and decisions

Media and structure

Tools and workflows

Quality and safety

Local, hosted or hybrid?

The local stack, layer by layer

From chat to agent

Answer

Retrieve

Call tools

Remember

Schedule

Act with approval

Skills as portable files

Small automations that survive

Inbox triage

Research digest

Course lead router

Weekly studio brief

Trigger

Validate

Retrieve

Decide

Draft

Approve

Log

The AI engineering foundation

Maths and Python

Models that still win

Neural networks

The system around the model

Retrieval that cites

Ingest

Chunk

Index

Retrieve + rerank

Generate + cite

Evaluate

The adaptation ladder

Prompt + context

Retrieval

Tools

Fine-tune

From first prompt
to systems that deserve trust.