AutoGPT 무한루프·비용폭주 막는 가드레일 7가지

// TypeScript 예시: 에이전트 루프 하드 리밋

type ToolName = string;

interface Limits {
  maxSteps: number;
  maxWallTimeMs: number;
  maxRetriesPerTool: number;
}

interface State {
  step: number;
  startedAt: number;
  toolRetries: Record<ToolName, number>;
}

function assertLimits(state: State, limits: Limits) {
  if (state.step >= limits.maxSteps) throw new Error("GUARDRAIL: maxSteps exceeded");
  if (Date.now() - state.startedAt >= limits.maxWallTimeMs) {
    throw new Error("GUARDRAIL: maxWallTime exceeded");
  }
}

function canRetryTool(state: State, tool: ToolName, limits: Limits) {
  const n = state.toolRetries[tool] ?? 0;
  return n < limits.maxRetriesPerTool;
}

# Python 예시: 간단한 예산 차감기

from dataclasses import dataclass

@dataclass
class Budget:
    max_input_tokens: int
    max_output_tokens: int
    max_tool_calls: int

    used_input_tokens: int = 0
    used_output_tokens: int = 0
    used_tool_calls: int = 0

    def charge_llm(self, in_tok: int, out_tok: int):
        self.used_input_tokens += in_tok
        self.used_output_tokens += out_tok
        if self.used_input_tokens > self.max_input_tokens:
            raise RuntimeError("GUARDRAIL: input token budget exceeded")
        if self.used_output_tokens > self.max_output_tokens:
            raise RuntimeError("GUARDRAIL: output token budget exceeded")

    def charge_tool(self, n: int = 1):
        self.used_tool_calls += n
        if self.used_tool_calls > self.max_tool_calls:
            raise RuntimeError("GUARDRAIL: tool call budget exceeded")

// TypeScript 예시: 최근 스텝 서명 기반 루프 감지

function stableStringify(obj: any) {
  return JSON.stringify(obj, Object.keys(obj).sort());
}

function stepSignature(tool: string, args: any, observation: string) {
  // observation은 너무 길면 앞부분만
  const obs = observation.slice(0, 300);
  return `${tool}::${stableStringify(args)}::${obs}`;
}

function detectLoop(signatures: string[], windowSize: number) {
  const w = signatures.slice(-windowSize);
  const uniq = new Set(w);
  // window 내 고유값이 너무 적으면 루프 가능성
  return uniq.size <= Math.ceil(windowSize / 3);
}

# Python 예시: 도구 호출 게이트

import time

ALLOWED_TOOLS = {"search", "fetch_url", "summarize"}
TOOL_COOLDOWN_SEC = {"search": 3, "fetch_url": 5}

last_called_at = {}

def guard_tool_call(tool_name: str, args: dict):
    if tool_name not in ALLOWED_TOOLS:
        raise RuntimeError("GUARDRAIL: tool not allowed")

    # 간단한 스키마/상한 검증
    if tool_name == "search":
        q = args.get("query", "")
        if not (1 <= len(q) <= 120):
            raise RuntimeError("GUARDRAIL: invalid query length")
        if args.get("top_k", 5) > 5:
            raise RuntimeError("GUARDRAIL: top_k too large")

    # 쿨다운
    now = time.time()
    cd = TOOL_COOLDOWN_SEC.get(tool_name)
    if cd is not None:
        prev = last_called_at.get(tool_name, 0)
        if now - prev < cd:
            raise RuntimeError("GUARDRAIL: tool cooldown")
        last_called_at[tool_name] = now

// TypeScript 예시: 롤링 요약 기반 컨텍스트 구성

interface Memory {
  rollingSummary: string;
  recentTurns: { role: "user" | "assistant"; content: string }[];
  evidence: { source: string; quote: string }[];
}

function buildPrompt(mem: Memory) {
  const recent = mem.recentTurns.slice(-6)
    .map(t => `${t.role}: ${t.content}`)
    .join("\n");

  const evidence = mem.evidence.slice(-8)
    .map(e => `- [${e.source}] ${e.quote}`)
    .join("\n");

  return [
    "SYSTEM: You are a careful agent.",
    `STATE SUMMARY: ${mem.rollingSummary}`,
    "EVIDENCE:",
    evidence || "- (none)",
    "RECENT:",
    recent
  ].join("\n\n");
}

중단 리포트 템플릿(예시)
- 진행 요약: ...
- 마지막 관찰: ...
- 중단 사유: maxToolCalls exceeded
- 다음 후보:
  1) 도구 호출 없이 현재 정보로 초안 작성
  2) 사용자에게 추가 입력 요청
  3) 특정 도구 권한 승인 요청
- 재개 질문: ...

{
  "run_id": "run_20260226_001",
  "step": 12,
  "tool": "search",
  "args_hash": "9f2c...",
  "latency_ms": 842,
  "tokens_in": 1820,
  "tokens_out": 220,
  "cost_estimate_usd": 0.012,
  "stop_reason": "loop_detected"
}