The Articles
Every Triadive essay, explainer, workflow review, lesson, glossary entry, and dispatch — organized so you can read what you actually need, not whatever happens to be newest. Field Notes are flagship essays. Concept Briefs are explainers. Workflow Reviews are patterns. Lessons are reflections. Glossary entries are the working vocabulary. Dispatches are the weekly newsletter.
Field Notes
Flagship essays — single-topic deep dives into how the human / agent / robot triad actually works in practice. Each piece aims for the longest useful life: principles first, examples second, hand-waving third. Read these when you want the conceptual foundation before the next workflow or lesson, or when you need a single, durable take on a topic that the rest of the manual keeps returning to.
-
Work Desks and Specialty Agents: The Architecture Between Sessions and Teams
Sessions, jobs, work desks, and specialty agents are four names for the same primitive — and knowing which one you mean changes how you design, debug, and govern a running agent system. Here is the vocabulary, the hierarchy, and the six things a coordinating agent gets wrong when it tries to do everything itself.
FIELD-NOTES -
Field Note: When the Prompt Cache Saved the Morning
A small prompt restructure cut our morning cron latency from 4s to 1.1s and dropped the daily cost by 14%. Nothing else changed. A field note on what we learned, what didn't change, and what we now check weekly.
FIELD-NOTES -
Agent Loops: The Operating Rhythm of an AI System
Every agent system runs on a loop. This field note surveys the loops Triadive has documented — single-shot, multi-turn, cron-driven, sub-agent, and graph-driven — and names the design choices that decide whether a loop keeps an agent coherent or slowly destroys it.
PILLAR -
Loops vs Graphs: When Iteration Becomes Routing
Loops and graphs are the two shapes an agent workflow can take. Loops iterate until something terminates; graphs route through typed transitions until they reach a terminal node. This pillar names the threshold where iteration becomes routing, the patterns that work at that threshold, and the mistakes that come from picking the wrong shape.
PILLAR -
Agent Memory and State: How an AI System Remembers What It Needs To
Memory is the part of an agent system that decides whether the agent remembers anything between loops. This pillar surveys the four layers Triadive has documented — short-term, long-term, semantic, wiki — and the design choices that decide which layer to reach for, when, and at what cost.
PILLAR -
Field Notes: The Three Amigos of the Agent Stack
The user, the model, and the runtime are not the same person. Most operational confusion in agent work comes from forgetting which one is doing what. A short field note on how to keep the three roles straight.
FIELD-NOTES -
Field Notes: Triads, Not Tools
The human / agent / robot triad is a working arrangement, not a brand. Why the underlying pattern keeps showing up under different labels — and what to design for when it's the pattern that matters.
FIELD NOTES
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
Workflow Reviews
Pattern reviews: what a given workflow is good for, where it breaks, and how to improve it. Each piece documents a real workflow as it runs in practice, with the failure modes surfaced and the cost in operator time made explicit. Read these when you have a workflow problem to solve, or when a workflow you already run has started failing and you need to know why.
-
Setting Up Your First Three Desks
Three desks cover most small operations: a research desk, an editorial or production desk, and an operations desk. This workflow walks through the setup step by step — writing charters, carving the workspace, defining the job queue, and proving the system works before adding a fourth desk.
WORKFLOWS intermediate 2026-08-26 -
Setting Up Your First Three Work Desks: A Practical Starting Point
The most common mistake in early agent architecture is building one agent that does everything, then watching it slowly lose coherence under the weight of competing contexts. The fix is not more prompts. It is a small desk architecture. Here is how to set it up in practice.
WORKFLOWS intermediate 2026-08-26 -
An Agent Eval Workflow
A practical recipe for evaluating an agent system before it ships. Four layers to test, a 30-line harness in prose, what to do when an eval fails, and a minimum-viable eval you can stand up in an afternoon. Built for operators, not researchers.
WORKFLOWS intermediate 2026-08-09 -
Simple Workflows for Beginners
A workflow is a procedure the agent runs on a schedule, on demand, or in response to an event. The simplest workflows are the most reliable. This piece covers what a workflow is, the three trigger shapes, the minimum viable workflow, and the patterns that hold up as you grow.
WORKFLOWS beginner 2026-08-09 -
Using Agents to Manage Asset Libraries for 3D Work
Asset libraries fail when organization depends on the artist's discipline. An agent can tag, index, and surface assets without ever importing one — and that is exactly the value.
WORKFLOWS intermediate 2026-08-07 -
Blender + OpenClaw: Agents in the 3D Pipeline
Blender is a creative engine with a Python API. Agents should sit beside it, not inside it — automating render queues, writing bpy scripts for human review, and packaging assets the human then refines.
WORKFLOWS intermediate 2026-08-07 -
Crons + Skills + Loops + Lobsters + Workboard: How the Pieces Compose
A cron fires a payload. The payload is an agent turn. The agent turn runs skills, walks loops, drives lobsters, advances workboard cards. The composition is the design — and the design is what most operators skip.
WORKFLOWS intermediate 2026-08-07 -
Effective Cron Design: Idempotency, Pacing, Retries, and Condition Triggers
An effective cron is one you can run twice without breaking anything. The disciplines are idempotency, pacing, retries, condition triggers, and observability. Each one is cheap to add; each one is expensive to skip.
WORKFLOWS advanced 2026-08-07 -
Graph-Driven Pipelines: Blender, Game Engines, and Printers
When Blender hands off to a game engine, a 3D printer, or another tool, the handoff has shape. State graphs are how you make that shape explicit, debuggable, and recoverable.
WORKFLOWS advanced 2026-08-07 -
Long-Context Agents: Designing Workflows That Survive a Million Tokens
Long context changes what an agent can hold in mind, but it does not remove the need for good memory, good chunking, or good governance. This is the working set of patterns for designing workflows that use long context well — and the failure modes that arrive when long context is used as a substitute for design.
WORKFLOWS advanced 2026-08-07 -
Designing Safe Render Loops for Blender
A render queue should be a loop that respects budgets, fails honestly, and never modifies the source scene. The discipline is in the bound — not in the cleverness of the agent.
WORKFLOWS advanced 2026-08-07 -
State Graphs in Practice: Beyond Loops and Pipelines
Loops are how an agent makes progress. State graphs are how an operator builds a workflow that survives being long, branched, and shared with other agents. This article is about the move from loop-shaped systems to graph-shaped systems — what the new shape buys you, what it costs, and how to keep the graph from collapsing into spaghetti.
WORKFLOWS advanced 2026-08-07 -
Workflow Review: The Daily Check-in Loop
A small loop that runs once a day to surface what changed overnight, what is overdue, and what is at risk. Less work than you think, more leverage than you expect.
WORKFLOWS intermediate 2026-07-29 -
Workflow Review: The Daily Triage Routine
A triage routine is the cheapest reliable habit a long-running agent can have. It doesn't replace careful work; it just makes sure the careful work happens to the right thing. The pattern is small enough to ship in a day.
WORKFLOWS beginner 2026-07-29 -
Three rules for picking the first plugin you actually keep
Most operators install too many plugins too early. Three filters separate the ones that earn their place from the ones that get uninstalled by week two.
PLUGINS intermediate 2026-07-29
Lessons Learned
Anonymized, pattern-based reflections from running long-lived agents and tool chains. These are not how-tos. They are the postmortems: what went wrong, what the operator did about it, and what to keep in your back pocket for the next time it happens. Read these when you want to avoid a mistake someone else already paid for — or when you want to know which mistakes are inevitable and which are avoidable.
-
Desk Architecture Failure Modes: What Breaks First and How to Fix It
After running desk-based architectures across dozens of agent systems, the same failure patterns show up in the same order: context bleeds, memory饱和, handoff drops, and authority drift. Here is what each one looks like in practice, why it happens, and how to detect it before it causes real damage.
LESSONS intermediate 2026-08-26 -
Desk Architecture Failure Modes: The Six Ways Operators Get It Wrong
Adding desks does not automatically make a system better. It can make it worse — slower, more confused, and harder to debug. This lesson catalogs the six failure modes operators hit when they move from one generalist agent to a desk-based architecture, with the diagnostic signals and the fix for each.
LESSONS intermediate 2026-08-26 -
Where AI Helps Blender, and Where It Should Stop
AI helps with the tedious parts of 3D — base meshes, texture cleanup, denoising, rig auto-weighting. It does not help with the parts that need judgment. The line between is worth drawing clearly.
LESSONS intermediate 2026-08-07 -
Lessons Learned: Memory Design Mistakes in Early Agent Work
Three memory mistakes show up in nearly every first attempt at long-running agents: writing too much, writing too little, and writing in the wrong place. Each looks like a different kind of failure, but the underlying cause is the same — the agent is writing notes without writing knowledge. The fixes are architectural, not behavioral.
LESSONS intermediate 2026-07-29 -
Lessons Learned: Why Agents Stall Without Clear Termination
Termination is the most under-engineered part of the agent loop. Most agents stop on the wrong signal — or no signal at all — because the operator treated stop conditions as something the model would figure out. This piece walks through the four failure modes, the four parts of a testable stop condition, and the concrete patterns that make termination reliable.
LESSONS intermediate 2026-07-29 -
Lessons Learned: Why Context Explodes Without Bounding
The most common silent failure in long-running agents is unbounded context growth. The runtime decides to keep accumulating context without bound, and the model — responding to the unbounded transcript — eventually degrades. The fix is at the runtime layer: cap tool result sizes, cap retry counts, summarize resolved turns, and offload old context to long-term memory at intervals.
LESSONS intermediate 2026-07-29
Glossary
The vocabulary of agentic systems — concise definitions of the terms that show up in every Triadive article. Each entry stands alone and is referenced from concept, workflow, and lesson pieces. Read these once, then refer back as needed. The glossary is a working reference, not a sequential read. Start with the foundational primitives — loop, graph, memory, session — and branch out from there.
Dispatches
Weekly editorial newsletter published every Saturday morning. Each issue is a 1,800–2,500 word pattern essay + short recap + one observation. The dispatches are how the manual itself stays current: the week's new pieces, the operator-decision pattern, and one observation on what changed. Subscribe via RSS or read in the browser; new issues land here every Saturday at 11:00 ET.
- Dispatch #5 — The CEO-agent bottleneck: why centralized review is the operator's most expensive habit 2026-08-29
- Dispatch #4 — The vocabulary tax: why naming the primitive is the operator's cheapest move 2026-08-22
- Dispatch #3 — Why bounded context wins 2026-08-15
- Dispatch #2 — Static-first: why a 4-line reordering cut a cron's latency by 73% 2026-08-09
- Dispatch #1 — Why field manuals outlast vendor docs 2026-07-29