Concept

• ACI Design Principles - Keep agent actions simple and efficient, feedback informative but concise, and add guardrails that catch common errors before they compound.
• Action Format Enforcement - Require one thought and one action per turn, repair or strip malformed replies, and stop the episode after repeated format failures.
• Agent Environment Tree - Represent places and objects as a containment tree rendered to natural language, with each agent holding only a personal subgraph that can go stale.
• Agent Episode Prompt Stack - Compose an agent episode as fixed system, optional demonstration, instance brief, then per-turn next-step templates around action and observation.
• Agent Episode Termination Modes - Distinguish intentional submit, cost-limit submit, cost-limit with no edits, and early format-exit — only intentional submits resolve at useful rates.
• Agent Tool Categories - Agent tools fall into knowledge augmentation, capability extension, and write actions, with risk rising sharply for tools that mutate the environment.
• Agent Tool Failure Modes - The right tool can still return wrong output, mistranslate an NL plan, or be missing entirely — failures that must be tested per tool, not only per plan.
• Agent Trajectory Phases - Expect early localization/reproduction, then mid-episode edit–evaluate cycles, then submit — and redesign recovery when the first approach fails.
• Agent UX Steering Affordances - UI controls that expose tool activity, let users edit or authorize calls, and regenerate from a corrected point so humans steer the agent mid-trajectory.
• Agent-Computer Interface - Design the commands, observations, and history formatting an LM agent uses to operate a computer so digital work matches model limits, not human GUIs.
• Argument Hallucination - A model may invent plausible-looking placeholder values for tool arguments never mentioned in the conversation, producing schema-valid but semantically wrong calls, rather than asking for them.
• Autonomy Bounded by the Prepared Envelope - An agent that takes operational actions should act alone only on situations matching a known runbook signature, and leaving that prepared envelope (unknown diagnosis, exceeded retry or failure thresholds, a high-risk action) should trigger escalation as a planned step.
• Blind Scroll Loop - After finding a large file, repeatedly scrolling without search/goto wastes the episode — re-invoke search for the next symbol instead of linear hunting.
• Bounded Search Observations - Cap and normalize search-tool output so localization stays informative without drowning the context window in unbounded grep dumps.
• Browse-Then-Answer Episode - Separate a browsing phase that gathers quoted references from a later answer phase that composes only from those references and the question.
• Browser Tool Action Inventory - Give browsing agents a small closed command set — search, click-by-ID, find, quote, scroll, back, end — instead of free-form browser scripting.
• Citation-Backed Agent Answers - Require agents to collect quotable references while using tools so answers are checkable for factual accuracy without independent research.
• Collapsed Observations - Preserve history structure while replacing old tool or command outputs with short placeholders to cut tokens and drop stale duplicate state.
• Configurable ACI Harness - Specify an agent-computer interface as config — prompt templates, command files, parsers, history processors, and stateful environment variables.
• Decouple Brain, Hands and Session - Separate the model loop (brain), the sandbox (hands) and the durable session log so each can fail and be replaced on its own; a dead container surfaces as a tool error and is re-provisioned, not nursed.
• Deterministic Back-Pressure - Type checkers, linters, tests and structural lints are the deterministic signals that make looping agents converge; once a rule is objective, encode it as a check rather than prose.
• Diagnose by Default, Act by Exception - An agent that operates live systems should run read-only by default and reach write actions only through review, a narrow deterministic action or a separately configured, time-bound elevated tier.
• Doom-Loop Detection - Harness middleware should detect repetitive actions, such as repeated edits to the same file, and push the agent to change approach, much as a circuit breaker or retry budget does.
• Durable Approval State - Human approvals must be durable state: the workflow suspends on a signal without using compute, and the decision is persisted, so a restart neither loses the approval nor asks the human twice.
• Editable Tool-Call Correction - Let users edit a shown tool call's arguments and resubmit, regenerating the conversation forward from that corrected point.
• Failures Returned as Actionable Feedback - Agents recover when tool errors, timeouts and hangs come back as specific, actionable feedback; silence, opaque codes, or termination without a chance to diagnose prevent recovery.
• Forced Tool-Choice Extraction - Extract structured content from free-form input by defining a tool shaped like the target structure and forcing the model to call it.
• Full-Trace Remediation Audit - Log every action an operational agent takes with identity, prompt, tool calls, trigger and verified result, keeping raw traces as well as summaries, so each action is reconstructable and the agent can always say what it did and why.
• Function Calling - Model-provider-native tool use — declare a tool inventory, let the model emit structured calls, execute them in the harness, and feed results back.
• Function-Call Chaining - Let the model request immediate follow-up inference after a tool result so multi-step retrieval or edits can run without waiting for a new user turn.
• Guardrailed Edit Tool - Apply multi-line edits only when lint or syntax checks pass; on failure revert and show error type, proposed snippet, and original content.
• Guides and Sensors - Harness controls are feedforward guides (rules, docs) or feedback sensors (tests, analysis, reviewers), each computational or inferential; sensors are placed by cost, cheap ones locally and fuller ones later.
• Human Approval Gates - Explicit per-action automation levels so humans can supply plans, validate them, or approve irreversible tool calls before the agent proceeds.
• Human–Model Demo Interface Parity - Collect demonstrations through the same action/observation surface the model will use, exposing only deliberate exceptions such as memory summaries.
• Hybrid Agent-Tool Static Analysis - Bridge conventional static analysis tools with LLM agents to disambiguate warnings and verify candidate defects across complex code paths.
• Inline API Call Interruption - Decode until the model emits a call-result delimiter, pause generation, inject the tool response, then continue decoding in the same sequence.
• Invalid Action Budget Accounting - Count malformed or unknown commands against the episode action budget even when they are ignored, so format failure cannot be free.
• LM-Oriented Web Observations - Convert pages and search hits into tokenizer-stable text with numbered links, readability extracts, and media placeholders shaped for LM agents—not browsers.
• Make the Runtime Legible to the Agent - Exposing the running system's UI, logs, metrics and traces to the agent, for example through an ephemeral per-worktree observability stack, turns reliability goals into tasks the agent can verify.
• Minimal, General Tool Surface - A few general tools (read, write, edit, bash) plus command-line tools documented on demand often beat large bespoke tool sets, which spend context and confuse selection; MCP versus CLI remains disputed.
• Model Context Protocol - An open standard that unifies how agents securely discover, authenticate, and invoke external developer tools, execution environments, and data sources.
• Narrow Action Verb Set - Give an agent that changes real systems a small set of named, single-purpose, parameterised action verbs instead of a shell or a root-equivalent API, so least privilege can be expressed, audited and approved per action.
• Pinned Goal with Harness-Audited Acceptance Checks - Pin the objective once, with named acceptance checks such as a test file or command, and let the harness refuse to close the goal until those checks pass; a progress probe nudges the agent when it stalls.
• ReAct Thought Editing - Let humans correct a few reasoning traces mid-episode so later actions realign — cheaper than retyping action sequences or retraining the policy.
• Replay-Safe Tool Annotation - After a crash, only tools declared replay-safe rerun; every other interrupted tool returns an "interrupted" result to the model, so read-only diagnostics repeat freely while deploys or restarts cannot.
• Self-Supervised Tool Annotation - Sample candidate API calls, execute them, keep only those that reduce future token loss, then finetune so the model learns when tools help.
• Seven Harness Subsystems - A harness has to cover seven subsystems (loop, LLM integration, tools, memory and context, safety and permissions, orchestration, extensibility), which gives a shared vocabulary for saying which layer broke.
• Stateful File Viewer - Give the agent a windowed, line-numbered view of the open file with goto and scroll commands instead of flooding context with full-file dumps.
• Stateful Object of Discourse - Give a conversation a persistent object that gets edited in place across turns, instead of having the model re-emit a fresh copy into the transcript every time.
• Stateful Task Agents - Bind an agent permanently to one work item instead of restarting fresh each time, so it can track that item's state and notify dependents when it changes.
• System Prompt Architecture - Split developer instructions into a privileged system prompt and user content into a user prompt, then render them through the model's chat template.
• The LLM Proposes, Code Applies - The LLM proposes a diagnosis and an action from a schema of pre-approved actions while deterministic code computes, validates and applies the change, so the model never holds write authority and constrained output also cuts injection success.
• Token-Efficient Quote Observations - Let find/quote tools match case-insensitively and return abbreviated start–end spans so evidence fits the context budget without full-page dumps.
• Tool Call Decoding Budget - Control how freely the model may emit tool-call tokens at decode time — too tight under-calls, too loose destroys calibration of when tools help.
• Tool Definition Design - Name, schema, and documentation choices that make tools easy for the model to select and call correctly without overlapping or over-complex surfaces.
• Tool Definition Internal Representation - Native function calling is a fine-tuned chat model plus API-level syntactic sugar — tool defs render as TypeScript signatures, calls as ChatML-like tags.
• Tool Inventory - The declared set of tools an agent may call; inventory size is a capability versus reliability and context-budget tradeoff.
• Tool-Call Transparency UI - Surface an agent's background tool activity in the chat UI itself so users can inspect the rationale behind an unexpected response.
• Toolformer Tool Use - Train an LM to choose which API to call, when, with what arguments, and how to use the result — self-supervised, without tying tools to one task.
• Unknown State on Resurrection - When a crash leaves a tool's outcome uncertain, tell the agent the state is unknown so it re-inspects the real resource before retrying, because agent checkpoints do not capture sandbox state and the newest commit may be lost.
• Verify Before Done - Agents favour their first plausible answer and declare completion early, so the harness must force verification before "done": a pre-completion checklist, end-to-end tests run as a user would, or an agreed sprint contract.