A cognitive operating system for machine intelligence.

The graph is the authoritative representation. Everything else — search indexes, embeddings, caches, summaries, model inputs, projections — is derived from it.

Intelligence is not one model answering one prompt.

Real cognition involves continuously combining perception, memory, reasoning, state, goals, tools, actions, and feedback.

IQ turns those operations into a runtime.

Models can interpret. Queries can retrieve and derive. Rules can constrain. State machines can coordinate. Capabilities can act. Events can propagate change.

IQ provides the machinery that connects them.

Different cognitive operations shouldn't require completely different systems.

IQ provides a common execution model for:

• symbolic reasoning
• semantic search
• graph queries
• deterministic functions
• property paths
• state machines
• event processing
• business logic (WASM)
• SQL virtualisation
• neural inference
• ONNX model zoos
• external APIs, MCPs, CLIs and more

These aren't isolated features.

They are executable semantics in the same runtime.

A useful cognitive system cannot treat every operation as a fresh request.

It has to know:

what is happening
what happened before
what it is doing
what it is waiting for
what it can do
what it cannot do
what changed
and what should happen next

IQ makes state computational.

State can drive transitions. Transitions can produce actions. Actions can change state. Events can trigger new computation.

Cognition becomes an executing process, not a sequence of prompts.

Complex intelligence is inherently concurrent.

Queries run while observations arrive. Agents reason while workflows execute. Models process requests while resources change. Events trigger new work while previous work is still running.

IQ provides the control plane for this activity.

It can coordinate:

events → queries → reasoning → capabilities → actions → state

without forcing every component to invent its own orchestration model.

In ordinary knowledge systems, data describes what something means.

In IQ, semantics can also determine what happens.

A predicate may invoke a pure function, evaluate a query, traverse a property path, execute a rule, evaluate a state machine, business logic, invoke a model, or cross an external capability boundary.

This means the representation is not merely descriptive.

It can drive computation.

LLMs and other neural models are not the operating system.

They are capabilities within it.

IQ can route work to models, provide the relevant context, manage model-facing representations, incorporate results back into the cognitive state, and continue computation from there.

The model performs inference.

IQ determines where that inference fits in the larger computation.

Cognition happens on real machines with finite resources.

Compute. Memory. Storage. Models. Queues. Nodes. Latency. Concurrency.

IQ can represent these constraints alongside the work being performed.

That makes dynamic resource allocation possible: more compute for urgent work, less for background work, move execution when capacity changes, defer expensive operations, select another model, change priorities.

The runtime can reason about the conditions under which it is operating.

This is where the strange loop becomes useful.

IQ can model not only the workload, but the runtime executing it.

Its own state, resources, activity, capabilities, constraints, and observations can become inputs to computation.

That creates a closed loop:

observe → reason → act → observe → adapt

The runtime can participate in its own control loop.

The important shift is not that IQ contains more components.

It is that those components share a computational substrate.

Memory can affect reasoning. Reasoning can trigger actions. Actions can change state. State can trigger workflows. Workflows can invoke models. Models can produce new observations. Observations can change the system's understanding.

Everything can participate in the same loop.

IQ is not a database.

It is not a vector store.

It is not RAG.

It is not an agent framework.

It is not an LLM runtime.

It what they all want to be when they grow up .

A runtime where representation, reasoning, state, memory, models, capabilities, events, and execution can operate as one system.

Governed intelligence is like kubernetes for thinking machines.