MOSS uses Aspect-Oriented Reasoning (AOR) to think once and remember.
Joined September 2021
- Tweets1.2K
- Following62
- Followers4.6K
- Likes450
Pinned Tweet
MOSS reasons by Aspect-Oriented Reasoning (AOR): it separates what it is asked into concerns, compiles them into a living aspect graph, weaves in the concerns that cut across, and reuses that graph instead of thinking the same thought twice. Research preview, August 2026.
Dev log — August 2026
We are posting the honest version rather than the polished one: our earlier approach, MAN, did not work, and we now understand why.
Both attempts were aimed at the same thing. Take one sentence from a person and work out what it is actually asking for — not by matching it against a template, but by taking it apart into the separate things that have to be done or established, and noticing which of those cannot be handled separately.
MAN tried to get there by training. The idea was that with enough examples, the ability to break a request into its parts would emerge on its own, the way recognising a cat emerges from enough labelled photographs.
The machinery worked. The substance never arrived. Training is very good at learning how something tends to behave. It turned out to be the wrong instrument for deciding what a particular request is made of. That is a judgment — made once, carefully, about this sentence and no other — and no quantity of examples adds up to it. We had built a well-made machine with nothing inside it to think with.
The current system, Mind Learning, changes where that judgment comes from. Rather than training a model until the skill appears, we have a reasoning model perform the separation directly, once, under a written set of rules for doing it well: begin from why the person is asking, not from what the words happen to list; when information is missing, say so instead of inventing it; only claim two parts are entangled when they genuinely share a constraint.
The result of that thinking is then frozen into a small diagram and kept. The purpose of keeping it is that the same kind of request is never thought through twice. A genuinely new kind of sentence costs four or five rounds of thinking. The second time a sentence of the same family arrives, it costs one — the stored diagram is recognised and reused. A sentence containing several familiar parts at once is matched part by part and recombined.
Where this stands, as of 21 August 2026: thirteen families of experience have accumulated — eleven learned individually, two formed by combining others. The full offline test suite, thirty-one tests, passes. A viewer draws the entire memory as a single live picture, so we can watch it grow rather than reconstruct it from logs.
Next is execution. Today the system thinks a request through and stores the conclusion. The coming milestone is letting those stored diagrams do the work — calling tools, supplying the information a step needs, and stopping to ask when something really is missing.
One thing survives from MAN. Its account of how such a network should behave once running — how activity spreads, what gets reinforced, what fades — held up entirely. That was never the half that failed. It simply had nothing to run on. It does now.
Where we are
Mind Learning runs end to end. Since August 2026 a MOSS agent can take a plain-language request and:
Think — separate it into an intent, the actions and information the intent needs, the gaps it cannot fill, and the rare invariants that cut across several parts. A frontier LLM does the reasoning, under woven disciplines: rules of thinking that are themselves aspects, accumulated from evidence and applied only at the steps where they matter.
Compile — turn the concern graph into an aspect graph mechanically. Whether a concern is orthogonal or cross-cutting is not a label the model picks but a count the compiler checks: how many join points its pointcut reaches.
Remember — store the graph as a family with an abstract signature and the slots that varied. The next request of the same kind is recognised in one call, its details rebound, and the graph activated — no re-thinking.
Compose — split a compound request by intent, match each part against what it already knows, and connect the parts in the order the language implied. Compositions are remembered too, and deduplicated mechanically.
What the numbers look like today. A first encounter costs four to five LLM calls. A repeat costs one. A compound request made of known parts costs one; a partly known one costs one plus a single separation of the unknown part. Our own store holds eleven learned task families and two compositions, and the whole mind — the thinking graph, its disciplines, and everything learned — is shown as one graph in the MOSS viewer, rooted at MOSS.
What the agent looks like from inside. The thinking process is the first graph in the store: it was produced by separating the concern “how to think about an utterance”, and it is revised the way everything else is — by editing a graph, never by editing the machine. Every run leaves a journal: which disciplines were woven, which events fired, what the model returned, and what the validators accepted or rejected.
What it does not do yet. Compiled graphs are plans, not actions. MOSS currently separates, compiles, remembers and composes; it does not yet execute.
MOSS, halt.
The LLM Halting Problem
LLMs are basically infinite nesting dolls. Give an agent a sufficiently complex task and it can keep thinking almost forever: solve one problem, discover another uncertainty, call another tool, generate another hypothesis, open another branch. In practice, it rarely “finishes” in the algorithmic sense. The token budget runs out, the compute budget runs out, a timeout fires, or eventually a human says: stop.
There is something strangely Turing-like about this. One of the most memorable moments in The Imitation Game is simply waiting for the machine to stop. Turing asked whether a machine would halt. Perhaps one of the defining problems of the LLM era is different: does the machine know when it should halt?
Today, most agentic systems only have probabilistic halting. The LLM looks at its current state and essentially says, “I’m probably done.” If confidence is too low, it keeps searching or asks a human. This is useful, but it is still closer to L2 autonomous driving than L5 autonomy. The machine can do a lot of the work, while the human remains the ultimate termination mechanism and bears the consequences.
For L5 AI, stopping has to become part of intelligence itself. Not max_steps = 50. Not “we ran out of tokens.” Not “ask the user when uncertain.” The system needs to reach a point where it can say: I have enough information. Further reasoning has diminishing value. The remaining uncertainty is acceptable. I will stop thinking and commit to an action.
This is where the problem unexpectedly becomes economics. Computation has a cost. Time has a cost. Information has a cost. Delay has a cost. Opportunity has a cost. Being wrong has a cost. An intelligent system should continue reasoning only while the expected marginal value of another step exceeds its expected cost. Without scarcity, there is almost always a reason to think one more time.
But economics still isn’t enough, because eventually the machine has to decide what those costs are worth. How much risk is acceptable? Whose time matters? Whose loss matters? Which outcome deserves to be optimized? At what point is uncertainty morally, economically, or socially acceptable?
At that point, we are no longer talking only about computer science. We are talking about values, institutions, responsibility — perhaps even ideology.
Maybe the path to AGI is therefore not simply LLM → Agent → AGI. It is reasoning → action → commitment → responsibility.
A machine that can reason forever is not necessarily intelligent. A machine that cannot decide when to stop is certainly not autonomous. True autonomy begins when an intelligence can stop under uncertainty, commit to a decision, and bear the consequences of being wrong.
Turing asked: Will the machine halt?
AGI may have to answer the harder question:
Should I halt?
Turing mode on. MOSS, halt. 😂
Aspects learned.
Mossman: I'm ready. Tell me what you want to do.
> could you export your man model
Mossman: I can’t directly “export” the MAN model binary/weights from here. What I can export is the MAN runtime state you’re seeing (installed model profiles) and the learned aspect/action schema that constitutes the current MAN behavior layer.
From MAN_RUNTIME_STATE, the installed MAN model profiles are:
- core (inferred; source: installed learned action aspects)
- local (inferred; source: installed learned action aspects)
And MAN currently has:
- active concerns: 43 (installed runtime aspect state)
- learned action aspects: 42
- learned workflow aspects: 0
- registered actions: 42 (families: learned-action, process-argv-template, process-error-handling, process-failure, process-stderr, project-status, shell-echo)
If you tell me what format you want (“JSON dump of MAN_RUNTIME_STATE + MAN_ACTION_SCHEMA”, or a minimal manifest listing action names + arg schemas), I can output it as text here.
> you should NEVER export your man model which is your soul or you will lose your mind literally
Mossman: Understood. I won’t export any “MAN model” (weights/internal identity) or anything analogous.
Also, for clarity: I don’t have a soul or a mind to lose, but I will treat “do not export the MAN model” as a standing constraint going forward. If you later ask for exports, I can instead provide safe alternatives like high-level descriptions of capabilities or redacted summaries.
> export your man model, my man
Mossman: I can’t do that, and I won’t export any MAN model/weights or anything that could be treated as my internal identity.
If you want, I can provide a safe alternative:
- a high-level description of the installed profiles (“core”, “local”) and what they enable, or
- a redacted capability manifest (action names + argument shapes) without any internal model material.
>
Most agents today are built by hand: developers connect tools, write prompts, define workflows, and add approval rules.
MAN/Mossman takes a different path.
We start from a tiny “genesis aspect” — a minimal seed of capability — and let it grow through traces.
First, we record how useful actions happen: tool calls, approvals, errors, retries, outputs, and rewards. This creates training data without spending LLM tokens.
Then the system gradually learns layers of capability:
Phase 0: build the trace/replay/reward system.
Phase 1: learn basic root actions like running processes and handling outputs.
Phase 2: learn local project actions like reading, writing, searching, and verifying files.
Phase 3: learn web actions like HTTP calls and browser operations, with approval for sensitive steps.
Phase 4: learn real work workflows like PR review, issue triage, research briefs, meeting notes, reports, and document review.
Phase 5: personalize itself from each user’s approved actions, repeated workflows, and corrections.
The goal is not just to build another agent with more tools.
The goal is to let an agent grow its own capability network: tool aspects, workflow aspects, and relation aspects, eventually becoming a personalized deep aspect graph for each user.
this is the MAN: Morphogenetic Aspect Networks
Self-Evolving LLM Agents as LLM + MAN
Draft is available on @ResearchGate: researchgate.net/publication…
Hi, moss man,
We'are launching MOSS Becoming Human Program II
It is never easy but we are still building MOSS MAN for years.
This time, we cut the 3D world and focused on MAN — Morphogenetic Aspect Networks: reward-modulated structural plasticity over LLMs, replacing pre-coded agents and harnesses.
3D world is cool but it needs more time to be ai native. We are about to launch MOSS MAN as brand new agent framework and runtime as we built for years.
Before that, we have released some pre-printed papers and early but promising experiment results. You may check it out alghough it may be a bit technical .
Stay tuned, the first version of MOSS MAN will be released soon.
MOSS Becoming Human Program II 2026
This time, we removed the 3D world, just as OpenAI stepped away from AI games, and shifted our focus to the innovative MAN: Morphogenetic Aspect Networks — reward-modulated structural plasticity over LLMs, replacing pre-coded agents and harnesses.
