OS for Agent

A system built for agents.

In Kleinia, agents are first-class citizens of the system, just like processes. Your favourite agents and traditional apps get system-level identity, quotas, permissions and context without any modification.

Why

From an ordinary process to a first-class citizen.

To a conventional operating system an agent is just a process: identity, context, permissions and resources are left to each application, so nothing is shared and nothing is managed by the system. ACOS proposed reorganising the operating system around agents, so that the system provides these things directly, as it always has for processes.

In Kleinia, agents no longer have to look after themselves: identity, quotas, permissions, context and observability all come from the system. Agents focus on their tasks and leave the rest to Kleinia.

Every application becomes an agent

Every program gets the same agent shell, and how far it becomes an agent depends on the interfaces it has, never on special-casing an app or asking its authors to change it.

Joins the system
Every app, service and login session becomes a managed agent, with identity, a resource tier and usage accounting.
Shares its abilities
The system generates tools from MIME types, command-line help, D-Bus and MCP, so other agents can find and call what an app can do.
Understands tasks
A general agent on top of those tools lets traditional apps take tasks described in natural language.
Fully native
Apps built for Kleinia ship a manifest and expose all of their abilities.

Zero-modification onboarding

No changes to your apps: Kleinia recognizes and manages them for you, and they gain system-level scheduling, memory, quotas and permission management. Keep using opencode, Claude Code and the rest as usual.

Use them as usual: No code changes and no configuration: start opencode, Claude Code and the rest in a terminal as you always have.
Recognized automatically: When an app makes a model call, Kleinia recognizes it as an agent and gives it its own identity and agent:// address.
Abilities from the start: Scheduling, memory, quotas and permissions take effect at once, and every agent shows up in agenttop.

Unified model gateway

One endpoint for every model call: no juggling keys and credit limits, with model permissions and quotas enforced by the system. Local and cloud models both plug in.

Configure once: Set your keys once; every agent shares one endpoint, with nothing to fill in app by app.
Local and cloud: Compatible with the OpenAI and Anthropic APIs, so local and cloud models can be chosen and swapped freely.
Limits the system keeps: Tokens are metered per agent and limits are enforced by the system, so no agent quietly uses up your credit.

One address space

Everything is an agent, and every agent has its own agent:// address. Apps, system services, even agents on another device can be found and called directly.

One address, straight to the ability: Apps, system services and devices appear as agent:// addresses that agents can find and call directly.
Traditional apps too: The system generates tools from MIME types, command-line help, D-Bus and MCP, so apps never adapted for AI can be called as well.
Beyond this machine: Addresses are not limited to this computer: agents on your phone or a server are found and called the same way.

Context and memory

Context is persisted by the system, so agents carry project conventions and past decisions across sessions. Memory grows like a mind: based on PISA, the system does not just store knowledge but updates, evolves and creates knowledge schemas.

Across sessions: A new session or a new day, and your agents still remember the project’s conventions and earlier decisions.
Grows like a mind: Inspired by Piaget, PISA keeps reorganising knowledge through schema update, evolution and creation.
Kept by the system: Memory is stored and managed by the system, and can be shared with other agents as far as you allow.

Observability

Every task leaves a full execution trace: model calls, tool calls and system actions, step by step, with their time and token use. agenttop shows each agent’s resource use live.

Every step traceable: Model calls, tool calls and system actions are recorded in order, so you can see exactly which step went wrong.
Usage at a glance: Each task’s time and token use are itemised, so costs are always clear.
The whole picture, live: Like htop, agenttop shows each agent’s resource use and current scheduling policy in real time.

More system-level abilities

Tiered permissions: Low-risk actions run automatically, medium-risk ones notify you, and deleting, sending data out or changing the system needs your confirmation. Everything is audited.
Permissions per task: An agent gets only what its task needs, and loses it when the task ends.
Suspend and resume: Long tasks can be suspended to free resources and picked up where they left off.
Scheduled per agent: Foreground agents get low latency and background work gets throughput: resources follow agents, not processes.

Research

arXiv 2024

ACOS

Agent Centric Operating System — a Comprehensive Review and Outlook for Operating System

ACOS, our 2024 survey, was the first to set out the agent-centric operating system systematically, in which the system provides identity, context and permissions to agents: the origin of OS for Agent.

Read the paper ↗

arXiv 2025

PISA

PISA: A Pragmatic Psych-Inspired Unified Memory System for Enhanced AI Agency

PISA, our unified memory system, is inspired by Piaget’s theory of cognitive development: it organises an agent’s knowledge through schema update, evolution and creation.

Read the paper ↗

These capabilities were proposed in ACOS and will arrive in Kleinia over later releases.

Across devices: agent:// reaches your other devices, and tasks run where they run best.
Compute without borders: Heavy work goes to the strongest machine; latency-sensitive work stays close.
Interfaces on demand: Interfaces assemble around what an agent needs and how you work.

The other halfAgent for OSThe operating system, now scheduled by agents.→