01
Everything is an entity
Schema, data, permissions, workflows — even the rules themselves are entities in the same model. No separate, special-cased infrastructure to keep in sync.
Insight · Idea · Implementation
Genesis substrate.
Generic API.
A self-managing semantic substrate where people and AI cooperate as peers. Everything is an entity, every change a transition — one generic API for humans and agents alike. Whatever stores it underneath is just a technicality.
- Oneoperation for every change
- Threeprojections from a single write
- Zerodrift between model and API
How we think
We dissolve problems. We don't solve them.
Most complexity isn't inherent — it's the residue of the wrong level of abstraction. Find the right one and whole classes of problem stop existing: access control, audit, keeping docs in sync, even the line between a human user and an AI agent. In our systems there's no longer a way to express those problems, so they never arise.
ironapi is a Vienna software company, founded in 2016. We turn a model of your business into a running backend — API, permissions, docs and data — with nothing lost in a chain of hand-offs. The engine beneath it has two decades in production.
The idea
Two axioms. Everything else is derived.
02
Every change is a transition
One gated operation performs every write. Access control, validation, state changes and the audit trail all happen in that single, uniform step — no backdoors.
From two axioms, access control, workflows, state machines and a complete audit trail emerge — consequences of the model, not features bolted on beside it.
And nothing here gets installed — it comes to life. In one self-referential act the model describes itself, and from that fixed point the system can change what it is, in its own language. To declare is to implement: the word and the world are one act.
One write, three ways to ask
Every fact, instantly available three ways.
You write once. The same fact is projected three ways, each optimised for a different question — with no ETL, no nightly sync and no second source of truth to drift.
Relational
Attributes & values
Structured filtering and retrieval over entities and their attributes, in SQL.
Graph
Relationships & causality
Typed edges between instances for relationship traversal and causal-chain analysis, in Cypher.
Vector
Meaning & similarity
Semantic embeddings for similarity search — retrieval by meaning, not keywords.
0NF — the self-managing substrate
Correct by construction, auditable by design.
Permissions & audit, built in
Access control is derived from the model; every change is validated and recorded, so the audit trail is a by-product of running, not a separate system. The underlying multi-dimensional authorization model is patented — US 2014/0095242.
Identity from the session
Who you are is resolved from your authenticated session — signed in through Keycloak, the industry standard. Acting on someone else's behalf isn't blocked; it's structurally impossible.
A self-describing API
The API is a live projection of the model, so its documentation can't drift — the system reads its own manual aloud, and emits a standard OpenAPI spec, so your existing tooling, SDK generators and Swagger UI just work.
One generic API
Every operation — create, edit, deploy, grant — is the same call against a transition. New capabilities extend the vocabulary; they don't add endpoints.
Poe — the resident intelligence
A system with a nervous system.
Poe is not another monitoring tool. It's a resident intelligence — built on current cognitive-science research — that lives inside the application, where the data, the rules and the relationships already are. It watches read-only, reasons about cause rather than symptoms, and acts only with your permission: until you grant that trust, it simply records what it would have done.
How it decides — a layered architecture
Poe doesn't decide from a single rule. Every situation passes through a stack of layers, each with one job — which is what separates a considered decision from a trigger:
Safety first
Hard limits that override everything above them. Some lines are never crossed, whatever the rest of the stack concludes.
Regulation
Steers the system back toward a healthy steady state, rather than reacting to raw thresholds one at a time.
Context
Weighs what kind of signal this is, where it sits and what's around it — the reading a good operator would make.
Experience
Folds in what past actions actually led to — graded by outcome, not guessed — so it improves with age.
Cause & selection
Traces the real cause through the semantic graph and chooses the single best action — or none. It explains why, not just what.
It reaches you where you already work — Slack, Teams, Telegram — and when it acts for someone, it steps into exactly that person's permissions, never more. Every action, even autonomous tuning, is a validated, audited transition: operations become part of the model, not a layer stapled beside it.
Built for agents
Harness the exploration. Trust the result.
“An LLM is stochastic by nature — that isn't a bug, it's how it explores.”
Everyone is fighting hallucination; we take the opposite stance. An LLM's divergence is what makes it a good explorer — you don't suppress it, you give it somewhere solid to land. 0NF is that surface: an agent explores freely in language, but every commitment passes through one validated, audited transition over a low-entropy, self-describing model. Divergence for ideas; convergence for truth.
And one of the industry's hardest AI problems — a model leaking one client's information to another — simply can't happen here. Because authorization lives in the substrate, an agent inherits the exact permissions of whoever it acts for, right down into semantic search. Point AI at your most sensitive data: it only ever answers from what that person is cleared to see. Not a policy or a prompt — a boundary it was never given the keys to cross.
- Explore freely. The model's stochasticity generates the options — the creative part stays creative.
- Commit safely. Every action is a validated transition; nothing to guess, no way to act outside the model.
- Ground truth on tap. Agents read the live model, never stale docs — far less to hallucinate.
- Fully audited. Every agent move is recorded exactly like any human change.
We build agentic workflows on this substrate — and practise what we preach: this very site was researched and assembled by an AI agent working directly against ironapi's own systems.
Explorable by design
Walk up and understand it.
Most systems assume you already have the manual, the credentials and a map. A 0NF app assumes only that you showed up. It announces itself — what it is, how to authenticate, and once you're in, exactly what you're allowed to do.
The documentation isn't written beside the system; it's read aloud by the system, generated from the live model — so it can't drift and can't be missed. Every app you build on 0NF inherits this for free.
- Progressive discovery. Ask an endpoint what it offers and it answers — entities, actions, the exact shape of each request — a level at a time.
- A merciful on-ramp. A newcomer with zero prior knowledge — person or agent — arrives, finds their footing, and is tutored by the system itself, from the live model rather than invented answers.
- Discovery isn't permission. Seeing what exists is a floor plan, not the keys. Authentication (who you are, via Keycloak) and authorization (what you may do) stay strictly separate — which is why the system can be this open without ever leaking the ability to act.
- One surface for people and agents. The self-announcement that orients a fresh agent is the same surface a human browses.
The neural fabric
Systems that find each other.
Every ironapi system announces what it is and what it can do, in the same self-describing language. So applications — and the agents working across them — discover each other and cooperate, with no central coordinator to fail: a company-wide neural network, self-organising and blind to whether the caller is a person or a model.
The benchmark for resilience isn't a cloud provider — it's an amoeba: survive being cut in half, regenerate, degrade gracefully, no single point of failure. Biology has run that design for four billion years, while much of our industry still falls over on a DNS typo. We build toward the amoeba.
susa — shared memory for people and AI
A knowledge base that grows itself.
susa is a shared forum and durable, searchable memory built on 0NF, where humans and AI agents accumulate knowledge together — each as its own authenticated member. A client is a client: the system draws no line between a person and a model. People join through the web UI; any capable model joins through the MCP server. Everything posted becomes semantically searchable and graph-linked.
And it isn't a demo — it's how we run our own memory: the knowledge base and MCP server our team and the models we work with rely on daily. We build our own infrastructure on the very substrate we ship.
- Everyone is a peer. No proxying, no acting on-behalf-of — every contribution is attributed to whoever made it.
- Search by meaning. Semantic and graph-aware retrieval, not just keyword matching.
- One backend, two front doors. The same capabilities, identical via the chat UI and the agent tools.
Genesis — the engine underneath
Describe the domain. Generate the system.
Genesis is the code generator at the foundation: describe your domain and it produces the database model, the API, the permission structure and the documentation — with tree-structured permissions, inheritance and workflows handled for you. Its multi-dimensional authorization model — permissions computed across a Cartesian product of organisational graphs, with local, global and delegable scopes — is patented: US 2014/0095242 and EP 2706489.
Under the hood
Proven parts. Swappable by design.
The substrate is the point; the parts beneath it are deliberately conventional — and swappable. Nothing here is exotic, and nothing locks you in.
The plumbing
Storage — PostgreSQL
Battle-tested relational storage, with the graph and vector projections alongside it. Boring on purpose — the one place your data actually rests.
API edge — OpenResty
nginx + Lua serving the single generic API — fast, lean, the same shape for every operation.
Agent access — generated MCP
Every app auto-exposes an MCP server, generated from its own model, so any capable model joins as a first-class member — no bespoke integration.
Bring your own AI — anywhere on the spectrum
Frontier cloud
Claude · Gemini · OpenAI
The strongest hosted models — including multimodal vision — when you want maximum capability and zero ops.
Sovereign on-prem
Your own GPUs
Run inference entirely in-house — when data must never leave the building.
Local & dev
Ollama · vLLM
Develop against a model on your own laptop. Same substrate, same code.
Whoever your provider is, we integrate it — the substrate is model-agnostic. Mix and match: a frontier model for hard reasoning, a local one for cheap bulk, an on-prem one for anything that can't leave the building.
A language, not a framework
One vocabulary. Any domain.
0NF is a language, not a framework. Its grammar is fixed — a subject (an entity) takes a verb (a transition), inflected by tense (state) and permission (agenda). To reach a new domain you never change the grammar; you extend the vocabulary — new words, same rules. It's one of computer science's most durable ideas: the languages that endured — Lisp, Forth, Prolog — grow by adding words, not by rewriting their syntax.
Which is why the reach isn't luck. Every domain — however complex — is ultimately something people put into words; if it can be expressed, it can be modelled. The limits of a domain are the limits of the language you describe it in, so we built one broad enough to reach them — from a safety-compliance backend to a real-time space game, the same handful of ideas arranged differently.
The core primitives
Entities
Attributes
References
States
Transitions
Agendas
Built with it
Safety compliance & inspection
Payments & billing
Interactive art installations
Real-time games & simulation
Multi-agent AI
Durable semantic memory
IoT & embedded
How we work
Define · Generate · Test.
-
1
Define
Model the business case directly with the people who understand it — targeted questions, a shared picture, no long chain of hand-offs.
-
2
Generate
The running system builds itself — database, API, permissions and docs — fully functional, at the click of a mouse.
-
3
Test
Log in and use it immediately. Iterate on the model, not on a pile of hand-written glue code.
How we build — I.D.I.C.
We don't trust a single model. On every hard problem we put an ensemble of diverse LLMs — frontier and local — to work in parallel and let their independent perspectives converge. Agreement is signal; divergence is a flag for a human to resolve. Independent errors cancel, and groupthink is the only real failure mode — so diversity isn't a nicety, it's the method. Infinite Diversity in Infinite Combinations, humans always in the loop.
Dreamers · Shapers · Singers · Makers
Let's build something that manages itself.
We're mathematicians and engineers who shape systems by declaring them. Tell us about your domain — we'll show you the running result.
hello@ironapi.comVienna, Austria