2nd/10_Wiki/Topic_Programming/Coding/AI_Agentic_Patterns.md

id, title, category, status, source_trust_level, verification_status, created_at, updated_at, tags, tech_stack, applied_in, aliases

id	title	category	status	source_trust_level	verification_status	created_at	updated_at	tags	tech_stack	applied_in	aliases
ai-agentic-patterns	Agentic Patterns — Plan / Reflect / Multi-agent	Coding	draft	B	conceptual	2026-05-09	2026-05-09	ai agent agentic vibe-coding	language applicable_to TS / LLM Backend		agent ReAct Reflexion multi-agent planner supervisor swarm

Agentic Patterns

Tool 호출 + 추론을 묶은 자율 시스템. Plan → Execute → Reflect loop. Multi-agent (각 역할별) 가 복잡 작업에 강력. 단 비용 / 신뢰성 / 안전성 = 새 도전.

📖 핵심 개념

• ReAct: Reasoning + Acting 인터리브 (위 function calling 의 기본).
• Plan-and-Execute: 먼저 계획 세움 → 실행.
• Reflection: 결과 자체 평가 → 재시도.
• Multi-agent: 역할별 (planner / coder / reviewer).

💻 코드 패턴

Plan-and-Execute

async function planAndExecute(task: string) {
  // 1. Plan
  const plan = await llm.complete({
    system: 'Decompose into 3-7 numbered steps. Output JSON: {"steps":[...]}.',
    user: task,
    response_format: { type: 'json_object' },
  });
  const steps = JSON.parse(plan).steps as string[];

  // 2. Execute
  const results: string[] = [];
  for (const step of steps) {
    const r = await agentLoop(step + `\n\nContext from previous: ${results.join('\n')}`);
    results.push(r);
  }

  // 3. Synthesize
  return llm.complete({
    system: 'Synthesize the results.',
    user: `Task: ${task}\n\nResults:\n${results.map((r, i) => `Step ${i + 1}: ${r}`).join('\n')}`,
  });
}

Reflection (자체 평가)

async function reflectiveAgent(task: string, maxAttempts = 3) {
  let result: string | null = null;
  for (let i = 0; i < maxAttempts; i++) {
    result = await agentLoop(task + (i > 0 ? `\n\nPrevious attempt critique: ${critique}` : ''));

    const critique = await llm.complete({
      system: 'Evaluate the answer. If perfect, output "OK". Otherwise, point out specific issues.',
      user: `Task: ${task}\nAnswer: ${result}`,
    });

    if (critique.startsWith('OK')) return result;
  }
  return result;
}

Multi-agent (Planner + Worker)

async function multiAgent(task: string) {
  const planner = createAgent({
    system: 'You decompose tasks. Output JSON tasks for workers.',
    tools: [],
  });

  const coder = createAgent({
    system: 'You write code.',
    tools: [readFile, writeFile, runTest],
  });

  const reviewer = createAgent({
    system: 'You review code for bugs and style.',
    tools: [readFile],
  });

  const tasks = JSON.parse(await planner.run(task));
  for (const t of tasks) {
    const code = await coder.run(t);
    const review = await reviewer.run(code);
    if (review.includes('LGTM')) continue;
    await coder.run(`Fix issues: ${review}`); // refine
  }
}

Supervisor / Worker (LangGraph 스타일)

type State = { task: string; messages: Message[]; nextAgent: 'coder' | 'reviewer' | 'done' };

async function supervisor(state: State): Promise<State> {
  const decision = await llm.complete({
    system: 'Decide next: coder, reviewer, or done.',
    user: JSON.stringify(state),
  });
  return { ...state, nextAgent: parseDecision(decision) };
}

async function graph(initial: State): Promise<State> {
  let state = initial;
  while (state.nextAgent !== 'done') {
    state = await supervisor(state);
    if (state.nextAgent === 'coder') state = await coderNode(state);
    if (state.nextAgent === 'reviewer') state = await reviewerNode(state);
  }
  return state;
}

Memory (단순)

class AgentMemory {
  private notes: { ts: number; content: string }[] = [];
  add(c: string) { this.notes.push({ ts: Date.now(), content: c }); }
  recent(n = 10) { return this.notes.slice(-n).map(x => x.content).join('\n'); }
}

복잡 = vector DB + retrieval.

안전 가드 (guardrails)

async function safeExecute(plan: Step) {
  // High-risk: 사용자 confirm
  if (plan.action === 'delete_file' || plan.action === 'send_email') {
    const ok = await askUser(`Confirm: ${plan.summary}`);
    if (!ok) return { skipped: true };
  }
  return await execute(plan);
}

Cost / iteration cap

class Budget {
  constructor(private maxTokens: number, private maxIters: number) {}
  used = { tokens: 0, iters: 0 };
  check() {
    if (this.used.tokens > this.maxTokens) throw new Error('budget exceeded');
    if (this.used.iters > this.maxIters) throw new Error('iter limit');
  }
}

🤔 의사결정 기준

작업	패턴
1-2 step	단순 tool loop
멀티 step + 반복	Plan-and-Execute
정확성 critical	Reflection
복잡 도메인 (코딩, 조사)	Multi-agent
Long-running (시간 단위)	Temporal / Durable agents
사용자 in-the-loop	중간 confirm

❌ 안티패턴

• 무한 loop 가능성: max iters / max tokens / max time.
• High-stakes action 자동: 결제 / 삭제 / 메일은 confirm.
• Memory 없이 long task: context 잃음.
• Agent 가 외부 prompt injection 따름: system 권위 명시 + sanitize.
• 1 LLM 모든 역할: 너무 큰 prompt + 혼란. 분리.
• Reflection 무한: 같은 결과 반복 — limit.
• Cost 추적 없음: 1 task 가 $10 — 알아채기 늦음.

🤖 LLM 활용 힌트

• Plan + tool loop + reflection + budget 4종.
• Multi-agent = 역할별 분리.
• Guardrail (HITL) 항상 있어야.

🔗 관련 문서

• AI_Function_Calling_Deep
• AI_Prompt_Engineering_Patterns
• AI_LLM_Eval_Patterns