If you have been trying to work out how autonomous AI agents actually run, this agent os guide is the practical, start-to-finish walkthrough you have been looking for. An Agent OS (short for Agentic Operating System) is the layer that turns a clever chatbot into a genuine digital worker — one that remembers, uses tools, follows your playbooks, and finishes real jobs while you get on with your day. Below you will set one up piece by piece, run a mission from a single instruction, and see the ready-made option if you would rather skip the wiring.
What is an Agent OS?
Think of an Agent OS the way you think of the operating system on your laptop. On its own, a large language model is like a fast processor with no disk, no apps, and no memory of yesterday. An Agent OS wraps that model in the supporting parts it needs to be useful: long-term memory, a library of skills, connections to your tools, a place to watch the work happen, and a coordinator that decides what to do next.
Julian Goldie's own agent, Hermes, runs inside exactly this kind of system. The point is not a single magic prompt. It is a durable setup you reuse every day, where the agent picks up context automatically and carries a task through to a finished result rather than a half-answer.
The core components of an Agent OS
Every reliable Agent OS is built from the same handful of parts. Get these right and everything else falls into place.
- The model (the brain). The reasoning engine that reads instructions and decides on actions.
- Memory (the long-term store). Notes, facts and past decisions the agent can read back so it never starts from zero.
- Skills (the playbooks). Reusable, written procedures for jobs you repeat — publishing an article, researching a topic, drafting an email.
- Tools (the hands). Connections to the outside world — your files, a browser, a publishing API — usually wired in through MCP.
- A control center (the cockpit). A dashboard where you can see missions, progress and output at a glance.
- Orchestration (the manager). The logic that breaks a big request into steps and keeps the agent moving through them.
| Component | What it does | A common way to do it |
|---|---|---|
| Model | Reasons and decides | Claude Code, or a local model via Ollama |
| Memory | Remembers context | An Obsidian vault of markdown notes |
| Skills | Repeatable playbooks | Written instructions the agent loads on demand |
| Tools | Takes real actions | MCP servers for files, browser and APIs |
| Control center | Shows the work | A simple local dashboard |
| Orchestration | Coordinates steps | The agent runtime planning task by task |
📺 Watch: How to Build Agent OS - FREE Course!
How to set up your Agent OS with this agent os guide
Here is the order I recommend building things in. Each step works on its own, so you can stop at any point and still have something useful running.
1. Choose your model
The model is the brain, so start here. You have two broad routes. The first is a capable hosted model driven through a tool like Claude Code, which many people reach for when they want strong reasoning on long, multi-step tasks. The second is a free local model run through Ollama on your own machine — slower and less capable on hard problems, but private and with no per-use cost.
Which one should you pick? This is where honest testing matters. After my Goldie Bench testing — my own hands-on trials of how models cope with real agent work rather than benchmark trivia — the model I reach for on demanding missions is a frontier hosted one, while I keep a local Ollama model on hand for cheaper, simpler jobs. Goldie Bench is my personal read, not an objective ranking, so treat it as a starting point and run your own tasks through both.
2. Add a memory layer with Obsidian
An agent with no memory repeats itself and forgets what you told it last week. The fix is a simple, human-readable store. Obsidian is a free notes app that keeps everything as plain markdown files in a folder, which makes it ideal: your agent can read and write those notes directly. Create a vault, add a few files for your goals, your projects and your standing preferences, and point the agent at it. Now every mission starts with real context.
3. Add skills
A skill is just a written playbook for a job you do often. Instead of re-explaining how you like articles published or research done, you save the steps once and the agent loads them when the task matches. Start with one or two skills for your most repeated work, keep each one short and specific, and grow the library over time. Good skills are the difference between an agent that guesses and one that follows your process.
4. Wire in tools with MCP
MCP, the Model Context Protocol, is an open standard for connecting an agent to outside tools and data in a consistent way. Think of it as a universal adapter: instead of custom code for every service, you add an MCP server for your files, a browser, or a publishing platform, and the agent can use them. Add only the tools you actually need, and test each connection on its own before you rely on it.
5. Add a control center
Once your agent is doing real work, you want to see it. A control center is a dashboard — even a simple local one — that shows active missions, progress and finished output. It turns a black box into something you can supervise and trust. This is the difference between hoping the agent is working and knowing that it is.
6. Turn on orchestration
Orchestration is the coordinator that takes a single instruction and runs it as a sequence of steps: plan, act, check, repeat. This is what lets you say "research this topic and publish a post" and get a finished result instead of a to-do list. Most modern agent runtimes handle the planning loop for you, so your job is to give clear goals and let it do the stepping.
📺 Watch: Kimi K3 + Hermes AI Agent is INSANE!
How to run a mission day-to-day
With the pieces in place, daily use is simple. A mission is one job you hand the agent from start to finish.
- State the outcome. Describe the finished result you want, not every keystroke. "Draft a UK-friendly guide on this topic and save it to my drafts folder" is a mission.
- Let it pull context. The agent reads your Obsidian memory and any matching skill, so it already knows your preferences.
- Watch the control center. Follow the steps as they run and step in only if something looks off.
- Review the output. Check the finished work, give feedback, and let the agent revise.
- Save what worked. If it was a good run, capture the process as a new skill so next time is faster.
📺 Watch: Hermes Agent + Blender MCP is INSANE!
Common mistakes to avoid
- Skipping memory. Without a memory layer the agent forgets context and you repeat yourself endlessly.
- Too many tools too soon. Every MCP connection is a thing that can break. Add them one at a time.
- Vague missions. "Help with marketing" gets a vague answer. Name the outcome and the finished format.
- No control center. If you cannot see the work, you cannot trust it or fix it.
- Never writing skills. If you re-explain the same job each time, you are wasting the biggest advantage an Agent OS gives you.
- Chasing the biggest model for everything. Match the model to the task; a local Ollama model is plenty for simple jobs.
The done-for-you route
Building an Agent OS from parts is genuinely rewarding, but it does take time to wire the model, memory, skills, tools, control center and orchestration together. If you would rather start from a working system, there is a ready-made Agent OS built for exactly this.
If you want the ready-made Agent OS set up to make you money, check out the AI Profit Boardroom — a community with the pre-built agent, memory and skills already assembled, plus the training to run it. → Get the ready-made Agent OS
It is run by Julian Goldie, whose channel has 411K+ YouTube subscribers and whose community counts 75K+ members, drawing on 10+ years in SEO and content and his work as a best-selling author.
Agent OS guide FAQ
Do I need to code to set up an Agent OS?
No. The trickiest parts — adding MCP tools and writing skills — are mostly configuration and plain-English instructions. If you can edit a text file and follow steps, you can build a basic Agent OS.
Is a free local model good enough?
For simple, repetitive jobs a local model through Ollama is often fine and costs nothing to run. For hard, multi-step reasoning most people still prefer a frontier hosted model. Running both and comparing on your own tasks, Goldie Bench style, is the honest way to decide.
Why use Obsidian for memory?
Because it stores everything as plain markdown files your agent can read and write directly, it is free, and it stays on your machine. Any similar plain-text store works; Obsidian just makes it pleasant.
What is MCP, simply?
MCP is an open standard that lets an agent connect to tools and data through one consistent interface, so you are not writing custom glue code for every service.
How long does setup take?
You can stand up a basic version — model plus memory — in an afternoon. Skills, tools and a control center grow from there over days and weeks.
The Bottom Line
An Agent OS is what turns a smart model into a dependable digital worker: a brain, a memory, a set of playbooks, real tools, a cockpit to watch it all, and a coordinator to keep it moving. Build it in that order, start small, and add a skill every time you finish a good mission. Follow this agent os guide and you will have a system that quietly does more each week — or take the ready-made route and start from one that already works.
