bquast simple-agent-harness — Summary

Simple Agent Harness by bquast is a minimal autonomous LLM agent with zero framework dependencies: a shell script (agent.sh) that calls Ollama on a cron schedule, a soul file defining identity, a heartbeat prompt sent every 30 minutes, a rewritable memory file, and an append-only log. The agent can execute shell commands (fenced sh blocks) and rewrite its own memory (fenced memory blocks). This is the purest example of Archetype 4 (markdown scaffold + minimal primitives) pushed to its extreme: the "harness" is a 6-file system where the entire runtime is a bash script and the "framework" is three markdown files. It explicitly avoids all AI framework complexity. Differs from seeds: closest to agent-os (markdown scaffold, zero agent primitives) but agent-os generates project memory for Claude Code, while this IS an autonomous agent itself running locally via Ollama. The closest architectural analog is the continuous-ralph execution mode described for some seeds but implemented without any framework — a cron-driven daemon loop.

bquast simple-agent-harness — Overview

Origin

GitHub: https://github.com/bquast/simple-agent-harness
Stars: 0
License: unknown (none declared)
Language: Shell
Last commit: 2026-05-03

Philosophy

From README:

"A minimal autonomous LLM agent. No framework, no dependencies beyond Ollama."

The README is 25 lines. The philosophy is radical minimalism: the agent harness should be readable in 5 minutes and require no installation beyond Ollama and cron.

Files

Key Design Decisions

1. No dependencies: only Ollama (local LLM) and standard shell tools.
2. Self-modifying memory: the agent can rewrite memory.md via ```memory fenced blocks.
3. Shell execution: the agent can run shell commands via ```sh fenced blocks.
4. Log as audit trail: every response and action is appended to log.txt.
5. Heartbeat as scheduler: cron + heartbeat.md replace a complex scheduler.

bquast simple-agent-harness — Architecture

Distribution

Manual: clone the repo and install cron job.

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh
# Pull a model
ollama pull gemma4:e2b
# Make executable
chmod +x agent.sh
# Install cron job (adjust path first)
crontab cron.txt

File Tree

simple-agent-harness/
├── agent.sh          # Runtime loop (shell script)
├── cron.txt          # Cron schedule
├── heartbeat.md      # Prompt sent every 30 minutes
├── memory.md         # Persistent memory (LLM-rewritable)
├── soul.md           # Identity + behavioral rules
└── log.txt           # Append-only audit log

Required Runtime

• Ollama (local LLM)
• bash + cron
• No Node.js, no Python, no framework

Agent Action Protocol

The LLM can take two actions by wrapping content in fenced code blocks:

1. ```sh — shell command executed immediately, output logged
2. ```memory — replaces the contents of memory.md

Everything else is logged to log.txt and ignored.

Target

Local machine. No cloud dependencies. No API keys.

bquast simple-agent-harness — Components

Scripts (1)

Templates/Markdown (3 functional files)

Cron (1)

Log (1)

No commands, no skills, no hooks, no MCP servers, no agents directory.

bquast simple-agent-harness — Uniqueness

differs_from_seeds

Closest to agent-os (Archetype 4: markdown scaffold, minimal primitives) but inverted: agent-os provides context engineering for human-driven Claude Code sessions, while this IS the autonomous agent running without any AI coding tool. The cron-driven continuous loop resembles what some seeds describe as "continuous-ralph" execution mode, but implemented with nothing more than bash and cron. No seed achieves this level of minimalism — agent-os ships 5 commands, this ships 0.

Positioning

This is the floor of harness complexity: 6 files, 1 bash script, cron for scheduling, Ollama for local inference. It makes explicit that the minimal viable agent harness is: identity (soul.md) + memory (memory.md) + task (heartbeat.md) + runtime (agent.sh). Everything else in other frameworks is additional structure on top of these primitives.

Observable Failure Modes

1. No error handling: if the shell command fails, the only evidence is log.txt — there is no retry or error recovery.
2. Memory explosion: as memory.md grows, context window fills; the agent must proactively compact its own memory.
3. No human override: fully autonomous with no interrupt mechanism.
4. Ollama-only: cannot use cloud models.
5. Zero stars: not adopted; purely illustrative.