Concept

• A Deterministic Score Gates LLM Diagnosis - A fixed, formula-based score built from a few observable variables should decide when to wake an LLM diagnostician, so the LLM is never the component that decides whether there is a problem.
• Agent Control Flow - The order planned actions execute — sequential, parallel, conditional, or looped — with the model itself often determining non-sequential branches.
• Agent Planning Failure Modes - Plans fail via invalid tools, bad parameters, wrong values, unmet goals or constraints, or false success from broken reflection.
• AI Pipeline Orchestration - Declare models, data sources, and tools, then chain them so formats match and failures surface across multi-step agent and RAG pipelines.
• Assistant–UserProxy Pair - Two-role micro-workflow where a tool-using Assistant acts and a UserProxy keeps it on the human goal, corrects drift, and declares completion.
• Auditor-Critic Inspection - Separate vulnerability and defect detection into an auditor that generates candidate flaws and a critic that rigorously scores and filters false positives.
• Batch vs. Streaming Workflow Processing - Decide separately from topology whether a workflow processes a known finite set of work items together or an ongoing stream as items arrive.
• Closed-Loop Critique Failure Modes - Autonomous multi-agent critique loops risk infinite oscillation, mutual error reinforcement, and rapid token exhaustion without deterministic termination criteria.
• Compound Mistake Amplification - Per-step accuracy multiplies across a multi-step agent trajectory, so long plans fail even when each individual step looks reliable.
• Conversational Agent Structural Limitations - Conversational agents lack a built-in mechanism for processing discrete work units and no enforceable lever over how a task gets done, unlike a workflow.
• Cyclic Workflow Repair Loops - Route a failed work item back to an earlier task for another attempt, at the cost of context reattachment, universal failure handling, and loop limits.
• Dead Delivery Route Detection - Detect when accepted work is not reaching or being consumed by its intended recipient by measuring progress and liveness at each route boundary.
• Degradation Ladder - Define an agent system's fallback modes in advance (full service, reduced tools or cheaper model, read-only, paused with a holding message, stopped) and classify workloads by droppability while calm, so retreat during an incident is chosen rather than a collapse.
• Emergent Multi-Agent Coordination - Believable group behaviors — information diffusion, relationship continuity, and event coordination — arise from per-agent memory and planning, not hard-coded scripts.
• Exactly-Once Only After Journaling - Durable-execution "exactly-once" holds only for results already journaled and for submissions keyed by an idempotency key, because a crash between an effect and its journal write re-executes the effect.
• External Supervisor over Self-Diagnosis - A degraded agent cannot be trusted to diagnose or repair the process and store it runs in, so supervision and repair belong to a separate process with its own identity, credentials and failure domain.
• Fail-Loud Background Sync and Safe Divergence Recovery - Unattended Git sync jobs should expose failures by class and recover from divergence only through verified, non-destructive integration.
• Hierarchical Planning - Generate a high-level plan first, then expand each step into a detailed sub-plan, avoiding the generate-hard versus execute-hard granularity bind.
• Intent Classification for Routing - Classify what the user is trying to do so the agent selects the right tools and can decline out-of-scope queries before wasting a plan.
• Inter-Agent Coordination Protocols - Structure multi-agent interaction through formal task bidding, contract awards, and standardized messaging layers rather than free-form conversational chatter.
• Internal External Knowledge Routing - Fall back between retrieval-grounded acting and sample-and-vote CoT when step budget or answer confidence shows one path is stuck.
• Iterative Refinement Feedback Channels - Classify agent refinement feedback across model-based reflection, tool-grounded environment diagnostics, and human clarification.
• Iterative Research Conversations - A bounded question-answer loop lets retrieved evidence expose gaps and drive deeper follow-up searches during agentic research.
• Journal Then Replay - Durable-execution engines persist step results in a journal or event history and recover a crashed agent run by replaying it, with deterministic step identifiers acting as memoisation keys so work resumes from the failure point.
• Level-Triggered Reconcile Loop - An agent that repeatedly compares desired with actual state, and acts to close the gap, tolerates missed events and crash-uncertain outcomes better than one reacting to individual alerts.
• LLM-Driven Workflow Routing - Escalating autonomy where an LLM chooses, generates, or prioritizes tasks instead of a fixed DAG — trading dependability for open-ended flexibility.
• Multi-Agent Architecture - Split agent work across specialized roles — planner, validator, executor, critic — so each component has a narrower job than a single monolithic agent.
• Multi-Agent System Advantages - Decompose complex software engineering workflows into collaborative agents to gain specialization, modular upgrades, diverse perspectives, tool synergy, and parallelism.
• Multi-Agent Token Inflation - Mitigate rapid token and latency growth in multi-agent workflows by enforcing loop early-stopping, deterministic verification gates, and structured message passing.
• Natural Language Action Plans - Express agent plans in natural language then translate to tool calls, which is more robust to API churn than planning directly in exact function names.
• Non-LLM Task Implementation - Not every workflow task needs an LLM — mechanical, retrieval, and classification tasks are usually cheaper and more dependable without one.
• One Unit of Work per Session - Limiting each session or loop iteration of a long-running agent to one feature or item prevents one-shot attempts and premature "done" claims.
• Perspective-Guided Research - Assigning distinct perspectives to parallel research branches broadens the questions and evidence gathered before synthesis.
• Phased Explore-Write-Early Pattern - For a long-running autonomous exploration task, mandate a checkpointed partial write well before completion and periodic updates after — so a useful artifact exists even if the run is cut off early.
• Plan Validate Execute - Decouple plan generation from execution so a bad plan can be rejected before it burns tool calls, tokens, and irreversible side effects.
• Progressive Agent Architecture - Grow from a bare model API to a full agentic system in ordered steps — context, guardrails, routing/gateway, caching, then write-capable loops.
• ReAct Loop - Interleave reasoning traces that update context without side effects and environment actions so plans stay grounded and exceptions stay recoverable.
• ReAct Success and Failure Taxonomy - Audit interleaved reason–act trajectories as true/false positives plus reasoning, search, hallucination, and label-ambiguity failures — not only EM.
• Reflection and Error Correction - Reflection evaluates feasibility, plans, and outcomes; error correction acts on that insight by regenerating plans or retries until the goal is met.
• Reflexion - Separate an Actor, Evaluator, and Self-Reflection module so sparse outcome signals become verbal lessons that condition the next trial.
• Research Outline as a Control Artifact - An explicit outline between research and drafting exposes coverage for evaluation and controls how evidence is retrieved for generation.
• Role-Based Agent Delegation - Assemble agents with distinct roles, goals, and tools and delegate work between them like a team, following the AutoGen and CrewAI frameworks.
• Shared Task Board Coordination - Multi-agent work can be coordinated through a durable, dependency-aware task board in which every cross-role decision is a card comment, a dispatcher promotes cards when their dependencies finish, and the coordinator has no tools to do the work itself.
• Single-Threaded Writes - Multi-agent systems work when exactly one actor writes to a given piece of state and the others only add intelligence through review, consultation or research; parallel-writer swarms and second writers on a state store fail.
• Skill Library - Persist newly composed skills that proved useful so later tasks can reuse them as first-class tools instead of rediscovering the composition.
• Stage-specific WIP accounting - Define WIP against explicit workflow start and finish points, and separate active build constraints from downstream acceptance queues.
• Start Simple and Own the Control Flow - Start with the simplest single-agent design, treated as mostly deterministic software with LLM steps at chosen points, and add agency or more agents only when the simpler design demonstrably falls short.
• Start-of-Session Smoke Test - Every session of a long-running agent should orient itself and run an init script plus a basic end-to-end check before starting new work, so a broken inherited state is caught before anything is built on it.
• Supervision-Tree Escalation - Every automated restart or retry loop in an agent system needs an OTP-style intensity and period cap that turns repeated failure into escalation up a supervision tree, with restart strategies that encode how components depend on each other.
• Task Decomposition Prompting - Split a complex job into chained simpler prompts for better control, cheaper models on easy steps, and inspectable intermediate outputs.
• Task I/O Schema Design - Define each workflow task's input/output shape explicitly, and separately keep a clear-enough idea of how the task should be accomplished.
• Task Ownership Trees - Tasks and sub-agent conversations should form an explicit ownership tree in which parents wait on children under allSettled or failFast, aborts propagate down, and a replay-safe spawn finds its existing child instead of creating a duplicate.
• Task Quality Escalation Ladder - When a task's first-draft results aren't good enough, escalate through a fixed sequence of fixes rather than reaching for the most complex one first.
• The Effect Sandwich - Commit the intent, perform the external effect, then commit the outcome, so that a process reopening in the intent phase knows the effect may already have happened and must retry safely, poll an external handle, or record an interruption.
• Verbal Reinforcement Learning - Improve an agent across trials with linguistic self-reflection stored in memory instead of weight updates or scalar reward fine-tuning.
• Workflow Build Process - Build an LLM workflow in five ordered steps — define the goal, specify tasks, implement tasks, wire the workflow, then optimize — for modularity.
• Workflow Topology - A workflow's task-connectivity shape — pipeline, DAG, or cyclic graph — trades simplicity against flexibility independently of what each task does.
• Worktree-Isolated Sub-Agent Fan-Out - When parallel sub-agents must write, give each its own git worktree checked out from a base commit, bound concurrency, and treat cancellation as cooperative, so parallel writers never collide mid-flight and the parent checkout stays untouched.
• World-Model-Augmented Planning - Planning needs predicted action outcomes and backtracking, so bare chain-of-thought action lists often fail without state or search support.