The system, in layers.
AIOS Pro runs on your own machine, inside a real editor. Underneath it: your files, the relationships between them, the composition of each question, and the bounded operations that do the work. Each part has one job and reaches no further than its neighbours.
The stack, exploded
Your files are the foundation, and they are ordinary markdown in folders you chose. Above them sits the relation graph — not a database, but the relationships themselves, declared in a small file beside each document and resolved by search. Above that, composition assembles one package per question.
Outside the reasoning calls themselves, the mechanics are deterministic: declared capsule assembly, reference resolution, bounded file operations, known command dispatch, and rendering from file truth. The model is off to the side, called from exactly one place.
Read it as a slice, not a ladder. No layer is in charge, and none of them is the intelligence — durable files and known commands are the boundaries between them, which is why the security story is structural rather than a policy, and why each part can be reasoned about on its own.
Three stages, one circuit.
A reasoning turn is not one call. It is three blocks of code, each with a narrow job and a declared output schema that becomes the next block's input. One composes the context. One reasons over it in natural language. One judges how the result enters the system.
The first and third are where judgment about context, intent and consequence happens — and those judgments are what trigger further scaffolding, downstream actions, dispatches into other extensions, and the actions offered back to you.
The third stage's output is the first stage's context. The circuit has no entry point and nothing at its centre.
Three stages, one circuit
Writing and editing are not the same act.
Because each stage sees only what its job needs, the reasoning stage can stay pure — it is not composing for a reader while it is still working out what is true. Models rewarded for pleasing a reader filter their best material before it reaches the page: the doubt gets smoothed, the risk goes unmentioned, the gap is quietly filled with something plausible. A great deal of confident wrongness comes from exactly there.
There is no chat here and no audience to satisfy mid-thought, so what the reasoning produces arrives whole. Surfaced doubt, stated uncertainty, integrity checks, flagged risks and named gaps are first-class output rather than things trimmed for tone.
Code carries identity, structure, ordering, validation and operations. Language carries judgment. Neither is asked to do the other's job — and that balance is what makes the rest of it possible.
One turn, and everything it sets off
The straight line is the boring part. What makes the system worth building is everything that leaves it: a pass that decides it needs a wider aperture and re-opens composition. Reasoning that goes around again, at depth, without spawning a file. A record step that finds six other documents declared a dependency, and brings forward the exact places that may now be wrong. What you approve runs as bounded edits.
And the fan on the right — downstream work generated from something you settled, each piece its own bounded pass, inheriting the decision and the standards rather than being told again.
The loop underneath is the one that matters over months: what came back changes what you think, so the next turn begins from further along than the last one.
A system that handles a one-line edit and a quarter of work usually needs different machinery for each — a fast path for small requests, a heavier pipeline for large ones, and a set of rules deciding which is which. Every one of those seams is a place where behaviour diverges and quality becomes unpredictable.
AIOS Pro has one path. The same three movements govern every scale of request: why the work matters, how it should be done, what it produces. A sentence, a document, a plan and a year of work are the same shape at different sizes — so one composition mechanism serves all of them, and the system does not need to know how big your request is before it can reason about it.
It is also why nothing is re-explained when you zoom out. The whole of one level is a single step inside the level above it.
The seed, at three altitudes
The conventional approach to context is accumulation. Keep the conversation, keep the attachments, keep as much as the window allows, and re-send all of it every turn. Everything is present, nothing is ranked, and nothing declares how it should be treated — so a note from three weeks ago carries the same weight as this morning's decision, and a document you attached for reference can be read as an instruction.
The alternative is composition: decide, per question, what should be present, at what grain, in what order, carrying what authority. That is a capsule.
One capsule, composed
The labelling is the one to look at twice. Model prose never becomes a command, a path, or a piece of code — that door was never built, so nothing sent to you in a document can open it. Outside material also arrives labelled as material, so text someone else wrote reads as reference rather than as what you asked for.
The fixed order matters more than it looks. Every region is labelled by its role — guidance, context, available choices, reference, input — so nothing arrives as an undifferentiated pile of text, and reference material is never presented as the task. Because the order is fixed for a recipe, position itself carries meaning.
Most engineers will tell you a self-evolving knowledge system is not possible. Knowledge either sits frozen inside a model's parameters, or scattered across documents nobody maintains. It works here because of how the reasoning is designed: the system reads and writes its own knowledge as ordinary local files, so what it knows can change without anything being retrained.
What it holds is your expertise — the reasoning you apply, the vocabulary you use, your terms and their definitions, the methods behind work you consider good. All of it sits on your machine as files the system knows how to search, retrieve, and compose into context. Nothing is crammed into a model, and nothing leaves the device unless you send it.
It maintains itself rather than drifting. It runs gap analysis against its own context, researches what is missing, and keeps definitions internally consistent as they change — updating as you work, on one machine or across several. The consequence, rather than the goal, is that you no longer need a giant model trained on your data. You need a well-organised one, asked only for reasoning — the one thing it is genuinely better at than code.
Where the knowledge lives
Both sides do the same job. Only one of them lets you see what it knows, change your mind, and keep the result.
Reliability and efficiency are the same decision.
A pass cannot be misled by material it never received — and material it did receive arrives saying what it is. Because the context per turn is small and roughly constant, the system can afford several reasoning passes on a hard question and still cost a fraction of one turn of a conventional stack.
The budget that would have gone on re-reading your history goes on thinking about your question instead.
None of this was designed for procurement, but it answers most of what procurement asks. Local files, a composed context and a written record are not features added for compliance — they are how the system works at all.
It runs where the work lives
Against files on machines and servers you already control. Nothing leaves the device unless you send it.
Nothing to migrate into
Markdown in folders you chose. Stop using AIOS tomorrow and everything it produced is still readable.
An audit trail as a side effect
What was decided, what it was sourced from, who asked — written as the work happens, not assembled for a review.
Cost that does not drift
Context per turn stays small and roughly constant, so a seat in month twelve costs what it did in month one.
Your firm's expertise stops living in private histories.
The reasoning, the vocabulary, the standards and the methods behind work you consider good end up in files the organisation owns — searchable, correctable, and inheritable by whoever picks the work up next. That is the part no model can be bought to replace.
An organisation that can read its own reasoning is a different organisation from one that cannot.