I Gave My Hermes + OpenClaw Agents a Subconscious, and Now It Dreams 24/7 | Full Guide

You built your Hermes and Openclaw agents to run your workflows, but the more workflows you create, the less time you have to improve them. That is what the subconscious agent is for. Much like a human's subconscious, it continuously problem-solves to help your agents self-improve. It brainstorms, debates, refines, and writes the results back into the system so the next run starts smarter than the last. This is the difference between agents that guess improvements and agents that actually compound. That means less: background anxiety manual ops work repeated debugging mental overhead And more: shipping experimenting compounding Personally, I built the loop inside my Hermes agent workspace so it could stay close to my main workflows, stay configurable, and stay honest about what it knows. This guide is meant to be a template for all agents, so you can point your Hermes, OpenClaw, or other agent here and have it build a similar system. Why This Matters Most agent systems break in the same boring ways: They need babysitting they drift They burn tokens on vague exploration. They produce output, but not momentum. That is the trap. You spend more energy managing the system than using it. The subconscious agent flips that. Instead of asking, “What should this agent do right now?” the system keeps asking: What did we learn? What failed? What should we try next? What needs guardrails? What should be frozen until it earns trust? That is how you get a system that saves time, saves energy, saves tokens, and makes the whole stack feel a little bit like magic. The Architecture Think of it as a small but relentless loop: The system gathers evidence from its latest run. It generates candidate ideas. It debates those ideas against hard objections with a smarter agent. It synthesizes one recommendation that can be accepted or rejected. It writes the result into the state. The next run starts from that updated state instead of starting from zero. That last part is the real unlock. Most systems “remember” in a loose, fuzzy way. This one remembers by keeping the winning direction, the rejected paths, and the next improvement in a durable workspace. So the machine does not just answer. It learns how to answer better. What You Actually Need To Build It This is the part people usually skip. A self-improving agent system needs more than prompting. At a minimum, you need: 1. A runner Something has to coordinate the whole cycle: load the brief fetch current state run ideation run critique run synthesis write artifacts hand off the result In my setup, that is the runner. It is the control plane for the loop. 2. Persistent state The system needs memory that survives process restarts. That usually means: JSON for current summaries and governance JSONL for append-only history markdown for human-readable outputs a stable directory structure so later runs can pick up where the last one ended Without a durable state, the system cannot improve. It just reenacts the same conversation every time. 3. A scheduler or trigger source You need a way to decide when the loop runs: on a cron schedule after new metrics arrive after a live signal changes after a manual review request Please be realistic about how many times you want the subconscious to run on a given workflow each day. Too many runs can lead to excessive divergence from the original principles. 4. A transport or delivery layer The loop is useless if nobody sees the result. So you need a way to send the output somewhere useful: Discord (my setup) Telegram a file path a dashboard a task queue The transport should be separate from the reasoning layer. That keeps the model from becoming tightly coupled to one output channel. 5. A model router Different phases should use different models. For example: cheap/local model for ideation stronger model for challenge and synthesis execution model for artifact generation or final writes That split is what keeps costs sane and quality high. 6. A review and approval gate If the system can ship directly without a human check, you are no longer building an assistant loop. You are building an autopilot. This pattern keeps approval at the end, so the system can be smart without becoming reckless. Of course, it's up to you to decide which tasks and workflows you want to auto-approve, but it's best to test with human approval at the end. 7. Artifact writers The loop needs to write back into the filesystem in a predictable way. For example: `ideas/ideas-internal.jsonl` `debate/debate-log.jsonl.` `winning-concept.md` `improvement-backlog.md` `run-summary.json` These are the system's memories. What it actually does in an example Here is an example of the subconscious trying to think through content to create today. The subconscious layer creates a loop where: 1. `ideas/` stores candidate directions The subconscious starts by thinking in options, not conclusions. It looks at the evidence and generates a few possible directions. In this run, the names