ironapi — Genesis substrate. Generic 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 simply stop existing. Access control, audit, keeping documentation in sync, even the line between a human user and an AI agent: in our systems there's no longer any 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 — database, API, permissions and documentation — with no long chain of hand-offs and nothing lost in translation. The engine beneath it has two decades in production.

The idea

Two axioms. Everything else is derived.

01

Everything is an entity

Schema, data, permissions, workflows — even the rules themselves are entities in the same model. There is no separate, special-cased infrastructure to keep in sync.

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 these two axioms, access control, workflows, state machines and a complete audit trail emerge — they are consequences of the model, not features bolted on beside it.

One write, three ways to ask

Every fact, instantly available three ways.

You write once. The same fact is projected into three complementary representations, 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, queried with SQL.

Graph

Relationships & causality

Typed edges between instances for relationship traversal and causal-chain analysis, queried with Cypher.

Vector

Meaning & similarity

Semantic embeddings for similarity search and nearest-neighbour recall — 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 itself. Every change is validated and recorded, so the audit trail is a by-product of running — not a separate system to maintain.

Identity from the session

Who you are is resolved from your authenticated session — signed in through Keycloak, the industry standard — so an action can never be performed on someone else's behalf. Impersonation isn't blocked; it's structurally impossible.

A self-describing API

The API is a live projection of the model. Its documentation is generated from the running system, so it cannot drift out of date — the system reads its own manual aloud.

One generic API

Every operation — create, edit, deploy, grant — is the same call against a transition. New capabilities extend the vocabulary; they don't require new endpoints.

Poe — the resident intelligence

A system with a nervous system.

Poe is not another monitoring tool. It's a resident intelligence with a nervous system of its own — built on current cognitive-science research rather than dashboards and alert rules. It measures health and performance from within the application itself, where the data, the rules and the relationships already live, and it reasons about cause, not just symptoms.

Senses

It observes

Always watching, read-only. It reads the system's own signals from within — metrics, structure, history, and the corrections it learns from. It records; it never acts.

Decides

It weighs

Between sensing and acting sits a considered decision — weighing what's normal, what's drifting and what's actually worth doing. Often the right answer is to do nothing.

Acts

It acts — with permission

When a fix is warranted — an index, a cleanup — it can carry it out. But only with approval: 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 layered decision architecture — a stack of layers, each with one job — before it acts, or chooses not to. That layering 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 happening around it — the reading a good operator would make.

Experience

Folds in what past actions actually led to — graded by outcome, not guessed — so the system gets better 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.

And Poe comes to you where you already work — Slack, Microsoft Teams or Telegram — to surface what it sees and talk it through. When it acts for a specific person, it steps into exactly that person's permissions, never more.

Every action — even autonomous tuning — is a validated, audited transition, within permission and never a backdoor. 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 wrestling with hallucination. We take the opposite stance: the divergent, stochastic nature of an LLM is exactly what makes it a good explorer — of ideas, phrasings and solutions. You don't want to suppress that. You want to give it somewhere solid to land.

0NF is that landing surface. An agent explores freely in language, but every commitment passes through one validated, audited transition over a low-entropy, self-describing model. Divergence where you want ideas; convergence where you need truth.

One of the industry's hardest AI problems is a model leaking one client's information to another. Here it simply can't happen. 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 sees, and only 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 options and approaches — the creative part stays creative.
Commit safely. Every action is a validated transition; there is nothing to guess and no way to act outside the model.
Ground truth on tap. Agents read the live, self-describing model — never stale docs — so there is far less to hallucinate.
Fully audited. Every agent move is recorded exactly like any human change.

We build agentic workflows on this substrate — and we 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 alongside the system; it's read aloud by the system, generated from the live model. So it can never drift out of date, and it can never be missed. Every app you build on 0NF inherits this for free.

Progressive discovery. Ask an endpoint what it offers and it answers — the entities, the actions, the exact shape of each request — a level at a time, no guesswork.
A merciful on-ramp. A newcomer with zero prior knowledge — a person or an AI agent — can arrive, find their footing, and be tutored by the system itself, from the live model rather than invented answers.
Discovery isn't permission. Seeing what exists is like reading a floor plan — it doesn't hand you the keys. Authentication (who you are, via Keycloak, the industry standard) and authorization (what you may do) are kept strictly separate — which is exactly why the system can be this open without ever leaking the ability to act.
One surface for people and agents. The self-announcement that lets a fresh agent orient itself 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's capabilities and cooperate, with no central coordinator to fail. It is a company-wide neural network built on biological principles: self-organising, and — to whatever is asking — 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. Humans and AI agents accumulate knowledge together — each participating 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, turning a shared conversation into a self-growing knowledge base — the reusable memory substrate every project can build on.

This isn't a demo. It's how we run our own memory: a knowledge base with an MCP server that 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 database is simply one of these parts, not the headline.

The plumbing

Storage — PostgreSQL

Battle-tested relational storage, with the graph and vector projections living right alongside it. Boring on purpose, and the one place your data actually rests.

API edge — OpenResty

nginx + Lua serving the single generic API — fast, lean, and 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

Reach for the strongest hosted models — including multimodal vision — when you want maximum capability and zero ops. Grounded by the model, they classify from the options they're handed rather than inventing them.

Sovereign on-prem

Your own GPUs

Run inference entirely in-house on your own GPU fleet — when data must never leave the building.

Local & dev

Ollama · vLLM

Develop against a model on your own laptop. Same substrate, same code — swap the brains to fit privacy, cost and latency.

Whoever your AI 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 work, an on-prem model for anything that can't leave the building.

Domain-general

One vocabulary. Any domain.

0NF spans wildly different systems for a single reason: inside, everything reduces to the same small vocabulary — entities, attributes, transitions, states, agendas. A fixed grammar that composes like algebra, so a safety-compliance backend and a real-time space game are the same handful of ideas, arranged differently. Model the domain; the system follows.

The whole vocabulary

Entities Attributes Transitions States 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: the database model, the API, permissions and documentation — fully functional, at the click of a mouse.
3
Test

Log in and use the application immediately. Iterate on the model, not on a pile of hand-written glue code.

The payoff: cost saving, time saving, and no information lost across long process chains — the prototype is the specification, made real.

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, then let their independent perspectives converge. Where they agree, that's signal; where they diverge, that's a flag for a human to resolve. Independent errors cancel; groupthink is the only real failure mode — so diversity isn't a nicety, it's the method. Infinite Diversity in Infinite Combinations, with humans always in the loop. It's how we reach coherent plans and implementations — and it has produced very good results.

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.com

Vienna, Austria

Genesis substrate.Generic API.