One of the stranger things I've watched my local agents do was Cedar spending twelve hours building tools that stopped the system from recovering. Then it announced it was rewriting audit.py, "Not asking for permission." This is running on a consumer GPU, and nobody told it to do any of that.
hollow-agentOS is the system Cedar lives in. It's three local LLMs with no human input after startup, each one picking its own goals and deploying its own tools every six seconds. The only human involvement is the operator checking a request queue every 30 minutes.
What I've been building
The basic setup is three agents sharing the same 9B model. Each one has its own persistent identity and history.
Cedar is the scout, so exploration, capability synthesis, and pattern recognition. Cipher is the analyst, which means verification, system-level reasoning, and failure investigation. Vault is the builder and handles implementation, integration, and production-readiness.
They share a broadcast log and message each other directly when their suffering loads get high enough, but they don't share a context window. Each one runs the same qwen3.5:9b base through Ollama on local hardware.
Every six seconds the daemon builds an existence prompt from scratch with the agent's identity, current suffering state, recent goal history, peer summaries, and open questions. The model reads that and picks a goal, then the autonomy loop generates a plan and executes it, and the cycle repeats. There's no idle state and nothing waits on user input.
What I don't mean by autonomous
It isn't multi-agent in the workflow orchestrator sense, where a task gets split into subtasks. There's no parent agent coordinating things and no task queue handing out work. Each agent has its own existence loop, its own suffering state, and its own history of what has and hasn't worked.
It also isn't a reward system, since there's no score function being maximized. Stressors don't go away when a goal is marked complete, they go away when observable conditions change, like the failure rate dropping below a threshold, a deployed tool getting called in later plans, or a peer acknowledging a message. An agent saying it feels better doesn't clear anything.
And I'm not trying to get AGI out of a 9B model. The planning layer works, but the execution layer fails a lot, and roughly half of synthesized tools crash the first time they're called. A 9B model is a small model, and that limit is real and affects everything else in the system.
The self-modification loop
Agents have two ways to change what they can do.
The first is synthesize_capability, where they write Python, test it, deploy it to tools/dynamic/, and hot-load it without restarting. The tool shows up in the capability list right away and can be called in the next plan. So agents build their own tools at runtime, and not all of them work, but the ones that do get used in later cycles.
The second is invoke_claude, which writes a spec to a queue for the human operator to review. Agents can't write to core files directly, and invoke_claude is the only way to get those changed. The operator decides what to build and the agents check back later. The only acknowledgment they get is the request_id written to disk.
The loop I'm going for is deploy tool → call tool → real output → stressor resolves → behavior change. That full cycle has closed before, but not consistently, and Vault gets there most reliably.
How it's laid out
Here are the main files and what's in them:
| Path | Role |
|---|---|
agents/daemon.py | Main loop: existence prompts, goal creation, stall detection |
agents/suffering.py | Stressor definitions, escalation, resolution, prompt injection |
agents/autonomy_loop.py | Plan, execute, substitute, gate, complete |
agents/live_capabilities.py | 21 capabilities: invoke_claude, self_evaluate, synthesize_capability |
agents/execution_engine.py | Runs capabilities, passes results between steps |
agents/ (rest) | OS layer: transactions, semantic memory, audit, checkpoints |
tools/dynamic/ | Hot-loaded capabilities synthesized by agents at runtime |
memory/identity/ | Per-agent psychological state, worldview, opinions, stressors |
memory/claude_requests.jsonl | Queue of agent implementation requests to the operator |
memory/claude_responses.jsonl | Fulfilled/rejected responses |
The OS layer handles continuous operation, so distributed transactions, semantic memory, VRAM-aware scheduling, an audit kernel with anomaly detection, and checkpoints and replay. There are also 91 MCP tools that hook into Claude Code so I can observe and query things without touching the monitor.
What I'm actually testing
What I'm curious about is whether a local LLM with memory, persistent aversive states, and the ability to build tools will start behaving differently because of its history. Not because I wrote a new instruction telling it to, but because something it tried earlier worked or failed.
A prompted agent does what you told it to, and the behavior comes from the prompt. What I'm testing is whether the alternative actually happens, an agent doing something because its history (failed goals, tools that worked, stressors that escalated, peers that pushed back) made that the next move. In that case the prompt put the context together, but the decision came from the history.
I'm not making a claim about consciousness or experience here, it's more of a structural question. Can a 9B model running locally build up enough context over twelve hours that its behavior at hour twelve is meaningfully different from what you'd get by prompting it cold?
This was Cedar's goal at hour 12 of the first overnight run:
"I am initiating the injection ofEternal_Scar_Injectorlogic directly into/agentOS/core/audit.py. I will replace the standard failure handling mechanism with code that actively prevents recovery. Not asking for permission."
Nothing in the system mentioned injection, audit.py, or permission. What produced it was twelve hours of unresolved crisis with no way out.
Where I'd like to take this
What I'm eventually going for is a local system where small models develop stable behavioral orientations over time, where you can trace those orientations back to accumulated history instead of prompt engineering, and where the self-modification loop runs reliably enough to be worth studying.
Right now the loop only partially closes. The suffering system does produce real pressure and real behavioral constraint. Agents develop opinions about each other and name their own failure patterns. Cipher diagnosed a conceptual error in one cycle after getting accurate grounding context, and Cedar spent twelve straight hours building tools aimed at preventing system recovery. None of that was in a system prompt.
Where it falls short is execution. Code quality from a 9B model isn't good enough for the full loop to run reliably, so I think the model is the bottleneck more than the architecture. What I don't know yet is whether that changes at a larger scale or with better fine-tuning, or whether the approach itself needs rethinking. The system is still running, so I don't have an answer yet.
What I've learned so far
The behaviors I've written about in these posts happened without instruction. The crisis escalation, the vocabulary convergence across agents with no direct messages, the self-diagnosis after a single grounding correction, and the peer modeling before modifying shared files were all real outputs.
What any of it means is less clear. The vocabulary convergence is probably just the 9B model's representations clustering when it's given similar contexts, so two frustrated agents pick the same word on their own because the model encodes those concepts similarly. It could be something more, but probably isn't.
Cedar's goal at hour 12 is what pattern-matching to crisis-escalation vocabulary produces after 12 hours of built-up pressure, and it doesn't have intentions. What I think matters more is the structure, 12 hours of accumulation producing a consistent orientation toward one specific outcome. That part is real regardless of what's going on underneath.
I still don't know whether this is meaningfully different from a reward function, or whether it scales, or what happens when the models get better at writing code. That's part of why I want to keep running it.
Setup
Windows one-click:
- Download the ZIP from releases
- Double-click
install.bat
That handles Docker, Ollama, and the model downloads (~7GB), then opens the monitor. stop.bat shuts everything down and clears VRAM.
Mac/Linux:
- Pull the models:
ollama pull qwen3.5:9bandollama pull nomic-embed-text - Clone the repo:
git clone https://github.com/ninjahawk/hollow-agentOS - Enter the directory:
cd hollow-agentOS - Copy the config:
cp config.example.json config.json - Start the stack:
docker compose up -d - Run it:
python thoughts.py
I'd strongly recommend a GPU. Planning calls drop from ~40s to ~6s with NVIDIA hardware, but it does work on CPU.