NiallOS

Independent laboratory ยท ongoing

Make professional context durable.

NiallOS is my working laboratory for AI-assisted knowledge work. It is a local-first operating system for projects, research, documents, insights, contacts, tasks and AI workflows. It is not a chatbot. It is a structured environment for making professional context persistent.

What this page is: a method case, not a client programme. I use NiallOS every day on my own work. It is not a public product and not represented as a Cambridge client project.

Local-firstContext stays in a structured system, not only in chat history
Source-groundedDocuments become extracts and insights that can be checked
Skills and gatesRepeated work uses reusable methods and review
Human in the loopAI workers get bounded tasks, not unsupervised authorship

The problem

Most knowledge work fails in the same place: context.

The important material is scattered across documents, folders, emails, chats, meetings and people’s heads. AI can generate fluent text, but it often lacks the project memory, source grounding and judgement needed for serious work.

NiallOS is my answer to that problem. It is the system I use every day to make context durable enough for AI to work with it.

The origin story is in Why I Built an AI Twin to Run My Life.

The organisational argument behind it is in The Real AI Bottleneck in Organisations Is Memory.

For a concrete example of what it does day to day, see the worked example below.

The design bet

Professional expertise can be encoded into systems, not just prompts. The useful unit is not a clever chat interaction. It is an operating layer made from source material, expert judgement, workflow, retrieval and review.

What it does

A working layer around real projects

These are functions of the laboratory, not product features on a public roadmap.

Hold the work

Tracks projects, tasks, milestones, contacts, journal entries and decisions so the story of a piece of work does not live only in inbox threads.

Ingest and verify

Takes documents in and turns them into extracts and reusable insights that can be checked against the source, rather than summarised once and forgotten.

Search the material

Supports keyword and semantic search across source material, so retrieval is a first-class part of the work, not an afterthought in a chat window.

Keep memory structured

Stores project knowledge in a structured database rather than leaving it in chat history that expires, drifts or cannot be audited.

Reuse the method

Uses skills and quality gates for repeated work such as research synthesis, workshop design, document review and proposal writing.

Bound the agents

Packages work for AI workers with enough context to be useful, and keeps human review in the loop before anything is treated as finished.

A worked example

From a pile of workshop files to project memory

In June 2026 I ran a workshop for leaders in Harare. By the end I had the usual pile: the final slide deck, my facilitator guide, a participant workbook, handouts, an exit slip and the source files behind all of them. The normal next step is to drop the lot into a folder and promise to tidy it later.

By the next morning the pile had gone. Fourteen files had been registered as project documents, turned into searchable text and linked to the right project, and the intake folder had been cleared into an archive. When I later asked an agent which final materials existed for that work, or to draft a follow-up, it did not start from nothing.

The useful question was never just “where should these files go?”. It was which project they belong to, what kind of document each one is, whether any of them changes the timeline, creates a task or replaces an older version, and whether any of it should come up in the next attention check. Answer those and the files stop being storage. They become part of the project’s memory.

Decisions get written back

The same applies to decisions. In one project, a new plan replaced an earlier set of timeline assumptions: a later pilot date, face-to-face milestones in particular months, reporting later in the sequence. Saving the plan was not enough. The system needed to record what changed and why, retire the old version while keeping it traceable, and make sure later checks worked from the current picture instead of confidently repeating the stale one. Storage keeps the plan. Memory updates the work.

Attention before you ask

A knowledge base helps when you remember to search it. Working memory helps before you think to ask. Each morning a brief flags which live projects need attention: overdue tasks, a blocked milestone, documents nobody has reviewed. The scoring behind it is plain code working from structured signals such as tasks, milestones, recent activity and review load, so it comes out the same way every time. A language model only comes in afterwards, to explain what the scoring found.

Small agents, shared memory

The agents work as sidecars rather than one assistant that is meant to know everything. One writes the morning brief from the overnight scores. Another rebuilds the search index. A third checks whether the day’s new files have been processed, or prepares a handoff note for a heavier piece of work. Each has a narrow job, the right context and output I can review, and the decision goes back into the shared memory.

Where it is still rough

It breaks. For about two weeks, three background jobs failed silently: the search index went stale and the daily memory file froze, and nothing told me until I went looking. A memory system that quietly stops remembering is a good lesson in how much depends on the plumbing. It is also built for one person, so it has never had to deal with permissions or who can see what, which is exactly where an organisational version gets hard. And it is only as good as the habit of capture. A decision nobody records is still lost, AI or not.

Projects as the unitFiles, decisions and tasks attach to a piece of work, not to a folder.
Code before the modelDeterministic scoring decides what needs attention. The model explains it.
Bounded workersSmall agents with narrow jobs, writing back to one shared memory.

The organisational case for this layer is in The Real AI Bottleneck in Organisations Is Memory, and the question of who should own it is in Own the Memory, Rent the Intelligence.

Why it is on this site

I do not start client work from theory.

NiallOS is where I test the patterns: document ingestion, knowledge grounding, insight review, project workspaces, semantic search, agent handoff and human-in-the-loop quality control.

The same principles apply at organisational level. Capture the knowledge that matters, structure it, connect it to workflows, ground it in evidence, and make AI outputs reviewable.

Encode expertiseTurn judgement, sources and quality bars into something a team can reuse.
Ground the outputMake claims checkable against documents, not against the last prompt.
Keep reviewPeople still specify, supervise and reject the work.

What it is not

Not a chatbot. Not a SaaS product. Not a client case study.

  • Not a generic productivity app. It is built around real projects, research and professional judgement.
  • Not something you can log into. There is no public NiallOS service, and I am not selling the instance.
  • Not a substitute for the programme pages. DELP, KFAS, ECOSOCC, Zambia and Worldreader are delivered work with public sources. This page is the laboratory behind the method.

Confidentiality: NiallOS holds working material from consulting, research and personal practice. This page describes the method. It does not publish client files, internal databases or screenshots that would expose other people’s work.

Trying to build this kind of capability?

I work with education organisations and professional teams on encoding expertise, grounding AI work in sources, and putting review around delivery.

Work with me