The AI Periodic Table: A Design Language for AI Workflows

Article AI Architecture Workflow Published: March 28, 2026

Click the diagram to view a larger, zoomable version.

The AI Periodic Table maps the AI ecosystem onto a familiar chemistry metaphor. This idea comes from Martin Keen of IBM—brilliant framing—and the version here expands on that talk, following his suggestion to use the metaphor when planning AI workflows for concrete processing scenarios or use cases.

Rows describe how assembled a technology is, from raw atoms to production-ready systems. Columns are functional families: reactive, retrieval, orchestration, validation, or model capabilities. When you treat components as elements, you can see which atoms you have, which molecules you can build, and how those molecules interact in a reaction—a full AI workflow.

Dimension Meaning
Rows (levels of complexity) How “assembled” a technology is—from raw primitives to production systems.
Columns (functional families) The primary role in a workflow (reactive, retrieval, orchestration, validation, or model).

Below: every element (Pr, Em, Lg, and so on) with a short definition and a real-world example; combo recipes for end-to-end solutions; and practical tips for wiring and validating pieces in your own projects.

Rows – levels of complexity

Row What it means Typical “state” of the element
Row 1 – Primitives Indivisible building blocks, analogous to chemical atoms. Ready to be called directly by code; no further decomposition.
Row 2 – Compositions Assemblies of primitives (e.g., prompts, fine-tuned models). Usually a single artifact (a prompt file, a fine-tuned checkpoint).
Row 3 – Deployment Infrastructure that hosts or runs compositions in production. Containers, serverless functions, orchestrators, agent loops.
Row 4 – Emerging Cutting-edge ideas that have not yet settled into a stable form. Multi-agent debate platforms, self-optimising orchestration, generative synthetic-data pipelines.

Columns – functional families

Family (column) Core purpose Elements (rows 1–4)
G1 – Reactive (action & autonomy) Produce or trigger actions. Pr, Fc, Ag, Ma
G2 – Retrieval (memory & adaptation) Store, search, and adapt knowledge. Em, Vx, Ft, Sy
G3 – Orchestration (integration) Wire primitives and compositions together. Rg, Fw (no primitives)
G4 – Validation (safety & reliability) Guard, test, and explain AI behavior. Gr, Rt, In
G5 – Models (core capabilities) Provide the raw intelligence. Lg, Mm, Sm, Th

Elements – definitions and examples

G1 – Reactive

Element Row Definition Concrete example
Pr – Prompting 1 Plain text or token string that instructs a model. “You are a friendly travel assistant. Suggest a 3-day itinerary for Paris.”
Fc – Function calling 2 LLM-generated structured request that invokes an external API. An LLM returns { "name": "search_flight", "arguments": {"origin":"NYC","dest":"LON"} }.
Ag – Agents 3 Autonomous loop (sense → plan → act → observe) that runs continuously. A meeting-scheduler bot that watches a calendar, proposes slots, calls an API to send invites, and logs outcomes.
Ma – Multi-agent systems 4 A network of agents that negotiate or debate to reach a collective answer. A sales platform where pricing, compliance, and UI agents discuss a discount before presenting a final quote.

G2 – Retrieval

Element Row Definition Concrete example
Em – Embeddings 1 Vector representation of text, image, or audio. Sentence-Transformer all-mpnet-base-v2 producing 768-dim vectors for each support article.
Vx – Vector database 2 Store and similarity-search over embeddings. Pinecone index of 200k product FAQs for fast semantic lookup.
Ft – Fine-tuning 2 Updating a base model on domain-specific data. Fine-tuning LLaMA-2-7B on a corpus of 10k internal policy documents.
Sy – Synthetic data 4 AI-generated training data for another model. Using a diffusion model to generate labeled medical images to augment a scarce dataset.

G3 – Orchestration

Element Row Definition Concrete example
Rg – Retrieval-augmented generation 2 Pipeline that retrieves relevant context (via embeddings + vector DB) and feeds it to a model. A support bot that fetches the top three knowledge-base passages, then asks GPT-4 to craft a response.
Fw – Frameworks 3 SDKs that describe plumbing for LLM-centric apps. LangChain chain tying together a prompt, a vector store, a tool-calling step, and a guardrail filter.

G4 – Validation

Element Row Definition Concrete example
Gr – Guardrails 3 Runtime filters that block unsafe outputs or enforce schemas. JSON schema validator rejecting any LLM output not matching your contract.
Rt – Red-team testing 3 Systematic adversarial probing to expose weaknesses. Running prompt-injection attacks against an internal chatbot and documenting failure modes.
In – Interpretability 3 Tools that surface why a model made a specific prediction. Using SHAP to explain feature importance for a tabular classifier in credit-risk scoring.

G5 – Models

Element Row Definition Concrete example
Lg – Large language models 5 General-purpose, high-parameter LLMs. OpenAI GPT-4-Turbo, IBM Granite, Claude 3.
Mm – Multi-modal models 5 Process two or more modalities (text+image, text+audio). GPT-4-Vision, Meta LLaVA, Google PaLM-E.
Sm – Small models 5 Lightweight, distilled or quantised models for edge use. DistilBERT, TinyLlama-1.1B, Phi-3-mini.
Th – Thinking models 5 Architectures that natively perform chain-of-thought, reasoning, or planning. CoT-style systems, reasoning-focused GPT variants, or models with explicit reasoning modules.

Reactions – real-world workflows (combo recipes)

Each pattern below lists a goal, the elements used, a step-by-step flow, and practical tips.

Production RAG (retrieval-augmented generation)

Goal Build a safe, data-grounded chatbot for internal knowledge-base queries.
Elements Em → Vx → Rg → Pr → Lg → Gr
Flow
  1. Create embeddings (Em) for every knowledge-base article.
  2. Load them into a vector store (Vx).
  3. On each question, retrieve the top-k passages (Rg).
  4. Compose a prompt (Pr) that injects the retrieved snippets.
  5. Send the prompt to a large language model (Lg).
  6. Guardrail (Gr) validates the LLM’s structured reply before returning it.
Tips Keep vector dimension consistent (e.g., 768). Use hybrid search (vector + BM25) for recall. Guardrails should enforce format (JSON schema) and policy (e.g., no personal data leakage).
When to use Internal help desks, product documentation assistants, compliance Q&A bots.

Agentic loop (autonomous task execution)

Goal Automate multi-step business processes (e.g., travel booking) with minimal handoff.
Elements Ag → Fc → Fw → Lg → Gr (with Pr implicit inside LLM calls)
Flow
  1. Agent (Ag) listens for a trigger (e.g., a Slack command).
  2. Agent emits a function-call request (Fc) to an API such as search_flight.
  3. Framework (Fw) dispatches the API call and returns results.
  4. Agent asks the LLM (Lg) to rank options and draft an itinerary (prompting is implicit in the call).
  5. Guardrails (Gr) verify the itinerary against travel policy before email.
Tips Persist agent state in a lightweight DB across restarts. Rely on function-calling schemas for deterministic structure. Log decisions for post-mortems and compliance.
When to use Expense automation, HR onboarding bots, supply-chain order placement.

Specialized assistant via fine-tuning + prompting

Goal Deliver a domain-specific code assistant that writes production-grade Python.
Elements Ft → Lg → Pr → Gr
Flow
  1. Fine-tune (Ft) a base LLM on internal code, tests, and style guides.
  2. Deploy the fine-tuned model as your Lg.
  3. At inference, prepend a prompt (Pr) with API surface and constraints (e.g., PEP 8).
  4. Guardrail (Gr) runs static analysis (e.g., pylint) and rejects policy violations.
Tips Balance the fine-tuning dataset (good vs. buggy code). Add few-shot prompting for rare edge cases. Cache guardrail results for identical prompts when latency matters.
When to use Internal SDK generation, API client scaffolding, domain-specific documentation bots.

Synthetic-data-powered vision system (emerging)

Goal Train a small vision model for defect detection when real images are scarce.
Elements Sy → Mm → Ft → Gr
Flow
  1. Use a diffusion model (Sy) conditioned on CAD drawings to synthesize defect-annotated images.
  2. Train a multi-modal model (Mm) (e.g., CLIP-based) on the synthetic set.
  3. Fine-tune (Ft) on a small set of real photos to close the domain gap.
  4. Deploy with guardrail (Gr) that routes low-confidence predictions to human review.
Tips Validate synthetic diversity (e.g., embedding visualisations). Use domain randomisation (lighting, texture) for robustness.
When to use Manufacturing QA, regulated medical imaging, satellite anomaly detection.

Designing your own reaction

  1. Identify the goal – What output or action must the system produce?
  2. Pick a core model (G5) – Large, multi-modal, small, or thinking, depending on latency and budget.
  3. Add retrieval (G2) if knowledge grounding is required.
  4. Use orchestration (G3) to manage data flow.
  5. Choose a reactive element (G1) for the final act—prompt, function call, or agent.
  6. Layer validation (G4) – Guardrails first, red-team later, interpretability as needed.
  7. Iterate – Swap primitives for fine-tuned versions or emerging synthetic-data pipelines as you mature.

Quick checklist (copy into your notes):

- [ ] Goal statement
- [ ] Core model (Lg / Mm / Sm / Th)
- [ ] Retrieval needed? → Em + Vx
- [ ] Fine-tune? → Ft
- [ ] Reactive style? → Pr / Fc / Ag / Ma
- [ ] Orchestration? → Rg / Fw
- [ ] Guardrails? → Gr (schema, policy)
- [ ] Red-team tests? → Rt
- [ ] Explainability? → In
- [ ] Emerging boost? → Sy / Ma

Conclusion

The AI Periodic Table is more than a catalog of tools—it is a design language. Treating each piece as an element helps you diagnose gaps (“we have retrieval but no guardrails”), align engineering with product and compliance, and compose reusable molecules (a RAG block) into larger compounds (agents, multi-agent platforms).

References

  1. Martin Keen (IBM). Video introducing the AI periodic table concept (YouTube).