Going Agentic:
From Tokens to
Autonomous Action

If you've attended my workshops, you've heard me say this: "A language model on its own is stateless, memoryless, and passive." It waits. It responds. It forgets. So how do we get from that — a next-token predictor — to an autonomous agent that can book your flights, write code, run tests, and fix its own bugs?

That's what going agentic means. And it builds directly on transformer fundamentals you already know. Let's go layer by layer.

What the transformer is actually doing

Before we build an agent, let's re-anchor on the mechanism. A transformer takes a sequence of tokens, processes them through stacked self-attention + feed-forward layers, and outputs a probability distribution over the vocabulary. That's it.

The critical insight for agentic AI: the output doesn't have to be prose. It can be structured JSON. A function call. A decision. This is the bridge from "chatbot" to "agent."

The ReAct loop: Reason → Act → Observe

A single forward pass gives you one response. An agent chains many. The ReAct pattern (Yao et al., 2022) is the most common architecture: the model alternates between reasoning in natural language and executing tool calls, with each observation fed back as context for the next step.

This works because of something fundamental about transformer attention: the entire history is in the context window. Every prior reasoning step and observation is attended to at every layer. The model doesn't just see the last message — it attends across the full trajectory.

Here's the transformer connection that often gets missed: every observation from a tool becomes part of the key-value (KV) cache. When the model "thinks" in the next step, self-attention queries span the entire trajectory. The model isn't summarizing what happened — it's attending to it directly. This is why long context windows matter enormously for agentic reliability.

Anatomy of a production agent

A well-built agent has five distinct concerns. Understanding which layer handles what will save you days of debugging.

How attention makes agents work

Let's be precise about the transformer internals here, because this is what I always cover in workshops and what most blog posts skip.

In a standard transformer, each token's representation is computed as a weighted sum of all other tokens — the attention weights. During an agentic loop, this means the model's "reasoning" at step N is informed by everything: the original task, every prior think-step, every tool call, every observation. The KV cache stores the key and value projections for all prior tokens, so incremental generation is efficient — you don't recompute the whole context on every new token.

Multi-agent systems: when one loop isn't enough

Single agents hit limits: context overflow, task complexity, and parallelism. The solution is multi-agent orchestration — multiple transformer instances, each running its own ReAct loop, coordinated by an orchestrator.

What actually goes wrong (and why)

Building your first agent in ~50 lines

Here's the minimal pattern. Python pseudocode, but the logic applies everywhere:

# 1. Define your tools (just Python functions + docstrings)
def search_web(query: str) -> str: ...
def run_python(code: str) -> str: ...

# 2. Build a context window
messages = [
  {"role": "system", "content": SYSTEM_PROMPT + tool_schemas},
  {"role": "user",   "content": task}
]

# 3. ReAct loop
for step in range(MAX_STEPS):
  response = llm.generate(messages, temperature=0.2)

  if response.is_final_answer:
    return response.text

  # Parse the tool call from JSON output
  tool_call = parse_json(response.text)
  result = dispatch(tool_call)  # routes to Python function

  # Append both the model's output AND the result to context
  messages.append({"role": "assistant", "content": response.text})
  messages.append({"role": "tool",      "content": str(result)})

# If we hit MAX_STEPS without a final answer, surface that to the user
raise AgentTimeoutError("Max steps reached")
    

That's the core. Every agentic framework — LangChain, LlamaIndex, CrewAI, the Anthropic Claude SDK — is this loop with more error handling, observability, and tool abstractions around it.