Akshay Parkhi's Weblog

Understanding LLM-Driven Python Execution: Architecture, Terminology, and Use Cases

20th February 2026

LLM-Driven Python Execution: A Systems Engineering Breakdown

This pattern is not just “tool use.” It is a Reasoning → Execution → Observation loop where the LLM can generate Python during runtime and run it inside a sandbox, producing deterministic outputs.

Runtime Execution Agent =
  LLM (plans + decides next step)
+ Python Runtime (executes deterministic compute)
+ Memory Store (state + history + data)
+ Optional Subagents (parallelize tasks)

---

1. The LLM Planner (Probabilistic)

Purpose: Understand the request, decide the steps, and generate code or tool calls.

Input (text, tables, logs)
→ plan steps
→ generate Python OR call tools
→ interpret outputs
→ continue until done

Why Needed: Real tasks are messy: ambiguous inputs, missing fields, varied formats. The LLM provides flexible reasoning, decomposition, and decision-making.

Key Property: This layer is probabilistic (token prediction). It should not be trusted for precise arithmetic or strict rules without verification.

---

2. Python Execution Layer (Deterministic)

Purpose: Run computations deterministically: math, aggregations, rolling windows, scoring formulas, simulations, parsing, transformations.

Python code
→ sandboxed execution
→ structured outputs (JSON / tables / metrics)

Why Needed: Computation must be repeatable and testable. The same inputs should always produce the same outputs.

What This Enables:

• Determinism: identical results for identical inputs
• Auditability: replay exact compute with logs
• Unit Testing: validate scoring and thresholds
• Cost Control: avoid repeated “reasoning” for simple math

---

3. Observation Loop (Reason → Act → Observe)

Purpose: Turn execution results into the next reasoning step. This is the core “agent loop.”

Reason: decide next operation
Act: write Python (or call a tool)
Observe: read output + errors + metrics
Repeat: refine until final answer

Why Needed: Many tasks require multiple iterations: compute something, check constraints, branch, handle errors, retry with adjustments.

---

4. Dynamic Runtime Mode (Experimentation)

Purpose: Enable rapid experimentation by allowing the LLM to write Python during runtime.

LLM generates new code on the fly
→ run in sandbox
→ compare outcomes
→ modify logic
→ iterate quickly

Why Used: In research/prototyping, the steps are not fully known ahead of time. Dynamic code generation accelerates iteration and discovery.

Tradeoff: Higher flexibility, but harder to govern and standardize.

---

5. Tool-Constrained Mode (Production)

Purpose: Restrict execution to predefined Python functions exposed as tools (APIs), instead of arbitrary runtime code.

LLM → tool call (fixed schema)
     → Python function (versioned)
     → deterministic output

Why Used: Production systems need stable behavior, clear contracts, predictable cost, and strong safety boundaries.

What This Enables:

• Governance: only approved functions run
• Reliability: fewer runtime surprises
• Compliance: clear audit trail and versioning
• Scaling: easy to run at high concurrency

---

6. Common Names for This Pattern

Different communities use different labels:

Term	What It Emphasizes
Code Interpreter Pattern	LLM generates code and executes it in a sandbox
Program-Aided Language Models (PAL)	LLM writes programs to solve problems; execution is deterministic
Tool-Augmented Reasoning	LLM uses external tools (including Python runtime)
ReAct + Code Execution	Reason → Act → Observe loop with code as the action
Dynamic Execution Agent	Engineering term for runtime-generated code execution

---

Full Architecture Overview

User Request
  ↓
LLM Planner (probabilistic reasoning)
  ↓
Python Execution Layer (deterministic compute)
  ↓
Outputs / Metrics / Structured Results
  ↓
LLM Planner (interprets + decides next step)
  ↓
FINAL (answer / decision / action)

---

Why This Design Works

This architecture separates the system into two zones:

Zone	Role	Property
LLM	Interpretation, planning, branching, explanation	Flexible (probabilistic)
Python	Computation, aggregation, scoring, validation	Stable (deterministic)

The result is a system that can handle open-ended inputs while producing repeatable, testable outputs.

---

Final Mental Model

Probabilistic Planner (LLM)
+
Deterministic Engine (Python / Tools)
=
Trustworthy Execution Agent

Reasoning decides. Execution enforces.