What OrgOS Already Does for Me in Running Lucimark

In short

I am building Lucimark OrgOS, an organizational operating system: the whole assembly of AI agents with defined roles, the rules they work under and a structured record of the company that they keep. It is not a product yet, but it has already changed concrete things in how I work. My decisions are recorded instead of depending on the memory of conversations. I can delegate execution without delegating authority. A promise now requires a check. And the organization’s memory can be corrected without erasing its history. I do not yet know how much time it saves me or whether it increases revenue, but I already run Lucimark depending less on my own memory.

On 10 October, around noon, one of Lucimark’s production services started failing. Fourteen minutes later, an agent decided to roll back the version, and within twenty minutes the service was back to normal. In less than half an hour, another agent had found the cause in the code. An hour and a half after the first error, the fix was ready, tested and merged into the code.

Not long ago, every one of those steps would have gone through me.

Lucimark builds software infrastructure for companies that operate networks of digital screens. As its founder, I have to follow product, engineering, infrastructure and strategic decisions. And, as in many small companies, a disproportionate part of that work ends up depending on me.

Not necessarily because I am the best person for each task, but because I know the context, the priorities and what has already been decided.

In recent months I started building an alternative: Lucimark OrgOS, an organizational operating system. By that I mean the whole assembly, not only its memory: AI agents with defined roles, the rules they work under, and a structured record of the company that they keep.

It is not a commercial product yet. It runs internally, partly in a test environment, and is far from covering the whole operation.

But it has already changed concrete things in how I work. Four in particular: my decisions no longer get lost in conversations, I can delegate execution without delegating authority, a promise now requires a check, and the company’s memory can be corrected without erasing its history.

Decisions no longer depend on the memory of conversations

One of the first problems I tackled was simple: how do I make sure that a decision taken today is still the same decision tomorrow?

With several AI agents, conversations pile up. One agent proposes a solution, another implements it, a third reviews it. Meanwhile, I change a priority or set a constraint.

The hard part is not passing that on. It is having an unambiguous record of what I authorized.

Before, a decision of mine lived in the conversation where I made it. If, days later, someone needed to know what I had decided, they had to find that conversation, or trust memory: an agent’s or mine.

Today, a coordinating agent brings me the decisions that need me, with their consequences and whether they can be reversed. When I decide, the decision is written into OrgOS’s record, in the exact words I used, and that record is what we go back to, not the conversation. On 8 October, for example, I took thirteen decisions in a single session, and all of them were recorded that way.

Hand-drawn diptych. On the left, a small robot-like agent with a lantern kneels in a dim room buried in paper scraps shaped like speech bubbles, reaching for one of them. On the right, the same agent sits at a tidy desk by a window, reading a slip; a speech-bubble slip is pinned to the page of an open ledger, and a red thread runs from the pin to an open drawer of a wooden card cabinet. — Figure 1 **Before and after.** A decision used to live in a conversation. Now it lives in a record.

That does not make the decisions better. It makes them unambiguous. The most important gain, for me, is not speed. It is no longer depending on anyone’s memory to know what was decided.

I can delegate execution without delegating authority

Lucimark’s engineering already uses specialized agents.

Each agent has its own role and its own limits.

Execution still goes through normal engineering: code changes, merge proposals, tests, reviews and releases.

OrgOS does not replace those tools; its agents work through them, and its record preserves the context: which intention justifies a piece of work, which decisions authorize it and what evidence exists about the result.

The incident at the start shows the difference. The change that caused it was only meant to add measurements to the service. The rollback, the diagnosis and the fix, confirmed by tests, were done by agents. My part was to approve the next attempt.

The agents did that work, and the record kept what I had approved and on what basis. Both are OrgOS: one part acts, the other remembers. I still have to supervise, but I am no longer the intermediary for every technical step.

A promise now requires a check

On the evening of 10 October, the fixed version of the change that had caused the incident earlier that day was due to go to production.

The release was scheduled for 22

and did not happen: the routine responsible for it aborted when it read an old instruction, and it told no one.

Only the next morning did the problem become clear.

What bothered me was not the failure. It was realizing that I had treated an agent’s promise and its execution as one and the same thing.

Hand-drawn triptych from night to morning. First panel: at night, a small robot-like agent holds a sealed envelope tied with red string under a large wall clock without numerals. Second panel: at dawn, the same envelope lies unopened on the doormat in front of a closed green door. Third panel: in morning light, a second agent kneels with a magnifying glass and presses a red wax seal onto a parcel tied with red string, while a man in a tweed blazer watches from the doorway. — Figure 2 **Promised, executed, verified.** Only the last one counts as done.

It looks like a small failure, but it matters to anyone who depends on autonomous agents. An agent can say it will carry out a task. It can even start the work. That does not mean it has finished, or that anyone has confirmed the result.

On 11 October we set a stricter rule: commitments with a time need an associated check. A routine that fails or stops unexpectedly must report the problem to its owner. Confirmation that something is done has to come from whoever actually verified it.

Scheduled checks have already run under this rule. It is too early to show it covers every case.

But the criterion has changed.

A promised task is not a completed task. An executed task is not necessarily a verified task.

What I gain from this is a criterion that no longer depends on my attention: only what someone has verified counts as done.

The organization’s memory also has to be correctable

An organizational system cannot just accumulate information. It has to distinguish what happened, what someone reported and what remains unknown.

On 10 October we loaded Lucimark’s objectives into OrgOS’s record: six intentions and the fourteen initiatives that serve them. We checked each of the twenty records against its source, and all of them matched.

Along the way, the checking tool itself got it wrong: it misread where a piece of information came from and flagged twenty differences that did not exist. We fixed it.

That was when I realized that checking is not enough. You also have to be able to check the checker.

Hand-drawn illustration of two small robot-like agents at a desk. One bends over an open ledger with a magnifying glass, following a red thread that links two pins on facing pages. The other stands behind it, holding a larger magnifying glass over its shoulder. — Figure 3 **Checking the checker.**

We are building mechanisms of trust, but the mechanisms themselves can also fail.

Something similar happened while preparing this article.

I asked the coordinating agent for real figures from the company. In its first answer, it gave an inconsistent count of engineering changes and described part of the 10 October incident incorrectly. When I asked it to check its claims against the records, it corrected the answer and acknowledged what it had not verified.

An AI agent can answer with conviction and be wrong. Giving it organizational responsibilities does not change that.

The goal of OrgOS is not to make its agents infallible. It is to create the conditions for claims to be checked, contradictions found and corrections preserved without erasing the history.

That is what it already lets me do: hold what an agent claims up against what was recorded.

What still depends on me

There is a boundary I insist on keeping: agents can propose, analyse and carry out authorized work. They cannot take on the founder’s strategic authority.

I remain responsible for the company’s intentions, for decisions about cost, for changes of policy and for important changes to the operation.

The very change that caused the 10 October incident went through me: I approved it that morning, as an exception. The responsibility for that decision is mine, not the agents’.

Silence does not mean approval. A quick answer given without understanding the consequences should not be treated as a valid authorization either.

Some of these protections are already built into the process. Others still depend on agents following rules, not on mechanisms that would block a violation.

I do not confuse the two.

What I want is not a company governed by agents. It is an organization in which agents can work within clear limits, with human authority and accountability that can still be identified.

What changed in my day to day

Today I can ask the coordinating agent where work stands, which checks have run, what is pending and what needs a decision from me.

I no longer follow every conversation between agents or rebuild decisions from scattered messages.

There is also a watch that already runs without me. An agent’s routine proactively follows how our cloud platform is being used. It stays quiet by default and only raises the alarm when it sees a sudden spike, growth that persists or something that looks like a fault.

On 3 October, it flagged a possible fault in a test environment, with usage about five times above normal. On 7 October, it opened an alert in production and closed it in under an hour, after concluding it was real growth: more screens connected. It was the first time an alert about my company was opened, investigated and closed without my having to do anything. It measures usage, not money, and it was not built to detect failures. But it already keeps a watch for me that I could not keep on my own.

Hand-drawn landscape at sunset. On a wooden watchtower, a robot-like sentinel in a red scarf looks through a brass spyglass, with a small bell beside it. Below, a village of houses with glowing screens in their windows is linked by pale threads; one red thread runs to a lit window in the foreground, where a man reads at a table. — Figure 4 **A watch that runs without me.**

What I do not have yet is a reliable measure of the hours I have saved.

Nor do I have a reliable figure for what it costs, or evidence that it has directly increased Lucimark’s sales, retention or revenue.

For now, OrgOS does not coordinate sales, marketing or support for our customers. Its most concrete use is in structuring decisions, keeping the organization’s memory and following the work done by the agents.

It would be easy to draw an ambitious architecture and call it an autonomous company. Showing that this autonomy can be trusted is much harder.

I would rather start with what I can observe.

The next problem is not giving agents more autonomy

How do I measure the quality of a decision? How do I tell a task that was really completed from a completion that was only reported? How do I know whether the agents are creating more value than they cost? How do I preserve an organizational history that does not change arbitrarily when the context is rewritten?

I do not have complete answers yet.

For a long time, my role as founder blurred into being the company’s memory, its coordinator and its correction mechanism.

OrgOS is letting me experiment with separating those functions.

I still decide. I am still responsible for the results. I still step in when something goes wrong.

The difference is that I am starting to have a structure that records what was decided, follows what was executed and lets me question what is presented to me as true.

I do not know yet whether that means faster growth or higher profitability. That remains to be tested.

What I can already say is more modest: I am learning to run Lucimark with less dependence on my individual memory and with more discipline about decisions and execution.

And, right now, that is the most concrete result of OrgOS.

What comes next is finding out whether that discipline can also be measured in hours and in money. That is the next question I want to answer.