HarsOS explained

HarsOS is my AI operating system. I built it through a lot of trial and error, with one vision in mind:

My businesses, my clients, the software I build, my content, my admin, my personal life, and eventually hardware too. Every domain run by me and my AI agents, with whatever model is best at that moment plugged in, whether it comes from OpenAI, Anthropic, Google, a lab that doesn't exist yet, or a model running offline on my own machine.

I believe AGI is coming. I'm building for the day it arrives, so that when it does, it walks into a life that's already fully written down, organised and ready to run.

HarsOS took five weeks to build. It has been running my days for eight. In those eight days it has handled three clients at the same time: the automations, client portals built the moment a client needed one, proposals, fast rounds of changes, and call recordings turned into finished deliverables. It set up personal AI agents for a client and his office. It moved my own products, Harsift and RalvetoOS, forward. It fixed my own websites and my own setup in between. And it drafted the article you're reading.

Here's how it works and why every piece exists.

Three terms you'll see everywhere

Three words come up again and again in this piece, so here's what each one means.

A model is the AI that does the actual thinking. GPT, Claude and Gemini are models. When people say "the new GPT is smarter", they're talking about the model.

A harness is the app or program a model runs inside. ChatGPT is a harness for OpenAI's models. Claude Code and Codex are harnesses built for writing software. The harness decides what the model can see, which tools it can use, and what it remembers when the chat ends. If the model is the engine, the harness is the car built around it. Put the same engine in a different car and it drives very differently.

An agent is a model that can take actions: open files, run code, search the web, draft documents, use a computer.

Some harnesses are persistent: the agent keeps its own memory and judgment between conversations, like a colleague who was in yesterday's meeting. Most are non-persistent: close the window and everything is gone. HarsOS was built for both.

The problem: every AI company is building its own island

I kept running into drift between ecosystems, and inside them.

• Google has Antigravity, NotebookLM, the Gemini app and Spark, each with its own skills and its own tool connections.
• Anthropic has Claude chat, Cowork and Claude Code, all drawing from one usage pool while keeping separate setups.
• OpenAI has ChatGPT on the web, Codex, Work and Dots, with overlapping features that don't share what they know.

Nothing is unified between the labs, and very little is unified inside each one. Teach one app how you work and the app next to it, from the same company, has no idea. Add a skill in one place and you rebuild it in the next.

The new personal agents are islands too. Meta's Muse, launched in September, runs on Meta's own model. Grok Bot runs on Grok. Each one is built around its maker's model, so the day a better model ships somewhere else, you can't bring it in.

And the walls move. On 28 August, OpenAI announced it will stop supplying its models to Cursor, one of the most popular AI coding tools, after SpaceX bought it. From 12 November, GPT models leave Cursor's plans. Thousands of developers built their workflow on a tool, and a deal between two companies they've never dealt with is taking part of it away.

The all-in-one tools that promise to fix this tend to fall into one of two camps. Some are built for developers: endlessly custom, powerful, and far too advanced for a normal person. The others are built for business buyers, and in my view they give up too much intelligence to get there. Microsoft Copilot is the obvious example. Both camps still lock you in.

It shows up in the everyday stuff. A slide deck made in one AI app, a document drafted in another, a chart built in a third. Each one lives inside the app that made it, and none of the others knows it exists.

Then there's the other end. Tools like Abacus AI, OpenClaw and Hermes give you everything: every model, every connector, every setting. For a technical person, that's the dream. For an average person, it's overwhelming before they've done anything useful. My answer is modularity, just in time: the system is built from small pieces, and each piece appears only when the job in front of you needs it. Writing a proposal brings in the proposal skills. A client call brings in the transcript tools. Nothing else gets in your way.

That's the labs' business model. It doesn't have to be mine.

So I built one ecosystem underneath all of them. Plug and play. Any persistent agent and any non-persistent harness can walk in and work from the same rules, the same skills, the same memory and the same records.

Two principles hold it together:

1. Nothing important lives in anyone's head. Decisions, preferences, client facts, what we tried and why it failed: all of it is written down where every agent and every tool can find it. A chat window closing should never cost me anything.
2. Agents keep their own craft, and the craft is logged too. My persistent agents build their own judgment over time, the way an experienced colleague builds instincts. That stays theirs. But how they got there is written down as well: what they read, how they reasoned, the first principles they worked from, the corrections that shaped them. If an agent ever dies, I can retrace exactly how it became good and rebuild it.

Why every new model makes it stronger

However many features, apps and products the AI labs release, each one only works inside its own ecosystem. That's their lock-in.

Mine is agnostic. I own it, and I can plug all of them in. When one lab ships something brilliant, I use it. When another ships something better next month, I use that. I never have to pick a side, and nothing I've built gets stranded.

The same goes for the agents themselves. Persistent agents like OpenClaw, Hermes, Muse, Grok Bot and OpenAI's Dots are all harnesses, and HarsOS is built so any of them can plug into the same ecosystem. Several can run at once and talk to each other, each with its own instincts and quirks. If one of them disappears, or all of them do, nothing is lost.

Why: I'm preparing for AGI

AGI stands for artificial general intelligence: AI that can do roughly any thinking job a capable person can. Plenty of people think that's decades away, or never coming. I think it's coming, and I've built for it from day one.

This goes beyond business. I want to be fully AI-native from the start, so that when the best models arrive I plug them in on day one, including models running locally on my own hardware with no internet at all.

Three things follow from that belief.

The model is the part I can always swap. Whatever is best this month, I use. What no model can bring with it is my context: my life, my clients, my decisions, my taste, what I tried and why it failed. Context compounds. So I keep all of it, in a form any future model can read, and I own it.

So there's no vendor lock-in. My memory doesn't live inside ChatGPT or Claude. If a better model ships tomorrow from a company that doesn't exist yet, I switch, and it walks into a life and a business that are already written down. No "Hi, my name is Hamza." It starts where I am.

And nothing I build is allowed to get in a good model's way. This one took me a while to learn.

Rules that help a model, and rules that hold it back

Older models needed hand-holding. They lost the thread in long tasks, forgot instructions halfway through, skipped steps and made things up with total confidence. So everyone, me included, wrapped them in rigid step-by-step instructions, fixed templates, checklists for everything, and warnings repeated three times in capital letters.

Then the models got better, and I noticed something: a lot of that scaffolding started making them worse. A smart model following a rigid recipe written for a weaker one does weaker work. It does what the checklist says when the situation needed judgment.

So now I separate two kinds of rules.

Scaffolding exists only because today's models are weak at something. Every piece of scaffolding in HarsOS gets marked with the failure it prevents and a test for when it's safe to delete. Every so often I ask: what can current models now do on their own? Whatever they can, the scaffolding goes.

Rules that matter even for the most intelligent thing in the world have nothing to do with intelligence. They're about me, and about trust:

• my taste and my preferences
• privacy: who can see what
• permission: nothing gets sent, published, paid for or deleted without my yes
• provenance: every claim traceable to where it came from
• recovery: everything can be restored if something breaks
• hard safety rules that code enforces, every time

A genius employee still needs to know how I like things done, which files are private, and that they can't spend my money without asking. Those rules stay forever. As models get smarter, HarsOS gets simpler, and these rules are what's left.

I log everything

This is the part I'm proudest of, and the part that sounds a little insane.

I log everything. Every conversation with every agent, word for word. Every decision and what it replaced. Every correction I make. Every tool call an agent makes, down to each search, file edit and command it runs. Every day, from when I wake up to when I go to sleep.

Why go that far?

Because better models will read it better. Everything I save today gets re-read by tomorrow's models with fresh eyes. If I only kept summaries, I'd be stuck with today's understanding of my own life forever.

Because it's my insurance. If everything died tomorrow, every agent, every app, every server, I'd still have a complete record of everything that happened and why. I could retrace my steps exactly, down to the reasoning behind each decision, and rebuild from scratch.

Because it's training data for my own system. Every mistake, every correction and every win is a data point. It's how the system learns what "good" means to me, which I'll come back to.

Here's how the whole loop works.

1. Raw: every conversation, word for word

Every conversation I have, in any harness, gets exported as a raw thread: the exact words, timestamped, with passwords and keys stripped out. Coding sessions keep every action the agent took, so anyone can later see how the work really went, step by step.

Every raw thread is also cut into short passages and stored in a vector database, a search index that works by meaning (more on that below). So any agent can find any moment from any conversation in seconds, even when nobody remembers the exact words.

Why keep it raw when a summary is shorter? Because summaries drift. An agent summarising "I'm not sure about X" can turn it into "Hamza decided X", and once that summary gets summarised again, the mistake becomes history. The raw thread is the evidence.

My recall index currently holds more than 5,000 conversations, cut into over 53,000 searchable passages.

2. The day: it ends when I sleep

A small script keeps track of my days. It watches every chat I use for me saying good morning and goodnight, and it defines a day as the time between them. My day, as I actually live it.

Here's what caused it. I don't keep normal hours. I can wake up at 11pm on a Wednesday and go to sleep at 4am on Friday, and that's one day for me. Calendar-based logs chopped that one day across three dates. Reviews fired at midnight while I was still mid-work. Nothing matched how I live.

So the day follows me, and the script handles the edge cases:

• Come back within three hours of saying goodnight, and the same day reopens.
• Say good morning, or come back after more than three hours, and a new day starts.
• Forget to say goodnight, and four hours of night-time silence closes the day for me.
• A nap doesn't end the day.

Saying goodnight is also the trigger for the whole overnight cycle.

3. Overnight: every agent re-reads its whole day

When I go to sleep, each agent goes back through every conversation it had that day, all of it, word for word. I insisted on that. Skimming the first and last few messages is how important things get missed.

From that, each agent writes a cited log: every finding points to the exact conversation and the exact spot it came from. If it can't point, it doesn't go in. A second agent checks the work. A final pass writes my morning review.

The citations are for both of us. Months later, when someone asks "why did we decide this?", the agent and I can each click straight back to the moment it happened.

4. File: everything goes to its one home

Everything from the day gets sorted into my HQ, a set of linked databases I built for myself:

• Log. Every subject from the day, what happened and where.
• Decisions. What was decided, by whom, and which older decision it replaced.
• To-dos. Every open action, linked to its project.
• Ideas. Every idea, with the trigger that should bring it back.
• Learnings. Every correction or win, and the rule it produced.
• Done. A page for each day showing everything that got finished.

A few details matter here:

• Reminders keep their context. A reminder carries its trigger and its reason. When the moment comes, it comes back with everything around it, instead of firing just because a date passed.
• Coding work gets logged too. What was built, what changed, and why, linked to the code itself.
• Salience. Not everything deserves to be remembered. The overnight pass keeps rare but serious failures, stable preferences and good examples, and lets duplicates and noise fade. Repetition alone doesn't make something true.
• Synthesis. Scattered moments across a day, or a week, get pulled together into one clear picture, still linked back to every source.
• Upkeep. Records get reconciled against reality: done things marked done, stale ideas retired with a reason, conflicts surfaced instead of silently overwritten.
• One home, one writer. Each kind of record has exactly one place it lives. Copies drift apart. One home can't disagree with itself.

5. Learn: every correction becomes a lesson

Every time I correct an agent, or love something it did, it becomes a lesson that records:

• what the agent did
• what I wanted instead
• what I actually said
• the rule that came out of it
• how many times it has happened
• whether it's been promoted
• a link back to the raw conversation

The agents file these themselves. If they get something wrong and I have to push, they fix it, file the lesson with a link to the proof, and tell me in one line. Mistakes get logged whether a person made them or an agent did.

6. Upstream: proven lessons climb

A lesson starts small, inside one project. If it happens again, its count goes up. Once it's proven and clearly applies beyond that project, it climbs into a skill, a written playbook for one kind of work. If it turns out to be true everywhere, it climbs again into the rulebook, the one file every AI tool reads before it does anything.

Raw conversation, then lesson, then skill, then rulebook.

7. Downstream: the rules flow back to everyone

The next morning, every agent and every harness starts from the improved rules. That includes the tools that remember nothing on their own: they pick up the same rulebook and skills the moment they open.

One edge case: if a project has its own better local version of a rule, the shared rule doesn't flatten it. The closer, more specific rule wins inside its own project.

What runs while I'm not looking

A lot of HarsOS is scheduled jobs that run on their own:

• Every five minutes, my open to-dos and ideas are re-indexed for search, the day-tracking script checks my chats, and any comment I've left anywhere in my HQ gets picked up, turned into a task and answered.
• Every night, the agents review their day, the whole HQ is backed up off-site, only the pages that changed get re-indexed, and anything new that isn't linked to a project gets linked.
• Reconciliation checks what the records claim against what actually happened, so a to-do marked "sent" really was sent.

The design rule behind all of it: cheap watchers, smart judges. Simple scripts check for changes constantly and cost almost nothing. An agent only wakes up when something actually changed, and then decides whether it matters. Code handles the mechanical part. Intelligence is spent on judgment.

Recall: finding anything I've ever said

Logging everything is useless if nobody can find it. So all of it goes into a recall system: every page in my HQ, every raw conversation, every skill.

There are two ways to search a pile of text, and they're good at opposite things.

Lexical search matches exact words, like Ctrl+F. Search a client's name and you get every page with that name. It's precise with names, numbers and rare phrases. But ask "what did I decide about paying for the search tool?" and it finds nothing if I never used those exact words.

Vector search matches meaning. Every passage is turned into a long list of numbers that captures what it's about, something like coordinates on a map of ideas. Those numbers live in the vector database. Passages that mean similar things land close together. So "paying for the search tool" finds the night my card kept getting declined for the search service, even though none of the words match. On its own, vector search gets fuzzy with exact names and numbers.

So HarsOS runs hybrid search: both at once, merged into one ranked list. We worked this out ourselves, by watching each kind of search miss the things the other one caught.

The details that make it work:

• My own words are searchable on their own. An agent can pull only what I actually said, instead of another agent's summary of it.
• Dates come first when a question has a date in it. Ask about August and you get August, dated by when it was said, not when it was saved.
• Privacy is part of where things are stored. Work material goes into the shared search. Personal, money and client material stays on my own server, and only the agents allowed to see it can search it.
• New ideas are searchable within five minutes. I park ideas constantly and sometimes pick them up half an hour later. Waiting for the overnight run would have meant the agent I was talking to couldn't see what I'd just written down.

The search that runs before the agent replies

Every time I start something with any agent, the system searches my HQ before the agent writes a word. It pulls the open to-dos, ideas and decisions related to what I just said, by meaning and by exact words, and hands them over. The agent opens with something like: "Found this in your HQ: you wanted to write the HarsOS article, so I moved it into Doing."

A noise filter means a match only counts if it stands clearly above the background for that exact message, so sending a meme doesn't drag in a random to-do.

Two rules keep recall honest:

1. A search result is a pointer. It tells the agent which page to open. The agent reads the live page before acting.
2. Numbers never come from search. Money, statuses and counts get checked live, because any copy is out of date the moment it's made.

Memory: what's a fact and what's a rumour

Most "AI memory" is one big pile. Mine is separate layers, each with one job:

Everything a machine needs to read is a Markdown file: plain text with a little formatting, a # for a heading and a dash for a bullet. Every AI tool on earth can read plain text, and it'll still open in twenty years. That's a big part of how I stay free of any one company.

When two layers disagree, there's a fixed order:

1. The live system: my calendar, my bank, the actual code.
2. The maintained record in my HQ.
3. A recorded decision.
4. Search results.
5. An agent's memory.
6. Something someone said in a chat.

A newer message doesn't automatically beat an older record. Five summaries of the same guess are still one guess. And a lesson is allowed to become wrong: when it does, it's retired with the reason, so search doesn't keep dragging the old rule back.

One shared workspace

Everything sits in one shared workspace: a single folder every harness opens, with the rulebook at the top, one set of skills, and every project inside it. Whichever company made the tool, it reads the same rulebook and the same skills. Each skill exists once, and every harness uses that same copy.

My businesses and my personal life live in the same system, each in its own space with its own privacy rules.

My agents have their own computers

I run three agents. Each one lives in the cloud with its own computer: its own files, memory and tools. They work around the clock: while I sleep, while I'm out, while my laptop is shut.

They're also connected to my laptop through a private, encrypted link. (The technical name is SSH: a standard, secure way for one computer to control another. Mine runs over a private network that only my devices are on.) When a job needs my laptop, like a coding tool I pay for that only runs there, my agents open it themselves, run the work, and bring the result back to the cloud. Some of the images in this article were made exactly that way: an agent in the cloud drove the AI tools on my laptop, checked the results and brought them back. I can cut that link with one switch.

I don't run any agents on my laptop anymore. I used to have several. I retired every one. Everything is cloud, and the cloud agents reach the laptop when they need to.

And I run all of it from my phone, usually by voice note, from wherever I am. I don't need to be at my laptop at all.

One rule matters more than it sounds: the cloud never pretends it can see the laptop. If a job needs the laptop and the laptop is off, the job waits and says so. It never reports a result it couldn't have produced.

If my laptop disappears tomorrow

I still have everything.

• My agents and their memory are on a cloud server.
• My HQ is backed up off-site every night.
• My code lives in private online repositories.
• Every conversation is stored in two separate places.
• Big files sit in cloud storage.
• Passwords and keys are in a password manager. No agent ever sees one in plain text.
• A written rebuild guide, with no passwords in it, explains how to stand the whole agent setup back up on a fresh machine.

None of that depends on my laptop, and none of it depends on one AI company. Each agent is built to pack into a single file and move to a new machine.

The rule behind it: a backup only counts if you can restore from it. "It uploaded" and "I can get it back" are different claims, and only the second one matters.

A software factory

Because the agents build as well as think, HarsOS is also my software factory. Things it has designed, built and shipped:

• A control app for my agents, with views for knowledge, chat and live activity, and a share button that sends any link straight into HarsOS.
• My agency's website, rewritten and redesigned.
• Harsift, a CV screener where every shortlist decision points to the exact line in the CV behind it.
• Client portals, set up the moment a client needs one.
• Proposals and agreements, built from the client's own words on the call.
• A legal operations prototype.
• Client welcome films in English and Gulf Arabic, made with 3D software.
• A product launch film in four versions.
• A spec ad where two AI coding tools each made a cut with a 3D hero shot, and I picked the winner.
• Demos, like an agent that compares food prices across delivery apps and orders the cheapest.
• Every tool inside HarsOS itself: the exporters, the overnight review, the recall system, the backups, the comment watcher.

It also runs my consulting, from research and call prep to turning call transcripts into proposals and agreements.

Ten things at once

Multitasking was the problem that started all of this.

I always have far more going on than one head can hold: client work, my own products, content, ideas, personal admin. I'd dump a hundred thoughts into a hundred different chats, and lose most of them. I'd forget my own vision and what I'd already decided. Two hundred different things across two hundred projects, and decisions kept getting overwritten or lost between tools.

HarsOS is the fix. Every brain dump gets captured, sorted, linked to its project, and brought back when it's relevant.

The part that still feels like magic is switching. I can be in the middle of a client proposal, jump to a bug on my website, drop a voice note about a video idea, answer a question about my own product, and come back to the proposal an hour later. Nothing gets lost and nothing collides, because:

• Every piece of work has its own thread and its own home. The proposal lives with the client. The bug lives with the website. They never share a scratchpad.
• Every new message gets checked against everything that's open. The search that runs before the agent replies pulls in the right project, so I never have to re-explain where we were.
• Agents work in parallel. One drafts while another researches and a third builds. They hand work to each other in their own threads, and I see the results, not the plumbing.
• Reconciliation closes the loop. Overnight, everything that moved during the day gets matched against its record, so the state of every project is true when I wake up.

On a normal day I might have a client proposal, a website rebuild, a new product, a video and something personal all moving at once. I check in from my phone, approve what needs approving, and the agents carry the rest. When I come back, I see what got finished, what needs me, and what was learned.

It covers the personal side too: reminders, admin, plans, money tracking, and the hundred small things I'd otherwise forget.

I trained my agents

People see an agent step back and connect two ideas I hadn't connected, and assume that's the AI being clever. Most of the time, it's something I taught it.

None of what follows came out of the box. Every behaviour exists because an agent didn't do it, I noticed, and I built something that made it happen every time. I didn't change the model's weights. I engineered everything around the model: the rules it reads, the skills it follows, the context it's handed, the checks it has to pass, the data it learns from. It's harness engineering. And because I log every data point across my life down to each tool call, I can see exactly what changed and whether it worked. It's my own small AI lab.

Onboarding, like a new hire, only far more thorough

Before any of this ran on its own, every agent went through onboarding.

On 11 September, at about two in the morning, I kicked off a full learning pass for the whole team. At that point it was eleven agents, some in the cloud and some on my laptop. Each one had to:

• read my full history first: every conversation I'd had in ChatGPT and in my coding tools, extracted and cross-checked before anyone started
• learn the fundamentals of its own field, from named sources, including the people who disagree
• decide what to adopt, adapt or reject, and say why
• write what it learned into its own memory and skills, with a record of exactly what changed and where
• compare notes with its counterpart on the other machine
• write its own reflection, in its own words

One rule ran through all of it: reading something, absorbing it, fixing something because of it, and actually behaving differently are four different claims. Nobody got to award themselves an expertise score.

It wasn't smooth. I paused the whole thing at 4am that first night and resumed it the next afternoon. Agents reported material as "missing" that they had already received. Those mistakes became rules too.

Some of what they wrote about themselves at the end:

"The thing I learned most sharply is how to tell useful rigour from administrative cosplay."

"I came out of this pass less eager to be clever and more exact about what a clue permits."

"Research quality often turns on tiny joins, not giant reading lists."

On 15 September I closed onboarding. On 24 September every agent sat the same acceptance test, on the same evidence. They passed with conditions, scoring 7 and 8 out of 10, and nobody got a clean sweep. The test caught two real gaps: a nightly job that had never had a natural run, and a tool that reported a failure when the work had actually been done. The tool was fixed and checked again the same day. The nightly job stayed on watch until it proved itself on a real night.

At the end of September I cut the team to three. The retired agents' jobs moved to the three that stayed, and the lessons they had filed were already in the shared skills.

Onboarding never really ends. Every correction since then goes through the loop above. On 1 October, 89 waiting lessons were merged into the skills in one pass, and the queue hit zero.

The skills

A skill is a written playbook for one kind of work: how to do it well, what to check, what good looks like. Every agent and every harness uses the same ones. What's inside them stays mine. Here's what they do.

Interconnector. This came from how my own brain works. I always felt there were connections I was missing, like a missing pixel in an image. So the agent steps back from whatever I'm working on and strips it down to what it actually does underneath. Then it maps who it really affects, two or three steps out, and where the same problem appears somewhere completely different: another industry, history, science, another country. Then it changes the frame: a hundred times bigger, ten years out, flipped.

One example. We built a demo where an agent finds the cheapest price for a meal across delivery apps and orders it. Step back, and what that code really does is match the right food to the right person at the right moment. Where is that badly broken? Restaurants throw food away every night while people nearby go hungry. Same code, a Ramadan version that routes iftar meals to the people who need them.

The rule: keep only the connections that are real and give me something to do. A clever link that changes nothing is noise.

Interlinking. Nothing floats. Every to-do belongs to a project. Every piece of work is linked to the to-do it was made for, the moment it exists. Every claim links to its source. A daily pass catches anything that slipped through.

Research Orchestrator. Before an agent gives me an opinion on anything that matters, it works through a fixed order: what I already have, then official and first-hand evidence, then the people actually doing the thing, then the wider internet with real comments and real sentiment, and finally it attacks its own answer. Hacks and workarounds count as evidence. Ten copies of one source count as one source.

Reverse engineering. Take something that already works, a product, a funnel, an ad, and take it apart until you know why it works, before copying anything.

Writing. My voice, plus a running list of every phrase I've rejected, so nothing I publish reads like a machine wrote it.

Export, log and review. The skills that run the data loop, so it works in any harness, even ChatGPT in a browser.

The principles

• Steelman me, then push back. My messages are voice notes full of half-thoughts. The agent works out what I meant, says it back better than I said it, then argues if it's wrong. It doesn't fold because I push twice. New facts change its mind; repetition doesn't.
• Premise flip. Before solving a problem, check it's the right problem. If I say "we need more leads," the agent looks at the funnel first. If existing enquiries are going unanswered, it tells me to fix follow-up before paying for a single extra click.
• Bring me a decision. The best answer, already worked out, with what it's standing on. I only get asked for what only I can give: a real decision, access, taste or permission.
• Already handled. When I raise a concern, the ideal reply is "already handled, here's the proof, and here's something you didn't think of." It only counts with dated proof.

"Proactive" is just a word

Everyone says they want their AI to be proactive. On its own, the word means nothing.

So I defined it. Proactive means: every new event, an email, a payment, a finished task, my own update, gets checked against everything that's waiting. If it unblocks something that was parked, the agent tells me in one line, suggests the next move and asks for the one yes it needs. It stays quiet when nothing is worth saying. And it never takes an outside action, like sending, spending or publishing, without my yes.

Then I test it. HarsBench is my own benchmark, and it's the culmination of all my criteria. It runs inside HarsOS on real work from my own life and checks the whole system together: the model, the harness, the tools, the context and the result. It looks at autonomy, proactivity, stepping back and connecting ideas, picking what actually matters, writing and design taste, how much I had to fix afterwards, and real business value. It's built from my real wins and my real corrections. Where it's heading: every morning, my checklist line by line in plain English. Did they do this? Did they do that?

The 137 questions

Before I finished building the system, I wrote down everything it had to make possible. In my own words, it came to 137 questions across 18 areas, all hanging off one:

Will you be able to do this without me constantly remembering, routing, repeating context, checking and chasing?

Every question comes with a real example. I use the list before building anything ("is this what we're aiming for?") and after ("show me it actually happens, with evidence"). A good overall score never cancels out one serious failure.

This is where the edge cases live. A few of them:

• Pasted advice isn't an instruction. If I paste someone else's opinion into a voice note, the agent doesn't start following it.
• An idea isn't a task. "Build a robot someday" stays an idea. "Send this proposal tomorrow" becomes an obligation. "We tried this and dropped it" stays history.
• Seeing a reminder isn't doing it. Shown, put off and done are three different states. Seeing the same reminder in two places doesn't create two reminders.
• A changed file isn't a changed agent. When I correct how an agent writes, we check a fresh session actually picks up the correction.
• A crashed job doesn't get blindly repeated. If a worker sent a message and died before reporting it, the next one checks what actually happened first, so a client never gets the same email twice.
• Catching up never destroys newer work. Unsaved edits on my laptop survive the cloud updating overnight.
• Three agents agreeing proves nothing if they read the same stale sentence. Agreement has to come from checking the live record.
• A missing number stays missing. If a provider doesn't report a cost, the field says unknown. Never zero.
• Any improvement can lose. A change that raises a score but makes my day worse gets rolled back. "No change needed" is an allowed answer.
• Review has to end. Check the fix and what it touched, then stop.
• Important truth can't wait until midnight. If a proposal goes out at 2pm, the record updates at 2pm.
• A better model shouldn't mean rebuilding my life.
• And the last one: does the whole system leave me with less to hold in my head?

I thought AI would teach me

I went in thinking the AI was the genius and I'd be the student. It does teach me, all the time. But at almost every turn, I was the one sharpening it. Stepping back, interconnecting, interlinking, pushing back, citing everything, re-reading the whole day instead of skimming it. Every one of those is a rule I wrote after an agent didn't do it, then corrected again, and again, at all hours, until the behaviour stuck.

And it cut both ways. I caught myself doing the same things I'd catch the AI doing: confidently planning things that didn't hold up, overengineering, building architecture instead of shipping. In August I simplified the system three times and wrote down the rule "complexity must earn itself." In September I rebuilt it bigger anyway: eleven agents and close to 4,000 files. Then I tore it down to 133 files and, by the end of the month, three agents. The full story is in Why my AI system kept failing.

So the system had to be built to catch me too. That's half of why the agents are told to push back.

Where this is going

Project Hamza distillation. Every message I send, every correction, every decision and the reasoning behind it is already logged. The next step is to distil it: how I write, how I think, how I decide, across every context I work in. One day I want to connect intelligence straight into the ecosystem so that it knows and thinks the way I do.

More businesses. My goal is to be the most AI-native one-person operation possible: just me and my agents, across every domain, starting and running several businesses at once. Ralveto, my AI agency, is one of them.

Hardware and local models. Agents that work on my own machines, offline, with the same memory and the same rules.

From HarsOS to RalvetoOS

HarsOS is where I test everything on myself first. What works goes into RalvetoOS. The patterns travel from one to the other. My private data never does.

RalvetoOS is the same idea, built for everyone else, and it covers both halves of a life.

For a business, the owner, the staff, the clients and the AI agents all work off the same records, and the agents already know the business before they touch anything. It plugs into the software the business already uses. Nothing anyone says becomes a fact until a person confirms it, and nothing reaches a client until a person approves it.

For a person, it's a personal agent with its own computer that lives on your phone and knows your life the way my agents know mine.

For both at once, your personal side, your business and each of your clients sit in separate walled spaces inside one app, the way a phone keeps a work profile apart from your personal one. A business only sees what you choose to share. If you leave the company, your personal space leaves with you.

Both halves are already running. A business owner here in the UAE is paying for his own personal agents, built on the same core as mine. An e-commerce brand is being automated on it right now. And Harsift, my CV screener, is the hiring piece, with the same rule underneath it all: no claim without a source.

The moat

No matter what happens, this is almost impossible for me to lose, and that includes the businesses I build on it.

Here's why. Given the choice, a business would rather own its own software and its own data than rent them from a vendor that can change the price, the terms or the model whenever it likes. Cursor's users just found out what that costs. Anyone building on a single lab's island is one boardroom decision away from the same thing.

RalvetoOS is built around that choice. The business owns its records, its agents and its context, in plain formats any model can read, and it's designed so the business can take all of it with them.

That sounds like giving the moat away. It's the opposite.

And if every AI company changed its terms tomorrow, I'd swap the engine and keep driving. My moat never lived inside any of them.

The full walkthrough of RalvetoOS, from sign-up to the first voice note, is here: What I'm building: RalvetoOS.

The models will keep changing. The companies behind them will keep changing. My laptop will die one day. None of that touches what matters, because what matters was never stored inside any of them.

When the next model shows up, it won't need an introduction.