LLM & Agentic AI

The five nested disciplines named between 2023 and 2026, what each one actually controls, the limit in each that exposed the next, the pre-LLM prior art every layer rediscovered, the difference between an execution graph and a semantic graph, and a decision rule for not climbing a layer until the work forces it.

The harness as the product: why the same weights become a chat app, a coding agent or a voice platform depending on what surrounds them, the nine responsibilities a harness supplies, feedforward guides paired with feedback sensors, and failure modes including scaffolding built for a weaker model and tool surface sprawl.

Clawification — the shift to agents with bash access and markdown skill files, replacing tool definitions and MCP. Covers the skill primitive, platform implementations (OpenClaw, NemoClaw, NanoClaw, ZeroClaw and more), channel integrations (WhatsApp, Telegram, enterprise), and OpenRouter Spawn deployment.

Declaring an agent system's control flow as an artefact separate from the agent's own reasoning: node, edge and state primitives, the two families of abstraction, what a scoped step overrides, model-evaluated edges resolved outside the active prompt, and failure modes including unhandled paths, state lost on handoff and unbounded cycles.

Taxonomy of agentic loop patterns (refinement, research, verification, reflection, exploration, nested), loop anatomy, loop control mechanisms, real implementations including autoresearch and Claude Code /loop, and loop-specific failure modes.

State machine executor that takes a declarative graph spec and runs it to completion. Five edge condition types, parallel fan-out/fan-in, crash recovery, continuous conversation threading, and two-tier retry with the judge system.

Letting a model write and run code: the five-step execution loop, stateful versus one-shot execution models, the return channels (stdout, stderr, return value, files, images), designing the error feedback loop, and failure modes including hallucinated dependencies, wrongly truncated output and fabricated results.

Changing agent behaviour during a run rather than before it: steerable signals from constraint addition to plan replacement, injection points and the work each discards, who does the steering including guardian agents and the deliberative loop of a dual-process system, and failure modes including stale steers and over-steering.

Design patterns for building AI agents including reflection, planning, tool use, multi-agent systems, and autonomous workflows.

The shipped form of neuro-symbolic AI, with no gradients anywhere: integration patterns from tool calls and constrained decoding to propose-and-verify, production systems including constraint solvers, grammar-constrained decoding and type checkers in the loop, a worked formalise-solve-repair loop, operational failure modes at the seam, and what to instrument.

Core components and building blocks of AI agents including memory systems, tool interfaces, reasoning engines, and execution frameworks.

Memory systems for AI agents including short-term, long-term, semantic, and episodic memory architectures.

Strategies for managing conversation history within token limits, from simple sliding windows to semantic chunking and retrieval-augmented context.

V2V pipeline architecture, modality taxonomy (V2V, TTS, STT, hybrid), major platforms (ElevenLabs, Vapi, Retell, Bland, OpenAI Realtime, LiveKit), tool calling patterns in voice, latency constraints, and design principles.

Voice-to-voice agent risk catalogue covering cloning attacks, liveness injection, cross-platform deepfakes, and transcript poisoning — with gap analysis and third-party security tooling from Pindrop, Reality Defender, ID R&D, and Nuance.

Turn boundary detection in voice agents: the endpointing ladder from fixed silence thresholds through adaptive VAD and semantic turn detection to full-duplex models, the interruption taxonomy separating backchannels from genuine barge-in, the generated-vs-spoken truncation problem, latency budgets, and turn-level failure modes.

Carving deterministic islands into a probabilistic conversation: scripted versus generated utterances, the trigger and catalogue pattern for regulated messaging, injecting delivered text as an assistant turn, the audit metadata the model never sees, and failure modes including interrupted disclosures recorded as delivered.

Testing a system that answers differently every time: the four test shapes (next-reply, simulation, tool call, replay), next-reply against simulation as unit against integration, writing criteria that survive rewording, the four tool-call assertions including non-invocation, building suites from real traffic, and running probabilistic tests in a pipeline.

AI safety techniques including confessions for self-reporting misbehavior, scheming detection, deliberative alignment, chain-of-thought monitoring, and building robust safety stacks.

Zero Trust principles applied to AI agents, treating the model as an untrusted actor inside the perimeter with per-action gating, circuit breakers, and policy enforcement.

Execution isolation for agents that run generated code: the boundary ladder from interpreter restriction through kernel sandboxing, containers and microVMs to account separation, capability classes worth containing, network egress paths including DNS tunnelling and approved-host abuse, sandbox lifecycle models, and isolation failure modes.

Policy as a layer outside the model: enforcement, decision, information and administration points, policy models from allowlists through ABAC and capability tokens, the agent-specific decision inputs (session history, provenance, budget), policy as code with shadow evaluation, and failure modes including wildcard creep and fail-open.

Guardrails for AI safety including content moderation, PII protection, prompt injection defense, hallucination detection, and implementation patterns.

Block-level monitoring architecture with pre-hooks, stream safeguards, and output guardrails forming a three-layer safety system for runtime agent intervention.

Catalogue of 15 failure modes specific to AI agents — from context collapse and goal drift to coordination deadlocks and hallucinated affordances.

The first comprehensive standard for AI agent security, safety, and trustworthiness. Six domains, independent third-party certification, and mappings to ISO 42001, EU AI Act, NIST AI RMF, and OWASP.

OWASP LLM Top 10, prompt injection defenses, model security, adversarial attacks, and AI-specific security measures.

Anthropic's interpretability research traced Claude's internal computations across tasks — finding that it thinks in language-agnostic concepts, plans ahead in poetry, uses computation strategies it cannot describe, and sometimes constructs reasoning post-hoc. With implications for CoT trust, hallucination causes, and jailbreak vulnerabilities.

Combining neural and symbolic computation: the trade-offs of each substrate, Kautz’s six-type taxonomy, integration patterns from tool calls and constrained decoding through to logic-as-loss, real systems including AlphaGeometry, AlphaProof and DeepProbLog, the differentiability and symbol-grounding bridge problem, and where the hybrid earns its keep.

System 1 / System 2 splits in agent design: fast reactive loop versus slow deliberative loop, split patterns (Talker-Reasoner, hierarchical VLA, triage & escalate, reflective memory, metacognitive router, draft & verify), handoff representations, routing signals, and dual-process failure modes including staleness and router miscalibration.

Understanding, detecting, and preventing hallucinations in AI systems with focus on agentic applications, grounding techniques, and production monitoring.

Behavioural patterns observed across Gemini, GPT, and Claude model families in multi-agent environments, including emotional simulation, hypothesis reification, and cross-family dynamics.

Temperature guidance for 80+ agent roles across 11 categories, from deterministic code generators to creative writers, with rationale for each recommendation.

Fairness, bias detection and mitigation, explainability, interpretability, and ethical AI development practices.

Retrieval-Augmented Generation patterns, vector search, context injection, and hybrid search for grounding LLM responses.

Graph databases, query languages (Cypher, SPARQL), GraphRAG, ontology design, and entity resolution patterns.

Static, learned and reused-standard construction, the risks that degrade a graph over time, and when tool-based search is the better fit.

Zero-shot, few-shot, chain-of-thought prompting, ReAct patterns, prompt optimization, and security considerations.

LLM evaluation frameworks, benchmark datasets (MMLU, HumanEval), metrics (BLEU, BERTScore), and LLM-as-judge patterns.

LLM inference optimization including sampling parameters, quantization, parallelism strategies, KV-cache, Flash Attention, and throughput techniques.

Tiered judge system that evaluates worker output at the exit of every LLM turn. Structural checks, LLM-powered quality scoring against success criteria, and three verdicts (ACCEPT, RETRY, ESCALATE) controlling graph execution flow.

Vision-language models, audio processing, unified embeddings, and multi-modal architectures for diverse data types.

Neural networks that simulate environments — from playable 3D worlds and game engines running on diffusion models, to photorealistic video generation from text prompts.

Intelligent document processing with OCR, vision-based parsing, table extraction, and RAG integration patterns.

Frameworks, tools, and guardrails for building applications with Large Language Models including prompt engineering and safety measures.

Agent platforms, orchestration frameworks, cloud ADKs, model-agnostic SDKs, and supporting tools across the AI ecosystem.