harness.os

What harness.os is

A real OS — then something new on top.

Every OS concept maps 1:1 to harness.os. Then the table keeps growing — and Linux stops.

OS Theory	Linux	harness.os
Kernel	Linux kernel	harness.os kernel (4 types, 5 concerns)
Processes	PID, fork, kill	Sessions (CONNECT→WORK→BLOCK→END) ✓
Memory mgmt	RAM, virtual memory	Token economy (context window) ✓
Filesystem	ext4, /home, /etc	Knowledge (domains, chunks) ✓
System calls	open, read, write	MCP tools (get, add, search, log) ✓
Drivers	Block, network, USB	MCP servers (file, DB, APIs) ✓
Boot sequence	BIOS → GRUB → init	start_session (handoff→rules→knowledge) ✓
Security	SELinux, permissions	Concern-scoped access, sync rules ✓
Operating System	GNU/Linux	harness.os (kernel + tools + cortex)
Shell	bash, zsh	MCP protocol interface ✓
Core utilities	ls, cat, grep	Core MCP tools (get, search, add, list) ✓
Kernel config	/etc, sysctl	Rules (knowledge with enforcement) ✓
Executables	/usr/bin, scripts	Workflows (knowledge with sequence) ✓
IPC / Pipes	stdin→stdout, sockets	Session handoffs (context transfer) ✓
Scheduler	CFS, nice, cron	Workflow phase ordering, rule priority ✓
Distribution	Ubuntu, macOS	marco.os, acme.os
Default packages	apt install defaults	Default rules, workflows ✓
Package manager	apt, snap, brew	Knowledge ingestion (add_knowledge) ✓
Desktop env	GNOME, KDE	Control Tower UI ✓
Users / Groups	/etc/passwd, sudo	Agents with harness affinity ✓
Firewall	iptables, ufw	Sync rules (what crosses boundaries) ✓
↓ Cognitive Layer — no OS equivalent ↓
Learnings	—	Transferable patterns that compound ✓
Decisions	—	Choices with rationale (remembers why) ✓
Metadata	inode, xattr, file tags — describes things, can't reason	Same — knowledge chunks have tags, concerns, status
Metacognition	— (meta exists, cognition doesn't)	Reasons about its own patterns — what decisions repeat, where reasoning fails, what rules aren't working ✓
Cross-cutting concerns	—	5 lenses across all knowledge ✓
Knowledge growth	—	System genuinely gets smarter over time ✓

Kernel + OS + Distribution: harness.os maps 1:1 to real computing. "Everything is a file" → "Everything is knowledge."

Below the line: the cortex. What no OS has ever had — because programs don't think, but AI agents do. This is what makes harness.os different from every OS and every agent framework.

What they sell you

Brainstem + thin memory

Reasoning engine plus memories, custom instructions, projects. But no cognitive structure — and locked to their agent. Can't carry it to another tool or your own.

→

What harness.os builds

Full Cortex

Structured knowledge with types, concerns, learnings, decisions. Works across any agent — theirs or yours. Your knowledge, your OS.

Why nobody tells you this

There shouldn't be such a thing as "Claude is better than ChatGPT." The question should be: which agent is best for this task on my OS?

There shouldn't be "write a skill so Claude gets smarter at X." There should be: define the knowledge and workflows your OS needs — then let any agent execute them, learn from them, and improve them.

If your knowledge lives in your OS with your cortex, their model becomes a plug-in. You pick the best agent per task — they all work on the same OS, follow the same rules, compound the same learnings.

Today: "make your agent smarter" (locks you to one tool).
With an OS: "make your knowledge better" (any agent benefits).

Computing Evolution

Five attempts. Each got something right.
None had the full picture.

The cognitive layer didn't arrive sooner because five serious attempts each missed a critical piece. Each got closer. None put it together.

Knowledge engineering attempt — fell short New discipline emerging

Era	Breakthrough	Discipline	Product
1936	Turing Machines	Theoretical CS	Formal proofs
1945	Digital Systems	Computer Architecture	Von Neumann, x86, ARM
1960s	Kernels	Operating Systems	Unix, Linux
1970s	Full OS	Systems Programming	GNU/Linux, BSD
1980s	Distributions	Software Engineering	Ubuntu, macOS, Windows
1970s–80s	Expert Systems	Knowledge Engineering (attempt 1)	MYCIN, Cyc, Prolog
1990s–2000s	Knowledge Mgmt	KM Engineering (attempt 2)	Confluence, SharePoint, wikis
2000s–10s	Semantic Web	Ontology Engineering (attempt 3)	RDF, OWL, Freebase
2010s	PKM Tools	Personal Knowledge (attempt 4)	Notion, Obsidian, Roam
2000s–10s	Cloud + Web	Cloud / Data Eng.	AWS, GCP, Azure
2020s	AI Models	AI Engineering	GPT, Claude, Gemini
2020s	RAG + Vector DBs	AI Memory (attempt 5)	Pinecone, Chroma, Weaviate
Now	Cognitive Layer	AI Knowledge Eng.	harness.os

1936–45

Theoretical CS → Computer Architecture

Turing proves computation. Von Neumann gives it memory + processor. The machine exists. It just can't think or remember.

1960s–80s

Kernels → OS → Distributions → Software Engineering

"Everything is a file." Unix, Linux, SQL, macOS, Windows. Created the disciplines of OS design, systems programming, and software engineering. The OS abstracts hardware. Developers build on top.

1970s–80s

Expert Systems → Knowledge Engineering (attempt 1)

MYCIN, Cyc, Prolog, CLIPS. "Encode knowledge as rules." AI researchers built entire systems by hand-crafting thousands of IF-THEN rules. Brilliant engineers worked for decades. MYCIN diagnosed infections better than some doctors. Cyc tried to encode all of human common sense. What failed: too brittle, too expensive, couldn't scale beyond handcrafted rules. No learning, no adaptation. The knowledge was dead — it didn't grow.

Tried it. Got close. Didn't generalize.

1990s–2000s

Knowledge Management → Wikis, Intranets, Document Systems

Lotus Notes, SharePoint, Confluence, Wikipedia. "If we document it, we'll know it." Organizations built enormous knowledge bases — process docs, runbooks, wikis, intranets. What failed: search-based retrieval. No reasoning over the knowledge. No connection to workflows. The knowledge sat in documents — it didn't work. Agents didn't exist to use it. Humans had to read it, interpret it, apply it manually.

Right instinct. No agent to use it.

2000s–10s

Semantic Web → Ontologies, Knowledge Graphs

RDF, OWL, DBpedia, Freebase, Google Knowledge Graph. Tim Berners-Lee's vision: a web where machines understand meaning, not just links. Ontologies would give structure to knowledge. What failed: too complex to maintain. Ontology engineering required specialists. Real organizations couldn't build or sustain them. Knowledge graphs (Google, Wikidata) worked at scale for facts — but not for reasoning about process, decisions, or behavioral rules.

Right structure. Wrong implementation layer.

2010s

PKM Tools → Notion, Obsidian, Roam Research, Logseq

Personal knowledge management. Graph-based notes, bidirectional links, block editors. "Build your second brain." Roam Research had a cult following. Obsidian turned file-based notes into a graph. Notion made it beautiful. What failed: notes without agents. Knowledge without execution. The gap between "knowing" and "doing" never closed. Your Obsidian vault can't give instructions to Claude. Your Notion docs can't teach itself to a new AI session. The knowledge was yours — it just couldn't work for you.

Personal knowledge. No agent integration.

2000s–10s

Cloud → Data Engineering → ML Engineering

AWS, GCP, Azure. Elastic infrastructure. Massive datasets. Deep learning at scale. The machines got smarter at pattern matching. Better storage, better retrieval, partial reasoning. Still no persistent learning about your specific context.

2020s

AI Models → AI Engineering → RAG (attempt 5)

LLMs. GPT-3, Claude, Gemini. Transformer models that can reason, write, and code. Then RAG: Retrieval-Augmented Generation. Vector databases (Pinecone, Weaviate, Chroma). "Give the AI your documents." "Query your PDFs." This is as close as the field has gotten — the brainstem now has a filing cabinet. What still fails: no cognitive structure, no learning over time, no portability across agents. Every session starts fresh. The AI reads your files but doesn't build on them. You're still locked to one provider's agent.

Best attempt yet. Still missing the cortex.

Now

Cognitive Layer → AI Knowledge Engineering

The brainstem gets a full cortex. Structured knowledge with types and concerns. Learnings that compound across sessions. Decisions that carry rationale. Any agent can plug in — Claude, ChatGPT, Copilot — and they all run on the same OS, follow the same rules, and improve the same knowledge. This is what the previous five attempts were pointing toward.

New discipline. New product category.

How I Got Here

A software engineer finds a new layer.

I'm a software engineer whose focus on process made me see the abstraction. Implementing it exposed CS fundamentals I'd missed. Closing that gap confirmed it was real.

Files

Week 1–3

Three apps, knowledge files from day one

Claude subscription. Three products. CLAUDE.md, architecture docs, decision files. Each session revealed what the AI needed.

Anatomy

Week 4–6

Body metaphor + domain harnesses

"Artificial Anatomy" — cortex, spine, senses, motor. Built marco.ai. Domains (skydiving, fitness, finance) each needed their own harness.

Insight

Week 7–9

Software is process improvement — agents are just new participants

That's what clicked. Software engineering has always been about improving process. AI agents are just a new element in that loop. Once I saw that, the process thinking applied everywhere: plug in a personal finance assistant, a skydiving assistant, Claude Code, ChatGPT — any agent works on top of the same system knowledge, reasons across domains, talks to the others, and improves the OS instead of starting from zero.

Week 9–10

harness.os takes shape — something's missing

Four types, five concerns, three layers. Could design the process — struggled with implementation. My degree (UnB 2008) focused on process, not fundamentals: no mandatory OS, compilers, or networking.

Gap

Week 10–11

Built a college app to close the gap

Studied the courses I missed — starting with OS. Mapped each concept (processes, filesystems, memory, syscalls) to what I'd already built. 1:1 match. It wasn't a methodology. It was a real operating system.

Week 11

The cortex — a genuinely new layer

Stress-tested the mapping backwards. Found what no OS has: learnings, decisions with rationale, metacognition, cross-context transfer. I'd called it "cortex" since week 4 — now I understood why.

OS + Cortex = harness.os

The curriculum gap

My degree (2008)

Software Eng. (Process Focus)

✗ Operating Systems
✗ Compilers
✗ Networks
✗ Distributed Systems

Current (2016+)

CS + Process

✓ Operating Systems
✓ Compilers
✓ Networks
✓ Distributed Systems

Process expertise saw the abstraction. CS fundamentals confirmed it's real.