Intermediate
Patterns, prompts, and platform practices. What experienced operators reach for after the basics are familiar.
Once the basics are familiar, these pieces cover the patterns, prompts, and platform-specific practices that show up when an agent system has to last longer than a single session.
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.
-
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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
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 -
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 -
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 -
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 -
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 -
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