Adam Sioud

Building an LLM Agent in Python

So let's build our agent. I'm not gonna use a framework, everything is just Python. As with many others I like going with direct LLM API calls. In terminal2F we're using Mistral models, you're free to pick any.

If you were going to use any type of framework, do Temporal, PydanticAI, OpenAI SDK over... lang. You may ask why not just use CrewAI, Autogen, Langchain, Pydantic AI.. on and on. But we're not here to discuss that.

Some good introductory sources to read:

• Building Effective Agents (Anthropic)
• AI Agent from Scratch in Python (Leonie Monigatti)
• Function Calling (Mistral docs)

Background / Motivating Work

There's some interesting stuff that shaped how I think about this:

• State Machines for Agents
• Are Agents Just Automata? On the Formal Equivalence Between Agentic AI and the Chomsky Hierarchy
• P2Engine: A Multi-Agent System Framework

The thesis from that paper: the memory architecture of an AI agent is the definitive feature determining its computational power, and it maps directly to classes of automaton:

• Simple reflex agents → Finite Automata
• Hierarchical task-decomposition agents → Pushdown Automata
• Agents with readable/writable memory for reflection → Turing Machines

The Debate

If the agent owns agent.messages, then the agent already is your memory system. The runner is just a loop that calls the model. So calling something "FSM runner" or "PDA runner" would mostly be a label, because the real memory is still the full chat history you keep sending.

The paper is pretty explicit that memory architecture is the thing that determines the agent's computation class:

• An FSM has "memory" only as its current state. No stack, no history buffer.
• A PDA is an FSM plus a stack.
• A TM is an FSM plus read and write memory you can revisit and modify.

So terminal2F makes a split:

• Agent = model caller (brain)
• Runner = memory + control policy (the automaton)

The Loop Runner

I follow that tutorial closely: I have an Agent class with an LLM client and a system prompt, I keep conversation memory, I expose tools with schemas plus a name-to-function map, and I run an agent loop that executes tool calls until a final answer.

The main difference is that my conversation memory and loop live in a separate runner (runners/loop.py) instead of inside the Agent class. This is the basic agentic loop: append user message, call agent.step(), parse tool calls, execute tools, append results, repeat until done.

I use the Mistral API. We use that and the help of their docs to build our agent. The function calling doc is important. You're free to adopt whatever model family you want.

What's Next: FSM, PDA, TM Runners

The loop runner keeps full chat history as memory. But if we actually want to test the automaton equivalences from the paper, we need runners with different memory architectures:

• FSM Runner (runners/fsm.py) : Memory is only the current state. No history buffer. Explicit state transitions.
• PDA Runner (runners/pda.py) : FSM plus a stack. Good for hierarchical task decomposition, can push/pop context.
• TM Runner (runners/tm.py) : FSM plus read/write memory you can revisit. Persistent, addressable memory the agent can reflect on.

These are stubbed out in the codebase. The goal is to run the same task through different runners and compare how they behave.

The Basic Structure

The Agent class has:

• An LLM client (Mistral)
• A system prompt
• Tools with schemas plus a name-to-function map

Tools: Capability vs Permission

Tools are capability on the agent, permission on the runner. The agent can be initialized with tools=tools (everything installed), but the runner decides what the model can actually see and execute for that run.

The Step Function

agent.step() is the atomic unit. It takes the current messages, makes one API call, and returns whatever the model says. It doesn't loop. It doesn't execute tools. It just calls the model once and hands back the response. The runner decides what to do with that response: execute tools, append to history, loop again, or stop.