ArchieOS

Logo
Ad 1
Ad 2
Ad 3
Sphere

Inspiration

Our inspiration came from previous projects, J.A.R.V.I.S., science fiction, superheroes, and our shared obsession with technology.

We've always liked the idea of having a computer that actually understands what you're doing. AI has improved enormously, but operating systems haven't really caught up. You still spend a lot of time switching between applications, managing information, and doing repetitive tasks.

ArchieOS started from our curiosity about what an operating system designed specifically for AI could look like.

What it does

ArchieOS is an experimental AI-native operating system designed to make everyday computing more intuitive, efficient, and contextual.

Built around Arch Linux, with ArchISO and WSL2 environments, it combines AI reasoning, visual perception, persistent memory, system-level permissions, voice interaction, and task execution.

Its architecture includes several specialized components:

Archie: Central AI orchestrator.
Cerebra: Attention, context, and task coordination.
IRIS: Visual perception and GUI interaction.
Sentry: System and device control.
Wanda: Contextual intelligence and memory.
Vault: Privacy and information management.
Forge: Applications and development tools.
Nova: Simulation and evaluation.
Watcher: Research and information gathering.
Cortex: Native cognitive processing and contextual analysis.

The system supports natural voice conversations using NVIDIA Nemotron speech recognition, local speech synthesis, and AI reasoning through NVIDIA Nemotron on Nebius Token Factory or locally hosted models.

Archie Stage provides controlled interaction with applications through a Wayland compositor. Actions pass through authorization and permission checks before execution.

The Observatory is our native visual environment, featuring an interactive system graph, applications, and a geospatial world view.

We're also developing LNCM, our experimental neural architecture focused on efficient, specialized AI inference.

Our goal is to make computing more natural while keeping users in control of their systems and information.

How we built it

We're a three-person team, and we all co-founded ArchieOS together:

Santiago Rearte (Sheriff)
Xavier Cottier (Xavi)
Nelson Vera (Penta) — Lead Developer & Systems Architect

We have pretty different personalities, ideas, and approaches to solving problems, which made working together both interesting and occasionally chaotic.

We started with an existing systems foundation and significantly expanded it throughout the hackathon, developing new integrations, AI capabilities, and native components.

Most of our control plane is written in Rust, with C++23 for Cortex, Sentry, and native visual components. We use Python for AI training and supporting tools, while our interface uses Qt Quick 3D and QML.

Our architecture uses PostgreSQL, TimescaleDB, and pgvector for persistent state and memory.

For AI, we integrated NVIDIA Nemotron through Nebius Token Factory, NVIDIA NeMo-Speech.cpp for speech recognition, and local inference through llama.cpp.

We also worked extensively on two specialized AI systems: IRIS, our visual intelligence model, and Wanda, our contextual intelligence system.

A considerable amount of work went into optimizing inference, developing LNCM, designing permission boundaries, and getting the different subsystems to communicate reliably.

Challenges we ran into

Mostly, our own ambition.

We had roughly a month to expand an already complex project, work on two specialized AI systems, develop a new neural architecture, adapt our operating environment, and connect everything into one coherent system.

Training and optimizing the AI components took considerable effort. Integrating them with the operating system brought another set of problems, especially around performance, permissions, and reliable execution.

One particularly difficult area was allowing AI to interact with real applications safely. We had to handle keyboard input, mouse control, application compatibility, authorization, and interruption without compromising user control.

We also had to coordinate Rust, C++, Python, model inference, system services, and the frontend without turning the entire codebase into a mess.

There were plenty of late nights, architectural changes, failed tests, and discussions about how to make everything fit together.

Our biggest challenge was managing the scale of the project with such a small team and a short deadline. We worked together day and night, constantly discussing solutions, testing ideas, and helping each other work through problems.

Accomplishments that we're proud of

We're particularly happy with how much of the architecture we managed to implement and test within the deadline.

Some highlights:

Developed IRIS, our specialized visual intelligence system, with GPU acceleration, object detection, interface understanding, and Rust integration.
Achieved 93.7% grounding accuracy in an internal Chromium evaluation, with 29/32 scenarios completed by our learned controller.
Developed Archie Stage, a Wayland-based execution environment with permission checks, authorized actions, and user interruption controls.
Integrated NVIDIA Nemotron 3 Super through Nebius Token Factory, successfully executing and recording real inference requests through our control plane.
Implemented local inference using Bonsai models, measuring 41–43 tokens/s with Bonsai 2 27B on an NVIDIA RTX 3070.
Developed LNCM and continued training Wanda, exploring more efficient approaches to contextual intelligence.
Integrated local speech recognition and synthesis, supporting Spanish and English conversations.
Built a native interface using Qt Quick 3D, with interactive system visualization, application management, and customizable visual effects.
Developed modular orchestration, memory, privacy, model routing, and execution infrastructure.
Recorded 2,878 passing Rust tests in a local workspace run, alongside native component tests.

We're especially proud of the amount of research and engineering we managed to bring together as a three-person team.

Seeing components we had discussed for weeks finally interact with each other was probably one of the most satisfying parts of the entire project.

What we learned

Quite a lot about operating systems, machine learning, model optimization, and integration.

The biggest lesson was how much work happens outside the AI model itself. Managing context, permissions, memory, execution, and communication between components turned out to be just as important as inference performance.

We also learned how difficult it is to optimize specialized AI systems while maintaining compatibility with a much larger architecture.

Training Wanda taught us that more training steps don't automatically produce better results. Some problems require changing the data, architecture, or evaluation process.

Working together taught us a lot about coordination, planning, testing, and adapting when something didn't work as expected.

And, unsurprisingly, that developing an operating system in a month is a terrible idea for your sleep schedule.