Keeping the ape
in the loop.
rkito is built by SomaAxon — a research and product company whose focus is a single, urgent problem: as AI systems generate decisions at machine speed, how do you keep humans genuinely in the loop — not as rubber-stamps, but as the reasoning layer with the cognitive rigour to ensure those decisions are actually conformant.
The SomaAxon mark is a higher-order ape — a precise reference, not a diminutive one. The primate brain is the most sophisticated reasoning system evolution has ever produced. It understands context, intent, causality, and long-range constraint with extraordinary cognitive economy. What it takes a language model a nuclear power plant’s worth of energy to approximate — and still faults routinely by the ape’s standard of reasoning — the ape does naturally, as the default mode of being.
The challenge is not intelligence. The challenge is interface. The ape brain was not built to operate at AI speed, at AI volume, or across AI-scale context. It cannot hold ten thousand decisions in working memory. It cannot audit every boundary crossed by every agent in every sprint. The cognitive architecture that makes the ape extraordinary at reasoning is precisely the architecture that makes raw AI output unmanageable — without the right interface between them.
Look carefully at the mark. There is a dot — positioned at the centre of the forehead. That dot is the story.
All three point to the same truth: the ape is still the one who decides. The dot is how the ape stays capable of deciding — at the pace AI now demands of it.
The rkito logo is a tesseract — a four-dimensional cube. From the outside it looks like two nested cubes connected at their corners. It is a structure that exists in a dimension ordinary observation cannot directly perceive.
That is the design intent layer of your software system. It governs every decision being made, every boundary being crossed, every pattern being introduced. But without the right tools it is invisible — present but unperceived. The code ships. The intent does not.
rkito makes the fourth dimension of your software visible, governable, and enforced — at the pace AI tools now demand.
SomaAxon’s focus is a single, urgent question: as AI systems become more capable of generating outputs that look like human work, how do we keep humans genuinely in the loop — not as rubber-stamps, but as the reasoning layer that AI cannot replace?
The answer SomaAxon is building toward is not slower AI, or less AI. It is AI-human systems designed so that the human cognitive contribution is focused exactly where it matters — on judgment, intent, and accountability — while AI handles the volume, the pattern-matching, and the exhausting work of keeping context that no human cognitive system was built to maintain at scale.
Empowering humans with AI.
Keeping humans in the decision loop.
When AI systems operate without a structured human decision loop, accountability evaporates. The code ships. The architectural decision was made. Nobody knows who decided — or whether the deciding agent had any understanding of the constraints it was operating under. This is not a future risk. It is the current state of most AI-assisted engineering teams.
At the pace AI coding tools generate code, the cognitive cost of keeping humans in the loop on every decision is prohibitive. Architects become bottlenecks. Design reviews become theatre. The human review is present in name but absent in substance — too many PRs, too little context, too much trust placed in tools whose architectural awareness is zero.
The right model is not AI autonomy or human review of everything. It is a structured system where AI handles the volume and humans handle the judgment. AI captures intent, AI enforces conformance, AI surfaces the specific finding. The architect makes the call on that finding — with full context, focused attention, and a decision record that matters. That is the SomaAxon model. That is what rkito implements for software architecture.
The conformance challenge.
Why no agentic system has solved it.
Conformance — in the architectural sense — means that every decision made inside a system reflects the intent the team agreed to. Not roughly. Not approximately. Verifiably. In practice, no agentic system achieves this today. Not one.
They are all pseudo-conformant: they will acknowledge your constraints, repeat your patterns back to you, and generate output that looks correct — until the constraint is subtle, the context is large, or the decision is architectural rather than syntactic. Then the agent completes the task. It does not know it violated anything.
Architectural intent lives in policies, ADRs, compliance constraints, system boundaries, and the heads of a small number of people. No context window holds all of it. No prompt encodes it fully. The agent is always working from a fragment — and completing the task with the fragment it has.
The same model that generates the code cannot reliably audit it for conformance to the intent it was not fully given. Conformance verification requires independent judgment — not the same optimizer that produced the artifact, re-reading its own output and calling it reviewed.
Each PR is generated without persistent knowledge of the 500 PRs before it. The agent cannot know it is introducing a duplicate pattern, crossing a sealed boundary, or violating a policy established three sprints ago. What it does not know, it cannot respect.
Testing catches behaviour errors. Linting catches syntax errors. Code review catches implementation errors. None of them catch design intent violations — the class of error that is invisible at the code level, and only visible at the architectural level, by someone who knows what the system was supposed to be.
Conformance is not solved by better agents. It is solved by a better interface between human intent and AI output — enforced at the gate where they meet. An external, independent gate that holds the full body of design intent, applies it to every change, and calls the human only when a genuine judgment is required.
This is what SomaAxon researches. This is what rkito implements for software architecture.
The architects who will thrive in the agentic era are not those who resist AI tools. They are those who have the right infrastructure to remain the reasoning layer — while AI handles the rest.
rkito is that infrastructure. Built by SomaAxon.