Useful Cheatsheets
Build / AI /

Autonomous Agent Loops

Build robust ReAct autonomous agent loops with termination conditions, state history management, and recursion limits.

TL;DR

  1. Implement autonomous decision cycles using the react-pattern loop.
  2. Enforce strict termination limits using a configurable max-iterations counter.
  3. Accumulate conversational observations inside a persistent state-history array.
Jump to section

ReAct Loop Architecture

    While Loop Framework

    Core iterative dispatch cycle powering autonomous reasoning.

    let iterations = 0;
const maxIterations = 10;
while (iterations < maxIterations) {
  iterations++;
  const res = await callModel(messages);
  if (!res.hasToolUse) return res.finalAnswer;
  await handleTools(res.toolUse);
}
    Termination Evaluator

    Evaluate whether agent has satisfied original user objective.

    function isComplete(res: ModelResponse): boolean {
  // Stop reason is end_turn and no pending tools
  return res.stop_reason === 'end_turn' &&
         !res.content.some(b => b.type === 'tool_use');
}
    Recursion Depth Guard

    Throw explicit boundary exception if iteration ceiling breached.

    if (iterations >= maxIterations) {
  logger.warn('Agent exceeded iteration ceiling');
  return 'Agent reached maximum iteration limit.';
}

State And Memory Management

    Append-Only History

    Maintain chronological audit trail of agent steps and data.

    messages.push({
  role: 'assistant',
  content: step.content,
});
messages.push({
  role: 'user',
  content: step.toolResults,
});
    Observation Compression

    Truncate oversized tool payloads to preserve context budget.

    function compressResult(raw: string, maxChars = 1500) {
  if (raw.length <= maxChars) return raw;
  return raw.slice(0, maxChars) + '... [truncated]';
}
    Scratchpad Reflection

    Inject periodic evaluation directives into conversational state.

    if (iterations === 5) {
  messages.push({
    role: 'user',
    content: 'Pause and evaluate progress to goal.',
  });
}

Loop Defenses And Safeguards

    Repetition Detector

    Detect cyclic tool calling and break repetitive loops.

    const isLooping = history.slice(-3).every(
  h => h.name === currentTool && h.args === currentArgs
);
if (isLooping) {
  injectWarning('Repeated action detected.');
}
    Token Spend Cap

    Track cumulative token usage and abort if budget exceeded.

    totalTokens += res.usage.total_tokens;
if (totalTokens > 50000) {
  throw new Error('Agent exceeded token budget');
}
    Graceful Fallback Exit

    Return partial summary when iteration limits are encountered.

    return await synthesizeSummary({
  originalGoal: goal,
  completedActions: executedSteps,
});

Production Agent Observability

    Step Telemetry Event

    Emit telemetry event after each completed reasoning turn.

    telemetry.track('agent_step', {
  iteration: iterations,
  tool: currentTool,
  tokens: res.usage.total_tokens,
  durationMs: stepDuration,
});
    Agent Run State Machine

    Track lifecycle states: starting, running, paused, failed.

    type AgentState =
  'idle' | 'running' | 'paused' | 'done';
let state: AgentState = 'running';
// Expose state via websocket for UI visualization
    Cancellable AbortSignal

    Permit user to cancel running agent loop at any step.

    if (abortSignal.aborted) {
  throw new Error('Agent execution cancelled by user');
}

Tips

  1. Cap agent execution loops at a maximum threshold using max-iterations to prevent runaway token expenditure.
  2. Store intermediate thoughts and tool results in an append-only state-history array to give the agent persistent memory.

Warnings

  1. Never run agent loops without hard iteration ceilings because cyclic reasoning traps can rapidly consume your api-credits.
  2. Avoid unbounded memory accumulation by summarizing or pruning tool outputs in multi-turn loops to avoid context-window overflow.

In Practice

FAQ