01

History

02

How LLMs Work

03

Training & Alignment

04

Diffusion & Multimodal

05

Reasoning & Agents

06

Evaluation & Benchmarks

07

Validation & Hallucination

08

Applications

09

Deepfakes & Detection

10

Work, Learning, Planet, Law

11

Governance

12

Future

learns P(y | x)

Discriminative

“Is this a kucing or an anjing?” Draws a boundary and outputs a label, class or score.

learns P(x) or P(x, y)

Generative

“Draw me a kucing.” Models the whole data distribution, then samples new data: text, images, audio.

FORMULATION

V₀ = all single characters (or bytes)

(a, b)* = argmax count(a, b)

Vₖ₊₁ = Vₖ ∪ {ab} until |V| = target

Count adjacent pairs in the corpus; merge the most frequent pair into one new token; repeat. GPT-4o’s vocabulary ≈ 200k tokens.

STEPS

1. Split every word into characters.
2. Count all adjacent pairs; merge the top pair everywhere.
3. Repeat until the vocabulary reaches its target size.
4. To tokenize new text, replay the learned merges in order.

PYTHON · RUNS AS-IS

from collections import Counter
 
def merge(w, a, b):
    out, i = [], 0
    while i < len(w):
        if w[i:i + 2] == [a, b]: out.append(a + b); i += 2
        else: out.append(w[i]); i += 1
    return out
 
corpus = "makan makanan dimakan minum".split()
words = [list(w) for w in corpus]
for step in range(1, 5):
    pairs = Counter(p for w in words for p in zip(w, w[1:]))
    (a, b), n = pairs.most_common(1)[0]
    words = [merge(w, a, b) for w in words]
    print(step, a + b, n, words[1])     # watch "makanan"

OUTPUT

1 an 4 ['m', 'a', 'k', 'an', 'an']
2 ma 3 ['ma', 'k', 'an', 'an']
3 mak 3 ['mak', 'an', 'an']
4 makan 3 ['makan', 'an']

FORMULATION

cos(u, v) = u·v / (‖u‖ ‖v‖) ∈ [−1, 1]

v(king) − v(man) + v(woman) ≈ v(queen)

Each word is a point in ℝ³⁰⁰. Cosine ≈ 1: same direction (similar meaning); ≈ 0: unrelated. Differences between vectors capture relations such as gender or tense.

STEPS

1. Look up each word’s vector (learned from co-occurrence in a large corpus).
2. Compare two words with cosine similarity.
3. For an analogy, add and subtract vectors, then find the nearest word, excluding the inputs.
4. LLMs learn their own embeddings, one per token, as the first layer.

PYTHON · RUNS AS-IS

import spacy, numpy as np
nlp = spacy.load("en_core_web_lg")       # 300-d word vectors
v = lambda w: nlp.vocab[w].vector
 
def cos(a, b):
    return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))
 
print(f"{cos(v('king'), v('queen')):.2f}")    # similar
print(f"{cos(v('king'), v('banana')):.2f}")   # unrelated
t = v("king") - v("man") + v("woman")
ids, _, _ = nlp.vocab.vectors.most_similar(t[None], n=10)
out = [nlp.vocab.strings[i].lower() for i in ids[0]]
print([w for w in dict.fromkeys(out)
       if w not in {"king", "man", "woman"}][:3])

OUTPUT

0.73
0.22
['queen', 'prince', 'kings']

FORMULATION

Q = XW_q, K = XW_k, V = XW_v

Attention = softmax(QKᵀ / √dₖ + M) · V

MultiHead = [head₁ ‖ … ‖ headₕ] · W_o

X: T×d token vectors. QKᵀ scores how relevant each token is to every other; dividing by √dₖ keeps the softmax from saturating; mask M = −∞ above the diagonal stops a token seeing the future; each row of weights sums to 1.

STEPS

1. Project tokens into queries, keys and values.
2. Score every pair: one dot product per (query, key).
3. Mask future positions, softmax each row into weights.
4. Output = weighted blend of values; h heads run in parallel and are concatenated.

PYTHON · RUNS AS-IS

import numpy as np
rng = np.random.default_rng(0)
T, d = 4, 8                       # 4 tokens, 8-dim
X = rng.normal(size=(T, d))       # token vectors
Wq, Wk, Wv = (rng.normal(size=(d, d)) for _ in range(3))
Q, K, V = X @ Wq, X @ Wk, X @ Wv
 
S = Q @ K.T / np.sqrt(d)          # relevance scores
S += np.triu(np.full((T, T), -np.inf), 1)   # causal mask
A = np.exp(S - S.max(1, keepdims=True))
A = A / A.sum(1, keepdims=True)   # softmax per row
out = A @ V                       # blend values
print(A.round(2)[-1], out.shape)  # last token's weights

OUTPUT

[0.05 0.35 0.04 0.56] (4, 8)

FORMULATION

params ≈ 12 · L · d² + V · d

GPT-2 small: L = 12, d = 768, V = 50 257

12·12·768² ≈ 85 M + 38.6 M ≈ 124 M

Per block: attention 4d² (W_q, W_k, W_v, W_o) + MLP 8d² (d → 4d → d). Biases, norms and the 1024×768 position table (≈0.8 M) are left out.

STEPS

1. Embed tokens and add position information.
2. Each block: attention mixes information across tokens; the MLP transforms each token on its own.
3. Residual “+” paths carry the input forward, so deep stacks train stably.
4. The last vector of the sequence is projected onto the vocabulary to predict the next token.

FORMULATION

P(x₁ … x_T) = ∏ₜ P(xₜ | x₍<ₜ₎)

pᵢ = exp(zᵢ / τ) / Σⱼ exp(zⱼ / τ)

ℒ = −(1/T) Σₜ log P(xₜ | x₍<ₜ₎), PPL = eᴸ

z: the model’s raw scores (logits) for every vocabulary entry. τ < 1 sharpens, τ > 1 flattens. Top-p keeps the smallest set of tokens whose probability adds up to at least p. Training minimises the cross-entropy ℒ.

STEPS

1. Run the prompt through the network to get logits z.
2. Divide by temperature τ and apply softmax.
3. Keep the top-p nucleus, renormalise, sample one token.
4. Append it and repeat until an end token or length limit.

PYTHON · RUNS AS-IS

import numpy as np
vocab = ["rajin", "pandai", "baik", "malas", "lapar"]
z = np.array([3.0, 2.2, 1.5, 0.5, -1.0])      # logits
rng = np.random.default_rng(1)
 
def probs(z, tau):                            # softmax(z / tau)
    p = np.exp(z / tau); return p / p.sum()
 
def top_p(p, keep=0.9):
    idx = np.argsort(p)[::-1]                 # likeliest first
    cut = np.searchsorted(np.cumsum(p[idx]), keep) + 1
    q = p[idx[:cut]] / p[idx[:cut]].sum()     # renormalise
    return idx[rng.choice(cut, p=q)]
 
for tau in (0.5, 1.0, 1.5):
    p = probs(z, tau); print(tau, p.round(2), vocab[top_p(p)])
print("CE loss:", round(-np.log(probs(z, 1.0)[0]), 2))  # target

OUTPUT

0.5 [0.79 0.16 0.04 0.01 0.  ] rajin
1.0 [0.56 0.25 0.13 0.05 0.01] baik
1.5 [0.45 0.27 0.17 0.09 0.03] rajin
CE loss: 0.57

1

Pre-training

INPUT

“Ibu negara Malaysia: …”

TASK

predict the next token

LEARNS

“Kuala” ✓ loss ↓

2

Fine-tuning (SFT)

INPUT

“Terangkan fotosintesis.”

TARGET

an expert’s ideal answer

LEARNS

the assistant’s style

3

Preference tuning

INPUT

one prompt → answers A, B

HUMAN

A ≻ B (A is better)

UPDATE

RLHF (RM + PPO) or DPO

4

RL with verifiers

INPUT

“17 × 23 = ?”

MODEL

thinks step by step → 391

VERIFIER

391 ✓ → reward +1

PIPELINE

1. Pre-train on raw text, then fine-tune on curated instruction → answer pairs.
2. Collect human rankings of two answers to the same prompt.
3. Either train a reward model and optimise against it with PPO (RLHF), or apply DPO directly to the pairs.

FORMULATION

L(N, D) = E + A / Nᵅ + B / Dᵝ

E = 1.69, A = 406.4, B = 410.7, α = 0.34, β = 0.28

C ≈ 6 · N · D training FLOPs

compute-optimal (Approaches 1–2): D ≈ 20 · N

N: parameters · D: training tokens · L: test loss · E: irreducible loss of natural text. Growing only N or only D hits diminishing returns; Chinchilla showed both should grow together.

STEPS

1. Fix a compute budget C.
2. Choose N and D with 6ND = C and D ≈ 20N.
3. Predict the loss before spending the budget; check small runs fit the curve.

PYTHON · RUNS AS-IS

E, A, B, a, b = 1.69, 406.4, 410.7, 0.34, 0.28  # fitted
 
def loss(N, D):                   # N params, D tokens
    return E + A / N**a + B / D**b
 
for N, D in [(7e9, 140e9), (7e9, 2e12), (70e9, 1.4e12)]:
    C = 6 * N * D                 # training FLOPs
    print(f"N={N:.0e} D={D:.1e} C={C:.1e} "
          f"L={loss(N, D):.2f}")

OUTPUT

N=7e+09 D=1.4e+11 C=5.9e+21 L=2.18
N=7e+09 D=2.0e+12 C=8.4e+22 L=2.02
N=7e+10 D=1.4e+12 C=5.9e+23 L=1.94

FORMULATION

xₜ = √ᾱₜ · x₀ + √(1 − ᾱₜ) · ε, ε ~ N(0, I)

ℒ = E ‖ ε − ε̂(xₜ, t, c) ‖²

xₜ₋₁ = (xₜ − (1−αₜ)/√(1−ᾱₜ) · ε̂) / √αₜ + σₜ z

Forward: blend image x₀ with noise ε; ᾱₜ → 0 as t → T. Training: a network ε̂ learns to predict the noise, guided by the text embedding c. Sampling (code →): start from noise and subtract predicted noise T times.

PYTHON · RUNS AS-IS

import numpy as np
rng = np.random.default_rng(0)
T = 50                                 # same schedule as slide 23
c = np.cos(np.arange(T + 1) / T * np.pi / 2)
ab = np.maximum(c ** 2, 1e-4)          # alpha-bar_t
x0 = np.linspace(-1, 1, 64)            # toy "image": 64 pixels
def eps_hat(x, t):      # ideal denoiser if x0 is the ONLY image
    return (x - np.sqrt(ab[t]) * x0) / np.sqrt(1 - ab[t])
x = rng.normal(size=x0.shape)          # start from pure noise
for t in range(T, 0, -1):              # reverse process: T -> 1
    a = ab[t] / ab[t - 1]              # alpha_t
    e = eps_hat(x, t)                  # predicted noise
    x = (x - (1 - a) / np.sqrt(1 - ab[t]) * e) / np.sqrt(a)
    if t > 1:                          # + sigma_t * z
        s = np.sqrt((1 - a) * (1 - ab[t - 1]) / (1 - ab[t]))
        x = x + s * rng.normal(size=x.shape)
    if t in (50, 25, 1):
        print(f"t={t-1:2d}  error = {np.abs(x - x0).mean():.3f}")

OUTPUT

t=49  error = 0.882
t=24  error = 0.525
t= 0  error = 0.000

Text → Text

LLMs and reasoning models; chat, code, translation

Text → Image

Diffusion and autoregressive image models; editing by instruction

Text → Video + Audio

Veo 3 and rivals generate synced speech and sound in one pass

Text → World

Genie 3: interactive worlds you can walk through

Text → 3D

Game assets, product mock-ups, digital twins

Text → Task

Agents that browse, code, fill forms (Part 05)

3.3M → 1.1M

monthly app downloads, Nov 2025 → Feb 2026

$2.1M

reported lifetime app revenue

$1B

Disney licensing deal that collapsed with it

FORMULATION

rᵢ = verify(oᵢ) ∈ {0, 1}, i = 1 … G

Âᵢ = (rᵢ − mean(r)) / std(r)

J = E[ (1/G) Σᵢ min(ρᵢÂᵢ, clip(ρᵢ, 1±ε) Âᵢ) ]

− β · KL(π_θ ‖ π₀)

G answers oᵢ to one question q, each scored by a program. Above-average answers get  > 0 and become more likely. ρᵢ = π_θ(oᵢ|q) / π_old(oᵢ|q). The group mean is the baseline: no value network. (Per-token averaging omitted.)

STEPS

1. Sample G reasoned answers per question.
2. Score each with a verifier (tests, maths checker).
3. Normalise rewards within the group.
4. Clipped update; KL keeps the model near π₀.

PYTHON · RUNS AS-IS

import numpy as np
 
def verify(answer, truth):                 # the "verifier"
    return 1.0 if answer.strip() == truth else 0.0
 
truth = "42"                               # e.g. 6 × 7
group = ["42", "41", "42", "48", "42", "36"]  # G = 6 samples
r = np.array([verify(a, truth) for a in group])
adv = (r - r.mean()) / (r.std() + 1e-8)    # group-relative
print("rewards   ", r)
print("advantages", adv.round(2))
# raise log-prob where A > 0, lower it where A < 0

OUTPUT

rewards    [1. 0. 1. 0. 1. 0.]
advantages [ 1. -1.  1. -1.  1. -1.]

PYTHON · AGENT LOOP (SKETCH)

def run_agent(goal, tools, llm, max_steps=8):
    memory = [f"Goal: {goal}"]
    for _ in range(max_steps):
        step = llm(memory, tools)          # think + choose
        if step.kind == "final":
            return step.text               # done
        if step.tool in RISKY and not ask_human(step):
            memory.append("Human declined; try another way.")
            continue
        result = tools[step.tool](**step.args)    # act
        memory.append(f"{step.tool}: {result}")   # observe
    return "Stopped: step budget used up."

STEPS

1. Model sees goal, tools and memory; answers or picks a tool.
2. Run the tool; append the observation to memory.
3. Loop within a budget; a human approves risky steps.

FORMULATION

pₙ = matched n-grams / candidate n-grams

BLEU = BP · exp( Σₙ ¼ · log pₙ ), BP = min(1, e^(1 − r/c))

ROUGE-N = matched n-grams / reference n-grams

r, c: reference and output lengths. BLEU: precision (translation). ROUGE: recall (summaries).

WORKED EXAMPLE

Ref “kucing itu tidur di atas tikar”, output “kucing tidur di atas tikar”: p₁ = 5/5, p₂ = 3/4, BP = e^(1−6/5) = 0.82; ROUGE-1 = 5/6, F1 = 0.91. A correct paraphrase in other words scores far lower.

BENCHMARKS & DATA (CLICK)

WMT shared tasks · translation test sets

CNN / DailyMail · summarisation

HF evaluate · BLEU, ROUGE, F1 code

FORMULATION

P = TP / (TP + FP), R = TP / (TP + FN)

F1 = 2PR / (P + R)

Macro-F1 = (1/K) Σₖ F1ₖ

TP, FP, FN: true positives, false positives, false negatives. Macro-F1 weights every class equally, so rare classes count.

WORKED EXAMPLE

A spam filter flags 50 e-mails: 40 are spam (TP), 10 are not (FP), and it misses 20 spam (FN) → P = 0.80, R = 0.67, F1 = 0.73.

BENCHMARKS & DATA (CLICK)

GLUE / SuperGLUE · classification, NLI

SQuAD · QA, exact match + token F1

Malay LLM benchmarks · Malay tasks (Mesolitica)

FORMULATION

Acc = correct / N

95% CI ≈ Acc ± 1.96 · √( Acc(1 − Acc) / N )

Gaps inside the interval are noise. Contamination: if test questions (or long n-gram matches) appear in training data, scores are inflated.

WORKED EXAMPLE

MMLU has 14,042 test questions. A model at 85.0% has a 95% interval of about ±0.6 points, so 85.0% vs 85.4% is a tie.

BENCHMARKS & DATA (CLICK)

MMLU · 57 subjects, multiple choice

Humanity’s Last Exam · expert-level, unsaturated

GSM8K · grade-school maths

MalayMMLU · Bahasa Melayu exam questions

FORMULATION

pass@k = 1 − C(n − c, k) / C(n, k)

n programs per task, c pass the tests: chance ≥ 1 of k tries passes.

PYTHON · RUNS AS-IS

from math import comb
def pass_at_k(n, c, k):     # n samples, c of them correct
    if n - c < k: return 1.0
    return 1 - comb(n - c, k) / comb(n, k)
print([round(pass_at_k(20, 3, k), 3) for k in (1, 5, 10)])

OUTPUT

[0.15, 0.601, 0.895]

BENCHMARKS & DATA (CLICK)

HumanEval · 164 Python problems

SWE-bench · % of real GitHub issues resolved (hidden tests pass)

LiveCodeBench · fresh problems vs contamination

FORMULATION

E_A = 1 / (1 + 10^((R_B − R_A)/400))

R′_A = R_A + K · (S_A − E_A)

Bradley–Terry: P(A ≻ B) = σ(β_A − β_B)

S = 1 win, ½ tie, 0 loss. LMArena fits Bradley–Terry scores to many anonymous head-to-head votes and reports confidence intervals.

WORKED EXAMPLE

A (rated 1500) meets B (1400): E_A = 0.64. A loses (S = 0) with K = 32, so A drops to 1479.5 and B rises to 1420.5.

BENCHMARKS & DATA (CLICK)

LMArena · live leaderboard, vote yourself

Chatbot Arena conversations · 33k voted chats

FORMULATION

win rate = (wins + ½ · ties) / N

κ = (pₒ − pₑ) / (1 − pₑ)

κ (Cohen’s kappa): judge–human agreement beyond chance; pₒ observed, pₑ expected by chance. Swap answer order and average to cancel position bias.

WORKED EXAMPLE

The judge agrees with human raters on 80 of 100 pairs, chance agreement is 0.5 → κ = 0.6 (moderate). Report κ before trusting the judge.

BENCHMARKS & DATA (CLICK)

MT-Bench · 80 multi-turn questions

AlpacaEval · length-controlled win rate

FORMULATION

p(success | t) = σ( α − β · log₂ t )

h₅₀ = 2^(α/β) (where p = 0.5)

t: how long the task takes a skilled human. Fit the logistic curve to an agent’s successes and failures; h₅₀ is the length it completes half the time.

WORKED EXAMPLE

α = 3, β = 0.5 → p = 0.82 on 8-minute tasks, 0.50 on 64-minute tasks, 0.18 on 512-minute tasks; h₅₀ = 2⁶ = 64 minutes.

BENCHMARKS & DATA (CLICK)

METR time horizons · live chart of frontier models

Kwa et al. (2025) · method and task suite

FORMULATION

level = min( (human actions / AI actions)², cap )

game = Σₗ ℓ · levelₗ / Σₗ ℓ , total = mean over games

No instructions or stated goal: the agent must explore to learn each game. Later levels weigh more (weight ℓ), and wasted actions are penalised quadratically.

WORKED EXAMPLE

A 5-level game: the AI clears levels 1–4, each with twice the human’s actions → each (½)² = 0.25 → game = (1+2+3+4)·0.25 / 15 = 16.7%.

BENCHMARKS & DATA (CLICK)

ARC Prize · games, leaderboard, human play

Scoring method · official ARC-AGI-3 docs

FORMULATION

score(q, d) = cos( e(q), e(d) )

context = top-k chunks by score

e(·): an embedding model (TF-IDF here, a neural embedder in practice). Chunk size, overlap and k are the main tuning knobs.

PYTHON · RUNS AS-IS

import sklearn.feature_extraction.text as sk
docs = ["MK14 (4-10 Jan 2027): minggu kuliah terakhir",
        "Minggu ulang kaji: 11-17 Jan 2027",
        "Peperiksaan akhir: 18 Jan - 7 Feb 2027",
        "Cuti pertengahan semester: 9-15 Nov 2026"]
q = "Bila minggu ulang kaji Semester 1?"
 
vec = sk.TfidfVectorizer().fit(docs)          # 1 index
D, Q = vec.transform(docs), vec.transform([q])
score = (D @ Q.T).toarray().ravel()           # 2 cosine
top = score.argsort()[::-1][:2]               # 3 top-k
ctx = "\n".join(f"[{i}] {docs[i]}" for i in top)
prompt = (f"Jawab HANYA daripada sumber.\n{ctx}\n"
          f"Soalan: {q}")                     # 4 augment
print(score.round(2), docs[top[0]])

OUTPUT

[0.14 0.59 0.   0.21] Minggu ulang kaji: 11-17 Jan 2027

MALAY LANGUAGE MODEL

Foundation LLM for the national language

Dr. Mohd Nor Akmal Khalid

LANGUAGE & LITERATURE

EN–MS translation by fine-tuning the LLM

Assoc. Prof. Dr. Sabrina Tiun

JAWI

Jawi transliteration chatbot

Assoc. Prof. Dr. Mohammad Faidzul Nasrudin

LAW

AI for drafting legal contracts

Assoc. Prof. Dr. Muhamad Helmi Md Said

MEDICINE & HEALTH

Patient-history chatbot for internal medicine

Assoc. Prof. Dr. Noor Akmal Shareela Ismail

EDUCATION & STEM

TERAS-STEM: Malay data for STEM learning

Dr. Zainal Rasyid Mahayuddin

IOT & ROBOTICS

Lightweight Malay LLM for IoT edge devices

Dr. Ahmad Tarmizi Abdul Ghani

IMAGE

Bahasa-Bench: testing vision-language models in Malay

Assoc. Prof. Dr. Azizi Abdullah

ETHNIC LANGUAGES

Smart translator for Malaysia’s native languages

Assoc. Prof. Dr. Rabiah Abdul Kadir

FORMULATION

green list Gₜ = hash(xₜ₋₁) → γ·|V| tokens

logit ℓᵢ ← ℓᵢ + δ for i ∈ Gₜ (generation)

z = (g − γT) / √( T γ (1 − γ) ) (detection)

The previous token seeds a secret split of the vocabulary; green tokens get a logit boost δ. Detector counts green tokens g among T. Human text has ≈ γT green tokens by chance (z ≈ 0); z > 4 is strong evidence.

STEPS

1. Generate: hash previous token, boost green, sample.
2. Detect: rebuild green lists with the key, count hits.
3. Compute z; flag if above the threshold.
4. Paraphrase, translation, short text all lower z.

PYTHON · RUNS AS-IS

from math import sqrt
 
def z_score(green, T, gamma=0.25):
    """green: tokens found in the green list; T: total."""
    sd = sqrt(T * gamma * (1 - gamma))
    return (green - gamma * T) / sd
 
print(round(z_score(green=52, T=200), 2))    # human-like
print(round(z_score(green=120, T=200), 2))   # watermarked
# rule of thumb: flag as watermarked when z > 4

OUTPUT

0.33
11.43

2026

7%

2035 PROJECTION

31%

Reliability

Can hallucination be engineered close to zero, or only managed?

Verifiers

Rewards for essays, medicine and law, not just maths and code

Agent safety

Prompt injection, permissions, and who is accountable for an agent’s actions

Energy & water

Efficient models and smaller on-device AI

Bahasa & sovereignty

Malay and low-resource languages; local models such as ILMU (YTL AI Labs, 2025)

Work & skills

Rebuilding the entry-level ladder that AI is eroding

01

Write one sentence: a habit you will change.

02

Name one claim from today you want to verify yourself.

03

One question you still have for next week’s tutorial.

Brynjolfsson, Chandar & Chen (2026). Canaries in the Coal Mine? Six Facts… Stanford Digital Economy Lab, Aug 2026 update.

Stanford HAI (2026). The 2026 AI Index Report.

Anthropic (2026). Economic Index report: Learning curves, Mar 2026.

METR (2026). Time Horizon 1.1, 29 Jan 2026.

ARC Prize Foundation (2026). ARC-AGI-3 Technical Report.

Kalai, Nachum, Vempala & Zhang (2025). Why language models hallucinate. arXiv:2509.04664.

Shumailov et al. (2024). AI models collapse when trained on recursively generated data. Nature 631.

Liang et al. (2023). GPT detectors are biased against non-native English writers. Patterns 4(7).

Van Vlasselaer et al. (2026). Who wrote this? Reliability of AI detection tools in HE. Int. J. Educ. Integrity.

Kosmyna et al. (2025). Your Brain on ChatGPT. arXiv:2506.08872.

Vaswani et al. (2017). Attention is all you need. NeurIPS · Ho, Jain & Abbeel (2020). DDPM. NeurIPS.

Ouyang et al. (2022). Training LMs to follow instructions with human feedback · DeepSeek-AI (2025). DeepSeek-R1.

Baker McKenzie (2026). Malaysia: Public Consultation on the AI Governance Bill · White & Case (2026). EU AI Omnibus.

NPR (12 Jan 2026) Grok blocked · TechCrunch (24 Mar 2026) Sora · InfoQ (May 2026) SynthID · Malay Mail (1 Jul 2026) data centres.

Google DeepMind (2025). Genie 3 · YTL AI Labs (2025). ILMU technical report.

FTSM works: Zamani et al. (MJCA); Saeed et al. (2024) MTAP 83; Ghazvini et al. (2025) Applied Intelligence 55 · WaRiSAN MELAYU (2026), warisan.ukm.my.