harness.os
AI Knowledge Engineering

harness.os Blog

Two series — the journey of building harness.os, and the continuous improvement that followed. From files to methodology, from methodology to a system that improves itself.

Marco May 2026 2 series · 15 posts · ~85 min total

First, see what was built

Before the journey — see the destination. A multi-app AI ecosystem, from domain data to full orchestration.

→

What is AI Knowledge Engineering?

Not an official term — different people call it different things (KPMG: "knowledge engineering", Anthropic: "context engineering", Fowler: "harness engineering"). It's the framing I use for how harness.os works — a useful way to think about the two layers.

AI Engineering

AI Engineering

Picking models, writing prompts, building agents, wiring tools. The inner harness — the thin runtime connector. Claude Code, Copilot, custom API agents. Interchangeable by design.

Inner harness: Claude, GPT, Copilot, Codex, custom agents. A thin connector that reads context, calls a model, and routes tools. These tools keep getting better every month.
AI Knowledge Engineering

AI Knowledge Engineering

Structuring what the AI needs to know AND how work should be done — so that any AI can use it. The outer harness. Your knowledge AND your processes, organized so AI becomes a competent participant.

Outer harness: build, product, operations, domain knowledge + rules, workflows, process definitions. Stays the same when you swap models. It's yours.
AI Engineering runs tasks. AI Knowledge Engineering makes them more structured every time.

This blog is proof of both

This blog was built with build.ai — AI agents that decompose requests into phased pipelines. That's AI Engineering: the agents, the models, the execution. But the blog also draws from 6 weeks of structured knowledge — project history, architecture decisions, methodology documentation, dev workflow patterns — all organized in a harness.os knowledge mesh. That's AI Knowledge Engineering.

AE
AI Engineering
build.ai agents generated, structured, and deployed 8 posts in parallel
AKE
AI Knowledge Engineering
Harness knowledge made the output accurate — git history, decisions, learnings, all pre-structured
=
The Result
A blog that maintains itself — new posts, updates, corrections flow through the same pipeline. Built after 6 weeks of structured knowledge accumulation — the detail and accuracy come from AI Knowledge Engineering, not from the tools

The agents that wrote this blog had no special instructions about the content. They connected to the same knowledge harness that builds software — and produced documentation instead of code. Same outer harness, different output.

For the full technical documentation, see the kernel docs.

Series 1

Building harness.os

Eight posts across four phases — from first commit to methodology

Discovery Posts 1–2
1
I Got a Claude Subscription and Started Three Projects at Once
How trying to build three apps simultaneously taught me what AI tools actually need — and what they're missing.
Discovery way2fly way2move way2save ~4 min
2
The Artificial Anatomy of AI
Creating cortex and spine — giving structure to the chaos of AI knowledge. The naming that changed how I saw the problem.
Discovery Cortex / Spine Naming ~4 min
Architecture Posts 3–4
3
Dashboards and Personal Assistants
Building build.ai as command center, marco.ai as personal assistant — and discovering the multi-tenant vision.
Architecture build.ai marco.ai ~4 min
4
When Your Apps Should Talk to Each Other
The cross-domain data realization that changed how I think about software architecture forever.
Architecture Cross-Domain MCP ~4 min
Insight Posts 5–6
5
The Outer Harness Always Wins
I kept making my custom agent smaller and smaller — until I realized the agent isn't the point. The knowledge is.
Key Insight Inner vs Outer Paradigm Shift ~4 min
6
Software Improves Processes. AI Is Just a New Participant.
The realization that connected everything: we've always been doing this — now we can do it better.
Philosophy Process Improvement BPM ~4 min
Methodology Posts 7–8
7
Four Types of Knowledge. That's It.
How build, product, operations, and domain emerged from practice — and why there isn't a fifth.
Methodology Type System Stress-Tested ~4 min
8
From Personal System to Methodology
Scale tiers, teaching others, and the honest question: does this work for anyone besides me?
Methodology Scale Tiers What's Next ~4 min

Series 2

Continuous Improvement

The system that improves itself — each post documents a real improvement, written in the session where it happened

Improvement Ongoing
1
One Brain, Every Interface
How harness.os connects Claude Code, build.ai, Copilot, and anything else — and why the interface doesn't matter.
Architecture Shared Brain Session Lifecycle ~7 min
2
The Session That Stopped Itself
How a QA session across three apps revealed that working without the harness defeats its own purpose — and the enforcement mechanism we built to prevent it.
Enforcement Improvement Cycle Token Economy ~7 min
3
The Knowledge Precision Problem
Why loading everything is the opposite of intelligence — how task-based routing cut context tokens by 97% across three apps.
Token Economy Knowledge Routing Context Precision ~6 min
4
From Files to a Knowledge API
Why your AI rules don’t scale past one project — and the 4-stage progression from firehose to learned routing.
Architecture Knowledge API Multi-Project ~8 min
5
Building the Knowledge API
The implementation story — PostgreSQL tables, MCP tools, concern-based tagging, and the usage tracking that powers learned routing.
Implementation MCP Knowledge API ~8 min
6
Token Economics at Scale
Why context cost grows linearly with projects, how a harness creates a crossover point, and the 6-stage progression from expensive to self-funding.
Token Economy Scaling Cost Analysis ~10 min
7
Infrastructure That Moves
Why a harness that can't relocate its own hosting, restructure its own repo, and rewire its own connections in a single session isn't really infrastructure.
Portability Infrastructure Gateway MCP ~8 min
8
Kernel, Distribution, Mesh
Why “methodology, configuration, mesh” was confusing everyone — and how a Linux analogy gave the three layers names that explain themselves.
Naming Kernel/Distro Linux Analogy ~7 min
More posts added as improvements happen. This series has no planned end — that's the point.

Part of harness.os · Showcase · Kernel