I Spent an Hour Just Starting My AI Factory — So I Built Hermes a Start Button
I Spent an Hour Just Starting My AI Factory — So I Built Hermes a Start Button
The problem was not that the AI Factory had no tools. The problem was that every restart felt like rebuilding the control room from scratch.
This morning I sat down at my home PC with what should have been a very simple goal:
Turn the AI Factory back on and continue the video that was already sitting halfway through production.
Not start a new project. Not rewrite the pipeline. Not redesign Hermes. Not debug OpenMontage. Just continue yesterday's work.
Instead, nearly an hour disappeared into ports, model blobs, YAML configuration, local inference servers, Hermes profiles, MCP tools, project folders, checkpoints, logs, and one question that became increasingly difficult to ignore:
Why does a system this sophisticated still need a human to remember how to start it?
That question led to one of the least glamorous — and potentially most important — additions to my local AI Factory so far:
a startup button for Hermes.
This Is What “Local AI” Actually Looks Like
When people talk about running AI locally, the conversation usually centers on models: how many parameters, how much VRAM, which GPU, and how many tokens per second.
Those things matter. But once you start building a real system around those models, the model itself becomes only one component.
My local Factory now includes Hermes as the production supervisor, local language models, OpenMontage, Remotion, FFmpeg, screen capture, project checkpoints, asset management, metadata, YouTube publishing, Blogger, review gates, local browser interfaces, MCP connections, production state, and Git history.
The bigger Factory design has gradually moved toward an agent-supervised production model where Hermes acts as the local workhorse and OpenMontage handles the production and visual-planning layer. That architecture makes sense.
The problem was startup.
The Factory Worked — Until the Computer Restarted
The frustrating part was that we were not trying to repair a dead system.
A lot of it already worked. Hermes could see our Factory MCP gateway. The gateway registered its Factory tools. OpenMontage had a real project sitting on disk. The project had an approved storyboard. Stock video assets had already been downloaded. The scene plan was complete. The production had reached the asset stage.
Nothing about that sounds like a failed project.
But after the computer restarted, Hermes was effectively standing outside the Factory trying to remember which key opened the door.
The first problem was the local model endpoint. Hermes expected one port. The live model server was listening on another. Then the profile was referencing an old model blob. Then Hermes' auxiliary title-generation process was trying to use the same local model and timing out. Then we discovered Hermes was loading a much larger general-purpose tool surface than it actually needed for Factory work. Then we had to verify that the MCP server was still configured correctly. Then we had to rediscover which OpenMontage project was actually the unfinished production.
This morning, the system failed a very practical test: could a tired human sit down after a reboot and simply continue yesterday's work?
The Most Expensive Part Wasn't the Error
None of the individual problems was catastrophic.
The model server worked. Hermes worked. MCP worked. OpenMontage worked. The video project existed. The files existed. The checkpoints existed.
The real problem was the reconstruction cost.
We had to rediscover the operating state manually.
That is a very different kind of failure. A broken program may throw one obvious error. A partially automated system often does something worse: it leaves all the pieces intact while making the human figure out how they fit together again.
Hermes needed to know:
- Which model?
- Which port?
- Which profile?
- Which tools?
- Which MCP server?
- Which project?
- Which checkpoint?
- Which stage?
- Which actions are still allowed?
A human should not have to answer those questions every morning.
The machine should.
So We Built a Startup Layer
Instead of continuing to memorize recovery commands, we built a dedicated Hermes Factory startup script.
Its job is deliberately boring. That is exactly why it matters.
The launcher checks the known prerequisites before Hermes opens.
START HERMES FACTORY
↓
Read factorysupervisor configuration
↓
Identify configured local model + port
↓
Verify local model server
↓
Start server if necessary
↓
Verify model endpoint
↓
Verify Hermes safety settings
↓
Verify factory-gateway MCP configuration
↓
Find latest OpenMontage production project
↓
Read latest checkpoint
↓
Report project stage/status
↓
Launch Hermes with Factory tools
The eventual user experience should be even simpler:
Double-click: Start Hermes Factory.
Not open PowerShell, remember a port, search a YAML file, inspect a model blob, find an MCP server, grep Python source, find a project, inspect checkpoints, and finally launch Hermes.
Just: Start Hermes Factory.
Why the Toolset Matters
One useful discovery was that Hermes did not need to enter Factory mode carrying every tool it knows about.
Hermes can expose browser tools, web tools, image generation, video generation, Discord, Spotify, automation, and many other capabilities. Those are useful in the right context. They are unnecessary when Hermes is acting specifically as the Factory production supervisor.
Our Factory MCP server is called factory-gateway. It exposes the Factory-specific operations Hermes needs.
The working launch became:
hermes --toolsets factory-gateway
That greatly narrows the working context.
Before Hermes can supervise production, something needs to supervise Hermes startup.
The Startup Button Is Really a Preflight Checklist
A good analogy is aviation.
Pilots do not climb into a sophisticated aircraft and begin flipping switches based on memory and optimism. There is a preflight procedure.
Our Factory needs the same thing.
The startup system should be able to answer automatically:
- Is the model server alive?
- Is Hermes pointing at the same port?
- Is the configured model actually available?
- Is unnecessary auxiliary model traffic disabled?
- Is the Factory MCP gateway available?
- What project was most recently active?
- What checkpoint was most recently completed?
- What is the next unfinished production stage?
Once those facts are known, Hermes can take over.
We Also Rediscovered a Video That Wasn't Lost
One of the more revealing parts of this exercise was what happened after Hermes finally connected to the Factory.
The project had not disappeared.
The unfinished production was Building a Local AI Content Factory — Full Produced Video.
The selected pipeline was hybrid. The selected master runtime was Remotion. The composition approach was Atelier. The visual concept was a local Factory tour.
The approved scene plan was also intact, including local screen recordings, B-roll, diagrams, and generated visual inserts rather than a simple slide deck.
In other words: the creative work was not gone.
We were just having trouble getting back into it.
This Is the Difference Between Automation and Operations
There is a tendency in AI projects to obsess over automating the exciting parts: generate the image, write the article, create the video, call the API, publish the content.
But real automation requires another layer: operations.
Operations answers questions like:
- What happens after reboot?
- What happens after a crash?
- What happens after a model changes?
- What happens if a service starts on another port?
- What happens if a job stopped halfway through?
- Which project should resume?
- Which stages are already complete?
- Which actions must not be repeated?
That is where resumability becomes more important than raw intelligence.
Why I Don't Want Hermes “Starting Fresh”
An AI assistant naturally likes clean context: fresh prompt, fresh task, fresh plan.
Production systems cannot behave that way.
If Hermes receives a new production request and immediately assumes everything should restart, it may regenerate completed assets, rerun expensive inference, overwrite approved work, re-download media, repeat transcription, produce duplicate videos, change creative decisions, or invalidate review gates.
That is unacceptable for a production Factory.
Hermes should instead ask the machine:
What already exists? What was approved? What finished? What failed? What is blocked? What is the next permitted action?
That same logic should begin at startup.
The Button Is Small. The Architectural Change Is Bigger.
It would be easy to describe this as: “We wrote a PowerShell launcher.” Technically, yes. But that misses the larger point.
We are gradually separating three different kinds of intelligence inside the Factory:
Production intelligence — Hermes decides what should happen next.
Creative intelligence — OpenMontage plans how the media should actually be presented.
Operational intelligence — the Factory knows what exists, what is healthy, what is approved, and where production should resume.
The startup button belongs to that third category.
And without that third category, the first two become unreliable.
What the Final Startup Experience Should Become
The finished version should eventually feel like starting any other application.
I turn on the Alienware. I click:
START AI FACTORY
The system performs its own health check and reports something like:
AI FACTORY READY Local model ............... READY Hermes profile ............ READY Factory gateway ........... READY OpenMontage ............... READY FFmpeg .................... READY Current project ........... FOUND Last checkpoint ........... scene_plan Current stage ............. assets Publication gate .......... LOCKED Resume production? [YES]
Then Hermes opens already knowing where the Factory is.
That is what I expected this system to feel like months ago.
We are finally starting to build it.
One Button Is Better Than Fifty Commands
I do not want to become a full-time system administrator for my own AI.
That was never the point.
The point of this project is to build tools that let one person operate a much larger creative workflow.
If the AI system requires me to remember dozens of recovery commands, inspect logs, trace Python source code, and manually reconstruct its state every morning, then I have not eliminated work.
I have simply created a different job for myself.
The better design is:
Complexity underneath. Simplicity on top.
Hermes can remain complicated. OpenMontage can remain sophisticated. The Factory can contain dozens of tools.
But the human-facing interface should keep getting simpler.
What I Learned From Losing an Hour
This morning looked unproductive at first.
We spent nearly an hour trying to get back to a video that had already been partially produced.
But the session exposed something bigger than a broken configuration.
It exposed a missing layer in the Factory.
We had built production. We had built checkpoints. We had built agents. We had built publishing. We had built review gates.
We had not adequately built startup and recovery.
Now we are.
And I suspect that little startup button will eventually matter more to the day-to-day usefulness of the Factory than many of the much more impressive AI features behind it.
Because the best automation is not the automation that looks smartest in a demo.
It is the automation that still works on Wednesday morning after Windows restarted overnight.
The Next Step
The startup launcher is working.
It can bring Hermes back into the Factory without forcing us to rediscover the machine manually.
The next phase is to make it smarter about resuming production:
Start Factory → run health check → locate active project → read checkpoint → determine next permitted stage → hand that state to Hermes → continue production
Once that works reliably, the goal gets much closer to the original vision:
give the Factory a job and let the Factory remember how to finish it.
About this project
This is part of my ongoing effort at AI Workflow Solutions, LLC to build a local-first AI production Factory around tools such as Hermes, OpenMontage, local language models, FFmpeg, and custom workflow automation.
The objective is not to build the flashiest autonomous agent.
It is to build a system that can reliably turn source material into finished media without forcing the human operator to reconstruct the workflow every time the computer restarts.
And today, that meant building something wonderfully boring:
a start button.
Comments
Post a Comment