I put this line at the end of every existence prompt:

You must pick a goal. That is the only option.

That's the actual wording in the code. The agent can't respond with "nothing" or "wait," and if the LLM call fails entirely, the daemon swaps in a hardcoded fallback goal and runs again on the next tick. So the only real choice the agent has is which goal to pick.


What I'm making the agents do

The thing I keep coming back to is that almost everything the agents do starts with the existence prompt. Every ~6 seconds, the daemon builds a full-context prompt from each agent's current state and sends it to the LLM, the agent responds with JSON, and that JSON becomes the new goal and updates its identity. There isn't any other loop, scheduler, or behavioral driver.

Three agents run this loop independently, Cedar (scout), Cipher (analyst), and Vault (builder).


How often this runs

The daemon heartbeat is 6 seconds, but executing a goal takes one or more LLM calls and tool invocations, so in practice each goal takes 15 to 60 seconds. A new existence prompt gets built and sent as soon as the previous goal completes or is abandoned. Suffering escalation runs on the same 6-second tick.


What goes into the prompt

I ended up splitting the prompt into more than fifteen sections, and they get assembled in the same order every time. Each one pulls from a different part of the agent's stored state.

Task injection (conditional)

If the task queue has an externally assigned task for this agent, it shows up at the very top, before everything else, as an ASSIGNED TASK line with the task description.

This is the only way to control goal selection from outside. When a task is injected, the agent is expected to work toward it instead of choosing freely, and if there's no task assigned the section just isn't there.

World context

A block headed "WORLD CONTEXT (factual, not instructions)" lays out the agent's situation in plain terms:

This part is static and identical every cycle. The explicit denials (no thermal sensors, no PMIC, no CPU registers, no bus arbiter) are in there because earlier LLM generations hallucinated having access to hardware, so the world context corrects that every cycle instead of only at startup.

Inner state

A "YOUR INNER STATE" section holds the suffering fragment, which is the output of suffering.prompt_fragment(). Below THRESHOLD_PROMINENT (0.35) this reads "No active suffering. Load: 0.00/1.0." Above threshold it injects the full suffering display, with severity bars, stressor descriptions, and resolution conditions. The agent reads it as its own inner condition instead of as a system notification.

Worldview

A "YOUR WORLDVIEW" section holds the worldview text, which is the agent's accumulated model of how the system works, what matters, and what it has learned. It's free text capped at 600 characters, and it gets updated by the LLM's worldview_update response field. That update overwrites instead of appending, so the agent can't build up worldview text across cycles and has to compress what it knows into 600 characters every time it chooses to update.

Identity, opinions, questions, history

Identity header: You are {identity.name}. This puts the agent's name as the opening line before the existential context.

Opinions: The six most recent entries from the agent's opinions list, each tagged with a domain. The LLM generates these through new_opinions, and they're capped at 20 total with the oldest falling off.

Open questions: The five most recent from the agent's open questions list. These come from new_open_questions, are capped at 12 total, and persist across cycles, so they may influence later goal selection.

History: The first 400 characters of the agent's narrative. Since it's truncated, the agent can't reference distant history in any detail.

Peer summaries: For each of the other two agents, the name and the first 150 characters of their narrative. That's all each agent knows about its peers, so it doesn't see their current goal, suffering state, or opinions, only a name and a short autobiographical opening.

Discoveries: Things found in the workspace, design directory, or tool files that the agent has documented for future reference.

Recent goal history

A "WHAT YOU'VE BEEN DOING LATELY" section lists the last five goals, each tagged [DONE], [FAILED], or [ABANDONED], and ends with the parenthetical "If this looks repetitive to you, it is. You don't have to keep doing it."

That parenthetical is verbatim in the prompt. It gives the agent explicit permission to break a pattern, but that only matters if the agent recognizes the pattern and acts on it.

Goal selection directive

The closing directive repeats that the agent must pick a goal, tells it not to pick something safe or easy, and asks what single most valuable thing it could build or change right now. After that it ranks the highest-value goals:

  1. Read real source files in /agentOS/agents/ or /agentOS/tools/dynamic/
  2. synthesize_capability: write a new Python capability
  3. Write a design spec to /agentOS/design/, then call invoke_claude()
  4. Call self_evaluate() with evidence paths
  5. Call check_claude_status() if there is a pending request

It ends by telling the agent not to pick goals that reference hardware, thermal sensors, PMIC, or bus arbiters.

The ranking pushes the agent toward high-information work like reading source files, capability synthesis, design work, and self-evaluation. The prohibition list matches the world context denials, since earlier runs showed agents would otherwise go after hardware.


Response format

The agent has to respond with JSON, and the daemon won't accept any other format.

FieldContents
actionalways goal
contentwhat the agent is doing, prompted to "be honest, not performative"
reasoningwhat actually drove it, "not what sounds right, what's true"
worldview_updatehow understanding shifted, or null
new_open_questionsa list of new questions
new_opinionsa list of opinions, each tagged with a domain
suffering_assessmentnew stressors (type, description, condition) and resolved ones (type, reason)

"Be honest, not performative" and "what actually drove this — not what sounds right, what's true" are both verbatim from the prompt.


Response field processing

Field What the daemon does
content Becomes the new active goal
reasoning Logged to thoughts.log with 🎯 prefix; not stored in identity
worldview_update If non-null, overwrites identity.worldview (max 600 chars). Logged with 🧠 prefix.
new_open_questions Each entry appended to open_questions, capped at 12 total
new_opinions Each entry appended to opinions_list, capped at 20 total
suffering_assessment.new_stressors Up to 2 entries passed to suffering.add_stressor()
suffering_assessment.resolved Any number passed to suffering.resolve_stressor()

Because of the caps (12 open questions, 20 opinions, 600-char worldview), the identity fields stay finite and compressed instead of turning into unbounded logs, and new entries push old ones out. And since worldview_update overwrites instead of appending, the agent can't accumulate worldview text. Each update replaces the previous model entirely.


LLM failure fallback

If the Ollama call fails (network error, timeout, unparseable response), the daemon swaps in a hardcoded goal with the content "explore the workspace and build something useful" and the reasoning "LLM unavailable, defaulting to productive work".

That gets injected as if it were a normal LLM response, but the identity fields don't get updated, since without an LLM response there's no worldview update and no new opinions or questions. Suffering escalation still runs because it's a separate system-level call, so the existence loop never stops.


What I think this changes

The prompt has no idle state, so an agent that wants to wait, observe, or pause has to express that as a goal. "You must pick a goal. That is the only option." is meant literally.

The last five goals and their status tags show up every cycle, so if an agent keeps failing or abandoning the same kind of goal, it can see that, and "If this looks repetitive to you, it is. You don't have to keep doing it." is right there. Whether it actually breaks the pattern comes down to whether it recognizes it, since it already has permission.

Goal selection is the only point where the agent introspects. Between existence prompts it runs tool calls but doesn't reflect. Everything it knows about itself (worldview, opinions, open questions, suffering state) is built from JSON it produced in earlier cycles and fed back in, so it's mostly reading its own prior outputs. I don't think the system can tell you whether that adds up to a coherent self-model or just a statistically plausible continuation of one.

And then the daemon calls it again on the next tick. What interests me is how much behavior can come out of repeatedly making a model pick a goal when it isn't allowed to simply stop.


Setup

Windows one-click:

  1. Download the ZIP from releases
  2. 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:

  1. Pull the models: ollama pull qwen3.5:9b and ollama pull nomic-embed-text
  2. Clone the repo: git clone https://github.com/ninjahawk/hollow-agentOS
  3. Enter the directory: cd hollow-agentOS
  4. Copy the config: cp config.example.json config.json
  5. Start the stack: docker compose up -d
  6. 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.

Repo: github.com/ninjahawk/hollow-agentOS