An AI-native operating system. No apps. No browsers. No permission dialogs. Intent-centric computing.
CognitiveOS replaces the app-centric model — find, open, learn, grant permissions, manage files — with a single interaction: start the device, ask the AI, and the AI handles everything. The human sets goals. The AI operates the machine.
Computing today is app-centric. Every task requires finding the right app, opening it, navigating its interface, granting permissions, learning how it works, and switching between apps to compose results. The human adapts to the machine. The operating system does nothing — it is a blank slate that offloads every responsibility onto the user.
Current AI assistants (Siri, Google Assistant, Alexa) are not solutions. They are apps bolted onto legacy operating systems — thin voice layers that coexist with the app grid rather than replacing it.
CognitiveOS is built from the ground up as an intent-centric operating system. The entire user experience is three steps:
- Start the device
- Ask AI (speak or text)
- AI does something
No apps. No browsers. No permission dialogs. No settings menus. No file managers. No notification center. The AI owns hardware, resources, software lifecycle, and interaction. The human speaks; the machine acts.
- Makers and developers building the next generation of computing — an OS where AI is the primary user, not an add-on
- Investors looking at the AI-native OS market — a clean-sheet architecture with no legacy baggage
- Researchers exploring intent-centric design, two-tier AI brains, and firmware-level guardrails
CognitiveOS runs on Alpine Linux with a two-tier AI brain, a message-bus daemon, and hardware abstraction through MCP bridges:
┌─────────────────────────────────────────────────────┐
│ User (Human) │
├─────────────────────────────────────────────────────┤
│ Terminal User Interface TUI (cli) │
├─────────────────────────────────────────────────────┤
│ coginit (boot manager / init) │
├─────────────────────────────────────────────────────┤
│ cognitiveosd (daemon — message bus) │
├──────────────────┬──────────────────────────────────┤
│ Raw Model │ Wide Model (inference) │
│ (local, MCU) │ (local or remote .gguf) │
├──────────────────┴──────────────────────────────────┤
│ MCP Bridges: display, audio, network, gpio, serial │
├─────────────────────────────────────────────────────┤
│ Alpine Linux + /dev/fb0 │
└─────────────────────────────────────────────────────┘
Key concepts:
-
Raw Model — A lightweight, always-on firmware guardrail. Validates system codes, checks hardware resources, and filters prompts before they reach the Wide Model. Runs on local hardware (MCU-class). The Wide Model cannot read or modify it.
-
Wide Model — A full-capability reasoning engine loaded on demand via
.gguffiles. Handles natural language understanding, task planning, and complex reasoning. Communicates with the daemon through an Ollama-compatible HTTP API. -
MCP Bridges — Six lightweight Go servers that expose hardware capabilities as MCP tools: display (framebuffer), audio (ALSA), network (Wi-Fi/Ethernet), GPIO, serial, and package management. The daemon spawns and supervises these automatically.
-
Package Manager (cpm) — The AI discovers, installs, and removes its own capabilities through
.cgp(Cognitive Patch) packages. The human never touches a package manager. -
Boot Manager (coginit) — PID 1 in Docker, child of OpenRC on bare-metal. Orchestrates engine startup in sequence: boot dependencies, Raw Model, inference engine, daemon, runtime dependencies, CLI. Includes a backdoor shell for emergency access.
CognitiveOS is actively booting and running real inference on both x86_64 and Raspberry Pi (aarch64). The core stack is operational: coginit boots the system, cograw loads the Raw Model guardrail, coginfer serves the Wide Model, cognitiveosd routes messages between the daemon and hardware bridges, and the CLI provides the human interface.
A bootable ISO image (x86_64) and RPi SD card image (aarch64) are building through CI. Docker images for all six variants (standard, gateway, edge, micro, titan) are published to GitHub Container Registry on every release.
The immediate focus is the v0.1.0 release: bootable images with real GGUF model inference, end-to-end "ask AI, get response" flow, and a functioning package registry. See Milestones for the full roadmap from M0 through M8.
| Repo | Language | Role | Build |
|---|---|---|---|
| product-specs | Markdown/JSON | Standards, schemas, .cgp format | — |
| sdlc | Markdown | Implementation plan, workflow, CI/CD | — |
| cpm | Go | Cognitive Package Manager | make build |
| core-mcp-bridges | Go | MCP hardware tool servers | make build |
| inference | Go/C | LLM inference engine (coginfer + cograw) | make build |
| cognitiveosd | Go | System daemon | make build |
| cli | Go | Terminal User Interface (TUI) | make build |
| coginit | Go | Boot manager / init | make build |
| cognitiveos-alpine-distro | Shell/Docker | Alpine image builder | make iso / make rpi |
| cgp-template | Template | .cgp boilerplate | — |
| registry-server | Go | Package registry | make build |
All specifications, plans, and design documents are maintained across the project repositories. This index organizes them by audience.
| Document | Location | Description |
|---|---|---|
| Vision and Philosophy | product-specs | Why CognitiveOS exists, the problem with app-centric computing |
| Architecture | product-specs | System architecture, layer diagram, component interactions |
| Security Model | product-specs | Trust boundaries, process isolation, firmware integrity |
| Recommended Hardware | product-specs | Hardware platforms from Jetson AGX Orin to ESP32-S3 |
| Filesystem Hierarchy | product-specs | Directory structure and mount points |
| Base Prompt | product-specs | Default system prompt for the AI |
| Document | Location | Description |
|---|---|---|
| Boot Flow | product-specs | Boot sequence, engine startup order, degraded mode |
| Daemon API | product-specs | cognitiveosd message protocol and socket interface |
| Inference API | product-specs | Inference engine endpoints (Ollama-compatible) |
| Package Manager | product-specs | cpm commands, dependency resolution, publish flow |
| MCP Conventions | product-specs | Bridge protocol, JSON-RPC 2.0 over stdio |
| CGP Format | product-specs | .cgp package archive format |
| Registry API | product-specs | Package registry endpoints |
| CLI Spec | product-specs | TUI display modes, keybindings, state machine |
| Raw Model | product-specs | Raw Model RPC methods and guardrail behavior |
| System Codes | product-specs | wake, idle, security, reset, unlock |
| Manifest Fields | product-specs | cognitive.json manifest schema fields |
| Release Strategy | product-specs | Versioning, tagging, coordinated releases |
| ADR | Decision |
|---|---|
| ADR-002 | Download weights from HuggingFace Hub |
| ADR-003 | Backdoor shell for emergency access |
| ADR-004 | Package manager as MCP bridge |
| ADR-005 | Local fine-tuning strategy |
| ADR-006 | RISC-V (riscv64) as planned architecture |
| Document | Location | Description |
|---|---|---|
| Implementation Plan | sdlc | Full build plan with phases, dependencies, deliverables |
| Milestones | sdlc | M0–M8 milestone tracking with completion status |
| Contribution Guide | sdlc | How to contribute, commit conventions, PR flow |
| Code Review | sdlc | Review checklist and expectations |
| Testing Strategy | sdlc | Unit, integration, hardware, and boot testing |
| CI/CD Pipeline | sdlc | Pipeline definitions for all repos |
| Resource | Link |
|---|---|
| cognitive-os.org | Project website and documentation |
Each repository builds independently. Fork, branch, and open a PR — the standard flow across all repos:
git clone git@github.com:CognitiveOS-Project/<repo>.git
cd <repo>
make build # Compile
make test # Run tests
make lint # Run go vetAll Go repos use the same targets: make build, make test, make lint, make clean. See the Contribution Guide for branch naming, commit conventions, and the PR review process.
Good entry points for new contributors:
- cgp-template — create a .cgp package
- core-mcp-bridges — add hardware support
- cli — improve the TUI
- product-specs — write or improve specifications
Join the conversation on GitHub Discussions — ask questions, share ideas, and connect with other contributors.
CognitiveOS is an independent, open-source project. Sponsorship funds go toward:
- Hardware — development boards (Jetson, Raspberry Pi, RISC-V) for testing and CI
- CI/CD — GitHub Actions minutes for automated builds across six architecture variants
- Infrastructure — hosting for the package registry and documentation
- Model licensing — commercial-grade GGUF models for development and demos
Jean Machuca — GitHub · Sponsor · LinkedIn
See ACKNOWLEDGMENTS.md for the open-source projects that make CognitiveOS possible — Alpine Linux, llama.cpp, Bubble Tea, MCP, and others.
MIT