mini-coding-agent — Summary

mini-coding-agent is a minimal, zero-dependency Python coding agent by Sebastian Raschka (rasbt) designed explicitly as an educational reference implementation for understanding the six core components of coding agents. The entire agent lives in a single 400-line Python file (mini_coding_agent.py) with no external Python runtime dependencies beyond the standard library — it talks to Ollama's /api/generate endpoint directly. The six components are: (1) live repo context collection, (2) stable prompt shape with cache reuse, (3) structured tools with validation and approval gates, (4) context reduction and output management, (5) transcript/memory persistence with session resumption, and (6) delegation to bounded subagents. The agent ships a mini-coding-agent CLI entry point (via uv run), an interactive REPL with slash commands, approval modes (ask/auto/never), and session persistence under .mini-coding-agent/sessions/. The companion Substack tutorial "Components of a Coding Agent" is the primary documentation.

differs_from_seeds: mini-coding-agent is closest to agent-os in its minimalism (zero dependencies, markdown-first documentation) but is a fully runnable Python agent rather than a bash install script. Unlike every seed that targets Claude Code or another commercial AI tool, mini-coding-agent targets Ollama local models exclusively. The zero-dependency design (standard library only), single-file implementation, and explicit educational framing make it unique in the corpus — it is the only framework designed to be read cover-to-cover as a learning artifact, not just used as a tool.

mini-coding-agent — Overview

Origin

Authored by Sebastian Raschka (rasbt), a machine learning researcher and educator known for his book "Build a Large Language Model (From Scratch)." The companion tutorial, published in his Substack newsletter "Ahead of AI," explains the six components in depth.

Philosophy

The project's explicit purpose is educational — every design decision prioritizes readability over features:

"A minimal local agent loop with: workspace snapshot collection, stable prompt plus turn state, structured tools, approval handling for risky tools, transcript and memory persistence, bounded delegation."

From the README:

"This coding harness is organized around six practical building blocks"

The six components are labeled explicitly in the source code comments:

##############################
#### Six Agent Components ####
##############################
# 1) Live Repo Context -> WorkspaceContext
# 2) Prompt Shape And Cache Reuse -> build_prefix, memory_text, prompt
# 3) Structured Tools, Validation, And Permissions -> build_tools, run_tool, validate_tool, approve, parse, path, tool_*
# 4) Context Reduction And Output Management -> clip, history_text
# 5) Transcripts, Memory, And Resumption -> SessionStore, record, note_tool, ask, reset
# 6) Delegation And Bounded Subagents -> tool_delegate

Target Audience

The README is written for someone who wants to understand coding agent internals — "what makes a coding agent work" — not for production deployment.

Model Backend

Ollama only (/api/generate endpoint). Default model: qwen3.5:4b. Larger models supported but not required.

Design Constraint: Zero Python Dependencies

Beyond the Python standard library. No LangChain, no anthropic SDK, no requests. Just urllib.request and subprocess.

mini-coding-agent — Architecture

Distribution

• Type: Single Python file (mini_coding_agent.py) + pyproject.toml for CLI entry point
• License: Apache-2.0
• Runtime: Python 3.10+
• Dependencies: None (Python standard library only)
• Model backend: Ollama (local, http://localhost:11434/api/generate)

File Structure

mini-coding-agent/
├── mini_coding_agent.py  # Entire agent in one file
├── pyproject.toml        # CLI entry point (mini-coding-agent)
├── README.md
├── EXAMPLE.md            # Concrete usage walkthrough
└── tests/                # Test suite

Six Components (labeled in source)

Approval Modes

• --approval ask (default): prompts before risky tool calls (bash, file writes)
• --approval auto: all risky actions allowed automatically
• --approval never: risky actions denied (read-only mode)

Session Storage

.mini-coding-agent/sessions/ — JSONL files per session.

Config Files

• AGENTS.md, README.md, pyproject.toml, package.json — read at startup as workspace context
• No configuration file for the agent itself

mini-coding-agent — Components

Tools (6)

Risky tools require user approval when --approval ask mode is active.

Slash Commands (REPL)

WorkspaceContext (Component 1)

Collects at startup:

• cwd — current working directory
• repo_root — git repository root
• branch — current branch
• default_branch — default branch
• status — git status output
• recent_commits — recent commit messages
• project_docs — content of AGENTS.md, README.md, pyproject.toml, package.json

SessionStore (Component 5)

Maintains:

• Full durable transcript (JSONL)
• Distilled working memory (current task, tracked files, notes)

Working memory is separate from the full transcript — it's the smaller, curated context the agent uses actively.

Subagent (Component 6: tool_delegate)

Bounded delegation:

• Inherits enough context to complete the subtask
• Limited scope — cannot recursively delegate (bounded delegation)
• Returns a summary result to the parent agent

Ignored Paths

IGNORED_PATH_NAMES = {".git", ".mini-coding-agent", "__pycache__", ".pytest_cache", ".ruff_cache", ".venv", "venv"}

mini-coding-agent — Uniqueness

differs_from_seeds

mini-coding-agent has no close seed equivalent. Its closest seed in spirit is agent-os (minimalist, educational, markdown-first) but agent-os is a bash install script that sets up template files, while mini-coding-agent is a fully runnable Python agent. Unlike every other seed and framework in this batch, mini-coding-agent is explicitly educational — the source code has component labels, the README explains the six components, and the companion Substack article provides the full tutorial. The Ollama-only model backend makes it the only framework in the corpus that requires no API keys and no cloud service, running entirely on a local CPU/GPU. The single-file zero-dependency design is maximally portable: python mini_coding_agent.py on any Python 3.10+ machine with Ollama installed. Unlike superpowers (TDD-enforced, spec-first), mini-coding-agent imposes zero workflow requirements — it's a blank canvas that demonstrates the mechanics.

Positioning

mini-coding-agent is the "learn by reading the code" entry point in the coding agent ecosystem. Sebastian Raschka's audience (ML researchers, students, educators) wants to understand how agents work, not just use one. The companion Substack tutorial is the primary product; the code is the illustration.

Observable Failure Modes

• Ollama-only: Not usable without Ollama. Cloud/API models not supported.
• No MCP: No extensibility via MCP servers.
• Single-user REPL: No background mode, no scheduling, no IM integration.
• Last commit April 2026: Development appears to have slowed after tutorial publication.
• No TDD: No test-first enforcement — purely reactive to user requests.
• Context limits conservative: MAX_HISTORY=12000 chars is modest; complex tasks may exceed this frequently.
• Bounded delegation only: Subagents cannot recurse, limiting complex task decomposition.