What should remain known.
Durable facts, history and knowledge that should survive the current task.
Technically, Gunner is a stateful runtime built on Linux. It coordinates specialized agents, three forms of memory, probabilistic and declarative reasoning, and software tools within one persistent operating environment, working toward a human-defined objective. Okren is its first commercial use.
On the home page, Gunner does a person’s workday at a computer. This is what is running underneath. Gunner operates as a stateful software runtime above the Linux kernel. Linux provides the underlying environment for processes, networking, storage, and computing resources. Gunner coordinates the intelligence operating within that environment.
The runtime maintains the active objective, current state, relevant memory, agent responsibilities, and available tools. It receives information from connected systems, coordinates specialized work, applies probabilistic and declarative reasoning, executes actions through software interfaces, and observes what happens next.
Analogy (restaurant): Linux is the building and the utilities. Gunner is everything that happens inside once the doors open.
A person listens.
Remembers.
Investigates.
Uses different kinds of reasoning.
Asks specialists for help.
Acts.
Watches what happened.
Then carries that experience into what happens next.
Natural language is the interface. The architecture carries the work.
Gunner began as an attempt to do what one person does at a computer, start to finish. That goal led us to build an operating system around the model.
We built Gunner to explore what persistent intelligence needs in order to operate — to understand what is happening, remember what matters, reason, act, observe, and continue.
Palantir’s Ontology provides a shared operational model connecting an organization’s data, relationships, logic and actions.
Gunner keeps the objective, context, memory, reasoning, models, agents and tools coordinated as work continues and the state changes.
The comparison is about architectural roles. These are different systems solving different problems.

One objective can produce many actions. Each result changes the state of the work.
Analogy (restaurant): an order comes in, the kitchen cooks, the plate goes out, and what the diner says shapes the next order.

The world changes between prompts. Gunner keeps the right kind of memory for the right span of work.
Analogy (restaurant): the regulars’ book is what stays known. Tonight’s reservations are what this evening needs. The tickets on the rail are what is happening right now.
Durable facts, history and knowledge that should survive the current task.
The details that matter while an active objective is under way.
Live agents, tools, environment and the current operation.
Example (restaurant): what a system with continuity should get right. It illustrates the idea and is not a deployment.
When the night is over, Maria is still a regular. The temporary state changes.
An old chat transcript tells a new model what was said. An operating system needs to carry more: what the system is trying to do, what it knows, what changed and what should happen next.
Analogy (restaurant): swap the chef and the restaurant is still there — same kitchen, same orders, same regulars.
The objective belongs to the continuing system, rather than to one conversation.
Memory, decisions and observed results remain part of the work as the world changes.
A different model can be coordinated around the existing objective and state, instead of starting from zero.
This is the architectural direction: continuity belongs to the system, not to a particular model. Full portability across arbitrary models remains a capability to prove.
That is how probabilistic AI works. It weighs possibilities and gives you the most likely answer, not a fixed one. For research, language and unclear situations, that is exactly what you want.
A declarative system works the other way. It follows rules.
It reasons from likelihood. It is strong wherever the answer has to be discovered, and a different answer each time is part of how it explores.
Three answers. Useful for exploring. Not what you want from a rule.
It starts from facts that are accepted and rules that are written down, then works out what follows. It does not guess, so the same facts give the same result.
Same facts. Same rule. Same answer.
Gunner gives each kind of intelligence the job it is good at. Probabilistic AI explores and proposes. Rules and logic handle what has to come out the same every time.
Analogy (restaurant): the chef’s taste decides tonight’s special. The oven timer decides when it is done. Nobody argues with the timer.
Curiosity finds the options. Rules keep the answer the same every time.
Each handoff can change what the system understands or asks a tool to do. The objective must still guide the next action.
Analogy (restaurant): the ticket says “no nuts.” The server writes “light on nuts.” The kitchen adds almonds. The intent has to survive every handoff.
Research. Calculate. Investigate. Write software. Watch a source. Test an approach.
The operating system carries the state, memory and coordination around the workers.
Analogy (restaurant): the line cook, the pastry chef and the sommelier each do their own job. The expediter makes sure it arrives as one meal.

The tool returned an error.
The software worked.
The research contradicted the assumption.
The environment moved.
That changed state becomes part of the next decision.
Analogy (restaurant): the dishwasher breaks. The expediter reroutes the plates and the night goes on.
Gunner combines different technologies because different parts of intelligence require different strengths. The innovation is how those pieces work together around the same objective, memory and changing state.
Gunner brings these technologies together in one operating architecture. Linux provides the foundation. The runtime coordinates the other components around the same objective, memory, and changing state.
Analogy (restaurant): a gas range, a walk-in fridge, an oven timer and a ticket printer. Different equipment, one kitchen.
Gunner is Linux-based. Linux provides the underlying environment in which the larger intelligence system operates.
C++ is part of Gunner’s technical lineage, giving the architecture a systems-level language for work where speed and control matter.
Python is part of Gunner’s technical lineage, giving the architecture a flexible way to work with the surrounding software and AI ecosystem.
Used for language, research, ambiguity and situations where the answer cannot be completely known in advance.
Accepted facts, relationships and explicit rules let the system reason consistently where it should not have to guess.
Persistent, session and working memory preserve what should stay known, what matters during the current period, and what is in play right now.

Different technologies do different jobs. Gunner keeps them working as one persistent system.
Crypto trading is where we proved its capability because the environment changes constantly and the consequences are real.
The application was trading. The architecture was the point.
Change software.
Move a machine.
Commit resources.
Place an order.
The question changes when intelligence can make something real.
The more it can do, the more it matters that people stay in charge. Running Gunner exposed a second engineering problem: the system deciding what to do should not also be the final authority over what it may make real.
Persistent Intelligence carries the work forward.
Independent supervision: software that lets a person see every money move before it happens. It runs as separate software inside the customer’s environment and does not require Gunner.
Here is what is documented, what OA describes, and what it keeps private.
Public, dated sources show the industry adding persistent memory, agents, tools and runtime responsibilities around models.
Gunner’s architecture: three memory scopes, probabilistic and declarative reasoning, agents as workers, action, observation and continuation. This is OA’s own description.
Work on Gunner began in 2021. The architecture has run in live environments, including one where its decisions had real consequences.
Private implementation: schemas, retrieval methods, orchestration internals, prompts, security and source code.
No. An agent is a cook at one station: a worker with a job, tools, memory and some ability to keep working. In the analogy, Gunner is the restaurant. Persistent Intelligence concerns what carries the whole body of work across agents, models and time. In OA’s frame, an agent is a worker inside the system.
As an analogy: a restaurant that remembers your name is still not a restaurant that runs a full night. Memory is one responsibility. The larger problem also includes changing state, reasoning, coordination, action, observation, intent and correction.
Frameworks give you ingredients: memory, workflows, tools, controls. in the analogy, Gunner is the restaurant built from them, one system where everything works together on the same job. Two restaurants can use the same ingredients and still be completely different restaurants.
Both terms describe different aspects of Gunner. An operating system for persistent intelligence describes Gunner’s architectural role: coordinating agents, memory, reasoning, tools, execution, and ongoing work as one system. A runtime describes the software that actually carries out those responsibilities. Technically, Gunner is a stateful runtime built on Linux. Linux provides the underlying operating-system foundation. Gunner provides the intelligence operating environment above it. Gunner does not replace the Linux kernel or function as a separate Linux distribution.
Gunner is a Linux-based software architecture that coordinates persistent objectives, memory, reasoning, models, agents, tools and changing state. “Operating system” describes that coordinating responsibility. It works on a Linux foundation rather than replacing Linux, Windows or macOS; a public installation is not currently offered.
Analogy: swap the chef and the restaurant is still there. In real terms, Gunner is designed so the work, its state and its knowledge live in the system, not in one model.
Gunner operates. Okren supervises. In real terms, Gunner is OA’s architecture for running AI agents, and Okren is separate software, inside a customer’s environment, that lets a person check every money move before it happens. It does not need a Gunner install. Okren came second, as Gunner’s commercial proof, when intelligent action became consequential. See the product.
Yes. Okren runs as separate software and does not require Gunner. It supervises any AI, including Gunner’s own money moves.
The same architecture could become many things. Here are three we looked at, and why each comes second.
Swipe or tap a use to change the example
The instant check before the money moves, like every card payment.
Okren is where this research goes to work: independent supervision for AI that moves money, live with its first paying customer.
Gunner is OA’s architecture. Okren is the first product built from it, put to a real job with a real customer need. It is separate software and runs on its own.
Technical conversations go deeper into runtime, system diagrams and the evidence behind the architecture.