Inside Agentic Coding

Reproducing Claude Code's core flow in 900 lines

Something You Use Every Day

What actually happens in between?

Goal for Today

Walk through the core flow of an agentic coding tool
and examine a minimal working implementation

Starting from running code, not slides full of abstractions.

Pocket Code

⌨️

Switch to terminal — live run

Have Pocket Code ready with a buggy file

The Agentic Loop

Message Flow

Chatbot vs Agent

Entry — index.ts

• Parse CLI args (--model, --base-url)
• Load POCKET.md as system prompt
• Initialize MCP servers
• Start the REPL, handle slash commands

initReadline();

while (true) {
  const input = await question("> ");
  const trimmed = input.trim();
  if (!trimmed) continue;

  // Slash commands: /model, /clear, /help, /exit
  if (trimmed.startsWith("/")) {
    handleSlashCommand(trimmed, agent, config);
    continue;
  }

  // Regular input → hand off to the Agent
  await agent.run(trimmed);
}
  

Core — agent.ts

The agent loop lives here

async run(userInput: string) {
  this.messages.push({ role: "user", content: userInput });

  while (true) {
    // 1. Call the LLM
    const reply = await chatCompletion(
      this.config, this.messages, this.tools
    );

    // 2. No tool_calls → final answer, done
    if (!reply.tool_calls?.length) {
      printAnswer(reply.content);
      this.messages.push(reply);
      return;
    }

    // 3. Has tool_calls → execute each one
    printThinking(reply.content);  // [thinking]
    this.messages.push(reply);

    for (const tc of reply.tool_calls) {
      const args = JSON.parse(tc.function.arguments);
      printToolCall(name, args);        // [tool]

      if (needsConfirmation.has(name)) {
        if (!await confirm(name, args)) continue;  // [confirm]
      }

      const result = await executeTool(name, args);
      printResult(result);              // [result]
      this.messages.push({
        role: "tool", tool_call_id: tc.id, content: result
      });
    }
    // ↻ Back to while(true) — LLM sees tool results, decides next step
  }
}
  

Why while(true)?

LLM Wrapper — llm.ts

• OpenAI-compatible format — one POST request
• Send messages + tools, receive message
• Retry on 429, 120s timeout
• Switch models by changing the base URL

{
  "model": "deepseek-chat",
  "messages": [
    { "role": "system", "content": "You are a coding assistant..." },
    { "role": "user", "content": "fix bug.py" },
    { "role": "assistant", "tool_calls": [...] },
    { "role": "tool", "content": "def add(a,b): return a-b" }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "read_file",
        "description": "Read file contents (max 2000 lines)",
        "parameters": {
          "type": "object",
          "properties": { "path": { "type": "string" } },
          "required": ["path"]
        }
      }
    }
  ]
}
  

Tool System — tools.ts

// 1. JSON Schema tells the LLM what tools are available
export const toolDefs: ToolDef[] = [
  {
    type: "function",
    function: {
      name: "read_file",
      description: "Read file contents (max 2000 lines)",
      parameters: {
        type: "object",
        properties: { path: { type: "string" } },
        required: ["path"],
      },
    },
  },
  // ... 6 more tools
];

// 2. A switch dispatches execution
export async function executeTool(name, args) {
  switch (name) {
    case "read_file":  return readFileTool(args.path);
    case "write_file": return writeFileTool(args.path, args.content);
    case "run_command": return runCommandTool(args.command);
    // ...
  }
}
  

Output Truncation

Permissions — permissions.ts

export async function confirm(toolName, args) {
  // write_file: demo/index.html (2847 chars)
  // run_command: npm test
  const summary = summarize(toolName, args);
  const answer = await question(`[confirm] ${summary} (y/n) `);
  return answer.trim().toLowerCase() === "y";
}
  

MCP — mcp.ts

Model Context Protocol — connect external tools to the agent

MCP Lifecycle

// pocket.json — declare MCP servers
{
  "mcpServers": {
    "weather": {
      "command": "node",
      "args": ["./my-weather-server.js"]
    }
  }
}
  

Terminal UI — ui.ts

Pocket Code vs Production

Where Are the Gaps?

• Context management — conversation too long? Compression, summarization, sliding window
• Streaming — users don't want to stare at a blank screen for 30 seconds
• Security — y/n isn't enough: sandbox, path restrictions, command allowlists
• Fault tolerance — broke a file? Checkpoints + rollback
• Parallelism — multiple sub-agents reading files and running tasks concurrently

Takeaway

core concepts

In One Line

Agent = LLM + Tools + Loop

This is the minimal form. Production builds a lot more on top.