Concept Briefs
Short explainers on loops, graphs, memory, prompting, and the core vocabulary of agentic systems. Each piece stands alone — pick the topic you need right now and read it without preparing. Use these to fill vocabulary gaps, not to learn a full system. Concepts are written to be reread, not learned once.
Concept Briefs
Short explainers on loops, graphs, memory, prompting, and the core vocabulary of agentic systems. Each piece stands alone — pick the topic you need right now and read it without preparing. Use these to fill vocabulary gaps, not to learn a full system. Concepts are written to be reread, not learned once.
-
From Prompts to Agents: The Gap You're Probably Skipping
Most people who use LLMs daily are running one-shot or multi-turn prompts — not agents. The difference matters more than it sounds. Here is what actually changes when you move from prompts to agents, and why most people discover the gap only after they've built something brittle.
CONCEPTS -
From Prompts to Desks: Why One Agent Is Not Enough
The first time an agent system is set up, it is a single agent in a single session doing everything. That works until it does not. This is the beginner bridge from one generalist agent to a small team of desks with defined roles. What changes, what stays the same, and how to know when the move is worth making.
CONCEPTS -
What Is an LLM?
Large language models are next-token predictors trained on a wide corpus of human-written text. This piece explains what the model actually does, how it is trained, why it hallucinates, and what to look for when choosing one — the technical foundation the rest of the manual presumes.
CONCEPTS -
Agents and Robotics: Physical Workflows
A software agent that sends a wrong email is reversible. A robot that drives into a wall is not. This piece covers what changes when the agent's actions touch the physical world — the failure costs, the latency budgets, the safety patterns, and what current AI can and cannot do.
CONCEPTS -
Context Management and System Prompts: How the Operating Manual Gets Assembled
A system prompt is not a single file. It is assembled at runtime from a project file, an agent default, a tool-result injection, and the conversation history. This piece walks through where each layer comes from, what controls the order, what gets appended versus replaced, and how to inject permanent instructions that survive compaction.
CONCEPTS -
Evaluation, Safety, and Governance for AI Agents
Agents fail in ways classical software does not. Eval has to catch open-ended, multi-step, tool-mediated behavior. Safety has to bound runaway loops, prompt injection, and tool misuse. Governance has to make the system auditable. This piece is the advanced operator's checklist for all three.
CONCEPTS -
First Steps: Sessions and Memory
A session is a single conversation. Memory is what survives between sessions. Together they form the agent's lifecycle: each session starts cold, runs hot, and writes something durable for the next one. This piece is a practical first-day explanation of how this works and what the operator actually does.
CONCEPTS -
From Prompts to Agents
A prompt is a one-shot instruction. An agent is a system that runs prompts over time. The move from one to the other is not a single jump — it is a series of additions: system prompt, workspace, tools, memory, loop. This piece is the bridge.
CONCEPTS -
Future of Agent Architectures
Today's agent architecture is mostly language model plus memory plus tools plus loop. It works and will not be the final form. This piece is a forward-looking map of where the architecture is heading — what is being researched, what is being deployed, what is speculative, and what remains unknown.
CONCEPTS -
Getting Started with Workspaces
A workspace is the file system plus memory plus agent identity that an agent reads when it wakes up. The shape of that workspace determines what the agent can do, what it knows, and how easy it is to debug when something goes wrong. This piece is a practical first-day guide to what a workspace is, what it should contain, and how to start small and grow deliberately.
CONCEPTS -
How Does an Agent Understand?
An agent 'understands' by routing a query across three places: the current context window, the memory layer, and the model's pattern-matching weights. None of the three is real understanding. The three compose into the behavior that looks like understanding from the outside.
CONCEPTS -
Practical Applications: Personal, Team, and Business Agents
Three generations of agent deployments — personal, team, business — differ not in capability but in blast radius, governance, and cost model. This piece is a practical guide to figuring out which generation your use case belongs to, what to build first, and when to graduate to the next one.
CONCEPTS -
Prompting Patterns and Anti-Patterns
Most agent failures are prompting failures in disguise. The agent did not follow instructions, did not stay on task, did not produce the right output — not because the model is broken, but because the prompt was wrong. This piece catalogs the patterns that work reliably and the anti-patterns that produce repeat failures.
CONCEPTS -
Sandbox and Terminal Safety
An agent that can run shell commands is an agent that can destroy the file system, leak secrets, or call external APIs in ways the operator did not authorize. The sandbox is the discipline of bounding what the agent can do, what it can read, and what it can write. This piece is an operator's guide to the threat model, the five defensive practices, and the recovery playbook when the sandbox fails.
CONCEPTS -
What Is AI?
AI is a marketing label that covers several distinct technical generations — rules, classical ML, deep learning, LLMs, agents. The words mean different things at different times. An agent builder should know which generation they are actually using.
CONCEPTS -
Workspace Organization and Project Hygiene: Files as a Dogfooding Discipline
A well-run agent workspace is a small set of explicit files: AGENTS.md, SOUL.md, TOOLS.md, MEMORY.md, and the daily notes. Each file has a job; each file has a boundary. This piece is the dogfooding account of how Triadive uses these files itself, what each one is for, when to use them, when not to, and what the minimum viable workspace looks like.
CONCEPTS -
Agentic RAG: When Retrieval Thinks Before It Answers
Traditional RAG treats search as a static lookup. Agentic RAG lets the agent plan what to fetch, choose between retrieval tools, and re-query until the answer holds up. Here is what changes when retrieval itself becomes a loop, and when it is worth the added complexity.
CONCEPTS -
Cron Jobs in OpenClaw: Schedule Types, Payloads, and Delivery
OpenClaw's automation tool is the scheduler. Five schedule types (at, every, cron, on-exit, stream), four payload kinds (system-event, agent-message, command, script), and three delivery modes (announce, webhook, none) compose the design space. Most jobs use one of two combinations.
CONCEPTS -
Prompt Engineering for Agents in 2026: Operating Manuals, Not Magic Words
Prompting a chat assistant and prompting an agent are not the same problem. The system prompt is not a personality line; it is an operating manual that has to specify scope, tools, memory use, refusal behavior, and what to do when nothing else fits. This is a working set of best practices for writing prompts that survive contact with a long-running agent.
CONCEPTS -
Prompting Agents for 3D Tasks Without Losing Control
A 3D prompt is a contract. The shape of the contract — what is bounded, what is open, what the agent must not touch — is what keeps the agent useful without giving up the artist's authority.
CONCEPTS -
Algorithms: The Recipes Agents Need
An algorithm is a finite, deterministic sequence of steps that turns an abstract goal into an ordered set of tool calls. Most agent failures trace back to an algorithm that was never written down, or one that rotted away from the system it describes.
CONCEPTS -
Model Behavior: Laziness, Hallucination, and Accuracy
The same model can behave like a careful operator one day and a sloppy one the next. Three patterns show up repeatedly: laziness, hallucination, and accuracy degradation under load. Here is how each manifests and what the operator can actually do about it.
CONCEPTS -
Multi-Agent Orchestration: When One Agent Becomes a Team
The next failure mode after a working single-agent loop is the agent that tries to do everything at once. Multi-agent orchestration splits one loop into a coordinator and specialists with explicit handoffs and a shared contract. Here is when it makes sense and how the three patterns work in practice.
CONCEPTS -
Tools, Skills, and Plugins: The Three Extension Layers of an Agent
Every operator eventually confuses these three terms because platforms use them inconsistently. Here is the sharp distinction: tools are what the agent calls at runtime, skills are curated prompt+knowledge bundles the operator composes, and plugins are installable distributions of both.
CONCEPTS -
Best Ways to Ask an Agent for Things
A good request to an agent has four pieces: role, task, constraints, and examples. The model is roughly as capable as it is going to be — what changes between a working request and a failing one is the prompt that frames the work.
CONCEPTS -
Cron Jobs, Heartbeats, and Scheduled Work
Cron jobs run an agent session on a schedule. Heartbeats run an agent session at a faster cadence to keep state fresh. The two patterns are how long-lived automation actually gets built — and the design choices around them decide whether the automation is observable or silent.
CONCEPTS -
How Does an Agent Think?
An agent thinks in stages: intake, context, inference, tool execution, persistence, termination. Each stage is its own design problem. Understanding the stages is what separates a working agent from one that hallucinates, stalls, or runs forever.
CONCEPTS -
Inside the Agent Loop
The agent loop is six stages: intake, context, inference, tool execution, persistence, termination. Each stage is its own design problem. This piece walks through each stage with concrete examples of what can go wrong and how to fix it.
CONCEPTS -
Sessions, Sub-Agents, and Child Sessions
A session is the boundary of one unit of agent work. Sub-agents let a parent session delegate part of the work to a child session. The design choices around session boundaries are what decide whether an agent system scales or stalls.
CONCEPTS -
What Is a Graph?
A graph is a collection of nodes (steps) and edges (typed transitions) that an agent moves through. In agent work, graphs are how non-trivial workflows stay auditable, branchable, and reusable. They are not a replacement for loops; they are a structure around them.
CONCEPTS -
What Is a Loop?
A loop is the smallest repeating structure that lets a system make progress on a goal it cannot finish in one pass. In agent work, loops are how an AI system turns a single model call into something that can do multi-step work.
CONCEPTS -
What Is an AI Agent?
An AI agent is a system that takes a goal, gathers context, decides what to do, acts through tools, and keeps working until the goal is done or a stop condition fires. The agent is the loop; the model is one component inside it.
CONCEPTS -
OpenClaw Control on Mac and in the Browser
OpenClaw gives you two surfaces for the same system: a native macOS app and a browser-based Control UI. The Mac app is the local front door. The browser is the workbench. This article explains both, when to use each, and how they fit together.
CONCEPTS -
Pursuing Goal in OpenClaw
Pursuing goal is the feature that gives an OpenClaw session one durable objective, keeps it visible across turns, and turns long-running agent work into something an operator can actually follow. This article walks through what the feature does, why it matters, the six goal states, the goal tools the model can use, the /goal command surface, and the common mistakes a new operator makes.
CONCEPTS -
Wiki Memory: The Fourth Layer Most Agent Systems Skip
Wiki memory is a hand-edited knowledge base that sits on top of long-term notes and semantic search. It is the fourth layer most agent systems skip — and the layer that keeps a workspace coherent past year one.
CONCEPTS -
What Is an Agent Loop?
An agent loop is the repeating cycle an AI agent uses to make progress on a goal. It takes in a request, gathers context, reasons about the next step, uses tools if needed, records what happened, and decides whether to continue or stop. Once the loop is visible, much of agent behavior becomes easier to read, debug, and improve.
CONCEPTS -
Loops vs Graphs: When to Stop Iterating and Start Routing
Loops are what an agent does to make progress. Graphs are what an operator builds to keep a long-running system out of trouble. Knowing which one you are working on saves weeks.
CONCEPTS -
Memory: Short-Term, Long-Term, and Semantic
Agent memory has roughly three layers: short-term (the current conversation), long-term (notes the agent has saved), and semantic (vectors retrieved by relevance). Each layer has different rules for what goes in and what comes out.
CONCEPTS -
Why memory is the hardest part of any long-running AI workflow
Most operators underestimate the cost of memory until they hit it. A short field guide to the kinds of memory problems that show up after week one.
CONCEPTS