ArtificialIntelligence.How · AI Lab

Do not memorize the diagram.
Operate the system.

Interactive, research-grounded models of the mathematics inside a transformer and the engineered systems around an agent.

Enter the agent systems observatory →

AI Lab · Every subject owns its own experiment and landing page

Two observatories

Look inside the model. Then look around it.

Transformer microscopeAttention, layers, gradients, sampling, and the KV cache

Inspect every value in a tiny decoder transformer: token vectors, Q/K/V projections, masks, softmax, residual blocks, loss, gradient updates, and inference memory.

Open the transformer →Agent systems observatoryContext, authority, loops, tools, topology, and persistent state

Trace an agent from its finite context through model decisions, tool proposals, policy gates, execution, evidence, verification, and explicit stopping.

Open the agent runtime →

Focused experiments

Start at the layer you need to understand

Each subject owns a focused interaction, explanation, source set, image, URL, title, and canonical page.

Context engineering laboratoryCompile the model’s working state

Interactively learn context engineering by packing instructions, tools, evidence, memory, history, and skills into a finite model context window.

Run this experiment →Prompt injection airlockAssume the model can be manipulated. Contain the consequence.

Trace direct and indirect prompt injection through model context, tool proposals, approvals, network policy, least privilege, and isolated reader agents.

Run this experiment →Loop engineering foundryDesign the system that keeps prompting the agent

Interactively design an agent loop with observable state, tool and model budgets, verification, retry boundaries, completion evidence, and explicit stop conditions.

Run this experiment →Agent extension anatomySkills teach. Tools act. Plugins extend the runtime.

Understand AI agent skills, tools, MCP servers, plugins, resources, prompts, and memory through a precise interactive capability trace.

Run this experiment →Agent Skills laboratoryHow AI agent skills load procedures without becoming tools

Interactively inspect Agent Skills metadata, SKILL.md activation, progressive disclosure, reference loading, context cost, and trust boundaries.

Run this experiment →AI tool-calling laboratoryHow AI tools move from schema to policy to execution

Inspect a complete AI tool call: typed schema, model proposal, argument validation, authorization policy, handler execution, and structured result.

Run this experiment →Model Context Protocol laboratoryWhat an MCP server actually exposes—and what it does not authorize

Trace current stateless MCP discovery, per-request metadata, tools, resources, prompts, independent host grants, invocation, and the client–server trust boundary.

Run this experiment →Agent plugin laboratoryHow AI plugins extend a host runtime—and its attack surface

Inspect plugin manifests, publishers, requested permissions, executable hooks, registered tools and channels, enablement, and host-specific trust boundaries.

Run this experiment →Agent memory laboratoryHow AI agent memory should store, retrieve, update, and forget

Explore agent memory as scoped persisted state with provenance, relevance, lifecycle, retrieval, updates, deletion, and bounded context injection.

Run this experiment →Local knowledge workbenchBuild an AI second brain in Obsidian—without hiding the files

Turn source material into durable local Markdown notes, inspect wikilinks and backlinks, compare retrieval methods, and see exactly what AI sends beyond the vault.

Run this experiment →Knowledge graph construction microscopeBuild and interrogate a knowledge graph with Graphify

Extract typed nodes and relations, filter provenance, inspect communities and bridge nodes, and run deterministic query, path, and explain operations.

Run this experiment →Agent architecture switchyardRoute the same work through six agent topologies

Compare single agents, routers, parallel fan-out, orchestrator-worker systems, evaluator-optimizer loops, and specialist handoffs with exact structural counts.

Run this experiment →OpenClaw architecture laboratoryHow OpenClaw routes channels, sessions, tools, and nodes through its Gateway

Interactively trace OpenClaw from a messaging channel or client through the Gateway, session queue, embedded agent loop, tools, paired nodes, and persistent state.

Run this experiment →Hermes Agent architecture laboratoryHow Hermes Agent assembles prompts, tools, backends, memory, and learned skills

Interactively trace Hermes Agent from CLI, gateway, cron, or ACP through AIAgent, prompt tiers, tools, execution backends, bounded memory, delegation, and skills.

Run this experiment →Real agent runtime atlasOpenClaw and Hermes Agent, architecture before hype

Compare the official current architectures, loops, skills, plugins, memory, gateways, execution backends, and trust boundaries of OpenClaw and Hermes Agent.

Run this experiment →

The laboratory standard

Every visual must cash out in observable state.

No fake intelligence, safety, context, or autonomy scores.
No simulated private chain-of-thought.
Security guidance is separated from hard authorization.
Counts come from the visible teaching graph.
Current projects link to current official documentation.