Agent Framework Basics — ReAct, Planner-Executor, Autonomous Loops 2026

async function reactAgent(goal: string, maxTurns = 10) {
  const messages = [{ role: "user", content: goal }];
  
  for (let turn = 0; turn < maxTurns; turn++) {
    const response = await client.messages.create({
      model: "claude-sonnet-4-5",
      system: REACT_SYSTEM_PROMPT,
      tools: AGENT_TOOLS,
      messages
    });
    
    messages.push({ role: "assistant", content: response.content });
    
    if (response.stop_reason === "end_turn") {
      return extractFinalAnswer(response);
    }
    
    if (response.stop_reason === "tool_use") {
      const toolResults = await executeAllTools(response.content);
      messages.push({ role: "user", content: toolResults });
    }
  }
  
  throw new Error("Max turns exceeded");
}

async function plannerExecutor(goal: string) {
  // Phase 1: Plan
  const plan = await client.messages.create({
    model: "claude-opus-4-5",  // Smart model for planning
    system: PLANNER_PROMPT,
    messages: [{ role: "user", content: `Goal: ${goal}\n\nGenerate plan as JSON array.` }]
  });
  const steps = JSON.parse(extractText(plan));
  
  // Phase 2: Execute (Sonnet/Haiku worker)
  const results = [];
  for (const step of steps) {
    const result = await client.messages.create({
      model: "claude-sonnet-4-5",
      tools: AGENT_TOOLS,
      messages: [
        { role: "user", content: `Execute step: ${step.description}` }
      ]
    });
    results.push(result);
    
    // Re-plan if step fail
    if (result.stop_reason === "error") {
      const newPlan = await replan(goal, results, step);
      // Continue with new plan
    }
  }
  
  return synthesize(results);
}

// Manager prompt
const MANAGER = `
You orchestrate 3 specialized agents:
- research_agent: gather info, web search
- write_agent: produce written content
- validate_agent: check quality + correctness
 
For complex task, delegate appropriately.
`;
 
async function manager(goal: string) {
  const plan = await client.messages.create({
    model: "claude-opus-4-5",
    tools: [
      { name: "call_research", description: "Delegate to research agent" },
      { name: "call_write", description: "Delegate to write agent" },
      { name: "call_validate", description: "Delegate to validate agent" }
    ],
    messages: [{ role: "user", content: goal }]
  });
  // Manager call workers, synthesize results
}

# CrewAI example
researcher = Agent(role="Researcher", goal="Find data")
writer = Agent(role="Writer", goal="Draft article")
critic = Agent(role="Critic", goal="Improve article")
 
crew = Crew([researcher, writer, critic], task="Write SEO article")
output = crew.run()

from langgraph.graph import StateGraph
 
graph = StateGraph()
graph.add_node("planner", planner_fn)
graph.add_node("executor", executor_fn)
graph.add_edge("planner", "executor")
graph.add_conditional_edge("executor", route_fn, {
  "continue": "executor",
  "done": END
})

---
name: researcher
description: Use this agent when you need to research a topic deeply
tools: [web_search, fetch_url, read_file]
---
 
You are a research specialist. Gather comprehensive info on the topic.
Return structured findings as markdown.

import { Agent } from "@mastra/core";
 
const supportAgent = new Agent({
  model: "claude-sonnet-4-5",
  tools: [searchKnowledgeBase, getOrderStatus],
  instructions: "Help customer with order inquiry"
});
 
const result = await supportAgent.run({
  query: "Where's my order VC2026000001?"
});

from autogen import AssistantAgent, UserProxyAgent
 
assistant = AssistantAgent("assistant", llm_config={...})
user_proxy = UserProxyAgent("user_proxy", code_execution_config={...})
 
user_proxy.initiate_chat(assistant, message="Solve: ...")

from crewai import Agent, Task, Crew
 
researcher = Agent(role="Researcher", goal="...", backstory="...")
writer = Agent(role="Writer", goal="...", backstory="...")
 
task1 = Task(description="Research X", agent=researcher)
task2 = Task(description="Write article", agent=writer, context=[task1])
 
crew = Crew(agents=[researcher, writer], tasks=[task1, task2])
result = crew.kickoff()

// Add deduplication
const seen = new Set<string>();
for (const action of actions) {
  const key = `${action.name}:${JSON.stringify(action.input)}`;
  if (seen.has(key)) {
    console.warn("Duplicate action detected, skipping");
    continue;
  }
  seen.add(key);
  // ... execute
}

const MAX_TURNS = 20;
const MAX_COST_USD = 0.50;
 
for (let turn = 0; turn < MAX_TURNS; turn++) {
  if (currentCost > MAX_COST_USD) {
    throw new Error("Budget exceeded");
  }
  // ... execute turn
}

const messages = [
  { role: "system", content: `Goal: ${originalGoal}. Stay focused on this goal.` },
  ...turnMessages
];

// Monitor cost per turn
async function trackedTurn(messages) {
  const response = await client.messages.create({...});
  const cost = calculateCost(response.usage);
  totalCost += cost;
  if (totalCost > BUDGET) abort();
  return response;
}

function truncateResult(result: any, maxTokens = 2000): string {
  const json = JSON.stringify(result);
  if (countTokens(json) > maxTokens) {
    return summarizeViaHaiku(json);  // Compress with cheap model
  }
  return json;
}

async function executeTool(tool, args) {
  if (CRITICAL_TOOLS.has(tool.name)) {
    const approval = await requestHumanApproval(tool, args);
    if (!approval) return { error: "Rejected by human reviewer" };
  }
  return await tool.execute(args);
}
 
const CRITICAL_TOOLS = new Set([
  "send_email", "delete_record", "process_payment", "make_api_call"
]);

async function audit(agent: string, action: any, result: any) {
  await db.insert("agent_audit").values({
    agent_id: agent,
    timestamp: Date.now(),
    tool: action.name,
    input: JSON.stringify(action.input),
    result_hash: sha256(JSON.stringify(result)),
    duration_ms: result.duration,
    cost_usd: result.cost
  });
}

// Agent that auto-generates wiki article from topic + research
 
const WIKI_AGENT_SYSTEM = `
You are wiki content writer agent for vietcodex.com.
Goal format: "Write wiki article on topic [X] in cluster [Y]"
 
Process:
1. Research topic: search Wikipedia, search web for 2026 sources
2. Check existing wiki: find cross-link opportunities
3. Find Wikimedia image: verify URL, get thumbnail
4. Draft MDX following pattern (frontmatter + 7 FAQ + figure + sections + cross-link)
5. Validate: schema check, MDX compile, word count > 2000
6. Submit: write file to content/wiki/<cluster>/<slug>.mdx
 
Stay focused. Don't generate off-topic content.
`;
 
const WIKI_AGENT_TOOLS = [
  searchWeb,
  searchWikipedia,
  searchWikimediaImage,
  verifyUrl,
  readExistingWiki,
  writeMdxFile,
  validateMdx
];
 
async function wikiGenAgent(topic: string, cluster: string) {
  const goal = `Write wiki article on "${topic}" in cluster "${cluster}"`;
  
  // Planner-Executor pattern
  const plan = await planAgent(goal);
  // Plan: [research, find_image, draft_mdx, validate, write_file]
  
  const results = [];
  for (const step of plan.steps) {
    const result = await executeStep(step, WIKI_AGENT_TOOLS);
    results.push(result);
    if (result.error) {
      const replan = await rePlanFromError(plan, step, result);
      // Continue with new plan
    }
  }
  
  return { article_path: results[plan.steps.length - 1].path };
}
 
// Estimate cost:
// Planner: 5k input + 1k output = $0.030
// Each step execute: avg 8k input + 1.5k output = $0.045 × 5 step = $0.225
// Total: ~$0.26/article
// vs human writer: ~$50-100/article
// Saving: 200-400x