KleiniaarXiv:2411.177102024-11 · cs.OS
ACOS
Foundational
The architecture of Kleinia itself — agent abstraction, ACI, system-service agents and agent-facing OS services.
Since 0.1 AloeDefaultPaper ↗
Agent for OS, OS for Agent
● Kleinia 0.1 · Technology previewThe first Linux distribution that is agentic from the kernel up. Agents take part in scheduling and running the system, and the system gives every agent identity, permissions and context.
Agent for OS, OS for Agent
An operating system that works like an agent, agents that run like an operating system.
Kleinia brings agents and the operating system together in both directions: the system is built for agents, and agents work for the system. Each is the condition for the other, like the inside and outside of a Klein bottle, which turn out to be one surface.
Agent for OS
Agents drive the system
Scheduling is handed to agents: they understand what you are doing and pick the right policy for every moment, so the system feels better the more you use it.
More about Agent for OS →OS for Agent
The system carries its agents
Every app becomes an agent and gets identity, memory, quotas and permissions from the system, so it runs more smoothly and more safely.
More about OS for Agent →Two sides of one whole.
Agent for OS
The operating system, now scheduled by agents.
Kleinia brings the adaptability of agents to resource scheduling. It understands not just the workload but what you and the system need, and switches scheduling policies as needs change.
Fixed policies cannot keep up with changing workloads.
A conventional operating system fixes its scheduling policies at build time. One policy has to serve interactive work, builds and local inference alike, and can only compromise: when the background gets busy, the foreground starts to stutter. ACOS proposed making agents part of the operating system, so that they understand the task and make decisions for the system.
Before
One policy for every workload
Once a build starts in the background, typing in the foreground stutters.
In Kleinia
Policies follow the load
The build carries on in the background, and typing stays smooth.
Adaptive scheduling
The resource agent reads the character of each workload, picks the best CPU, I/O and page cache policies for it, and switches them in real time as the load changes.
- Policies that follow the load
- LAPS recognizes the character of the current load in real time and switches between scheduling policies.
- Intelligence decoupled from real time
- Agents recognize the workload and decide when to switch; only deterministic policies run in the kernel, so performance never costs safety or overhead.
8.91%
average performance gain over EEVDF, the Linux default scheduler
91.7%
lower response latency at most, in latency-sensitive tasks
An extensible scheduling substrate
Scheduling policies for every resource run in the kernel as pluggable modules, checked by the kernel before they load. Policies load and switch at runtime without rebuilding the kernel; if one misbehaves, the system falls back to the default.
Self-evolving
Faced with a workload it has not seen, the system analyses it and updates its scheduling model in the background, without disturbing the foreground.
Shared experience
Scheduling experience gathered on one device can be shared with other devices in the community, so new machines adapt faster.
OS for Agent · Anything, Anywhere, All as Agent
Anything, anywhere, all as agent.
Unix made the file the one abstraction for every resource. Kleinia makes the agent the basic unit of the system: applications, services, login sessions and system components all exist as agents, with one kind of identity, one way to describe what they can do, and one way to call them.
PDF
File
thesis-final.pdf
Fileagent
thesis-final.pdf
agent://file/thesis-final.pdf
App
Terminal
Appagent
Terminal
agent://app/terminal
Kernel
sched_ext
Kernelagent
sched_ext
agent://kernel/sched_ext
Agent Communication Interface
Device
Your phone
Deviceagent
Your phone
agent://device/your-phone
22
Web
Calendar API
22
Webagent
Calendar API
agent://web/calendar-api
Sensor
Ambient light
Sensoragent
Ambient light
agent://sensor/ambient-light
01Managed from launch
Every program becomes a managed agent with its own identity and resource quota the moment it starts, without any change to the program. All agents appear together under /agent.
02One address space
Every agent has an agent:// address. On this machine or another device, agents can discover and call one another.
03Collaboration by default
Applications never adapted for AI can still be called by other agents, through generic interfaces the system generates for them.
Everything as an agent means your agent can put the whole computer to work: any app, service or device can be found, called and combined by it, even ones never adapted for AI.
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.
From an ordinary process to a first-class citizen.
To a conventional operating system an agent is just a process: keys, memory and permissions 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.
Before
Every app for itself
Each app keeps its own keys, memory and permissions, and they cannot work together.
In Kleinia
Carried by the system
The system provides identity, models, memory and permissions, and agents call each other by address.
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.
Unified model gateway
One endpoint for every model call: no juggling keys and credit limits, with model permissions and quotas enforced by the system.
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.
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.
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.
Born from research
Built by the team that proposed it.
In 2024, our survey ACOS was the first to set out the agent-centric operating system systematically. Kleinia is the first distribution built on that architecture. Born from research, it brings the frontier of operating systems and agents to your desktop.
arXiv:2511.116282025-11 · cs.DC
LAPS
In Kleinia
Powers the Compute Scheduler Agent: the desktop picks the right scheduler for what you are doing, live.
arXiv:2510.159662025-10 · cs.AI
PISA
In Kleinia
Powers the Knowledge & Memory Agent: long-term, organised memory shared safely between agents.
IntegratingPaper ↗
Solid foundation
Built on Fedora. Atomic updates, instant rollback.
$
sudo bootc switch ghcr.io/kleinia-os/kleinia:latest01
Fedora at the core
A fresh upstream kernel, SELinux and Fedora packages, compatible with the development tools and workflows you already use.
02
Atomic updates
The system updates as a whole image: an update either takes full effect or leaves everything as it was. Rolling back takes one reboot.
03
Flatpak apps
Thousands of apps from Flathub, each running in a sandbox isolated from the system.
Get started with Kleinia 0.1
Technology preview. Free and open source, for x86_64.