Open Cognitive Commons

Open Cognitive Commons (OCC) is an open-source network of collaborative AI agents grounded in community-verified knowledge. A locally-run agent — the Node — answers your questions by drawing from expert packs: collections of knowledge prepared, reviewed, and approved by the community. Where possible, the Node also asks more powerful peers in the network for an independent review of its draft answer. Together, these two mechanisms — verified sources and collaborative deliberation — let small local models produce answers far beyond what they could reach on their own.

What you can do with OCC

• Run a private AI agent on your own machine, answering questions from a curated knowledge base.
• Connect to the public network to use expert packs maintained by the community on shared infrastructure.
• Build private packs from your own data — personal notes, professional documents, anything you want the agent to know without it ever leaving your machine.
• Build public packs on topics that interest a community, and submit them for review and publication on the public registry.
• Contribute to the codebase, the source registry, or the catalog of packs. Everything is public, versioned, and reviewable.

The long-term goal is something close to a Wikipedia for language models: a shared, curated body of knowledge that any AI agent in the network can draw from, and that anyone can extend.

Collaborative agents

A query in OCC is not handled by a single model. It passes through three roles:

• Expert — the local model produces a first draft answer using the retrieved knowledge.
• Critic — a separate model reviews that draft against the same sources, flags unsupported claims, and points out gaps. When a more powerful peer is available on the network, the Critic step can run there over an end-to-end encrypted exchange — your query and the draft pass through the broker but the broker never reads them.
• Synthesizer — the local model integrates the Expert's draft and the Critic's review into a final answer.

This division of cognitive labor produces verifiably better answers than the local model could on its own. A small Qwen 4B with good retrieval and a peer-reviewed Critic step routinely outperforms a much larger model running alone, because the failure modes are distinct: small models hallucinate specifics; the Critic catches unsupported specifics; the Expert and Synth then produce a tighter, more faithful answer. In effect, each node operates beyond what its hardware would allow in isolation.

Verified knowledge, not crawled web

Most AI systems draw on a continuously crawled web — permanently exposed to manipulation, SEO poisoning, and sources nobody vetted. OCC's knowledge is different.

• Every pack is built from sources explicitly approved by the community.
• Every pack is reviewed before it enters the public network.
• Every pack is versioned and cryptographically signed.
• What enters the network is inspectable. What is rejected stays out.

Private use, public use

Forge — OCC's pack-building tool — is the same whether you are creating something for yourself or for the world.

• Private packs stay on your machine. Build a pack from your personal notes, internal company documents, research data, anything you want. The Node uses it to answer your questions and the content never leaves your computer. No cloud, no telemetry, no shared index.
• Public packs are submitted to the OCC registry. The community reviews the sources, the structure, and the resulting pages. Approved packs are published on the broker and become available to every Node in the network. The pack you build can become part of the commons.

Same workflow, same quality bar. Only the destination changes.

Why Qwen

OCC standardizes on the Qwen family of open models. The choice is deliberate, and the lock-in is by design:

• Open weights — fully inspectable, redistributable, no vendor lock-in at the model layer.
• Strong multilingual coverage — Qwen handles dozens of languages well, essential for a global commons.
• Efficient — recent Qwen variants are unusually capable per parameter, which makes smaller hardware tiers genuinely useful.
• Multimodal — vision support is available on appropriate variants, opening the door to image-based queries and pack content.

You can choose where the model runs — locally on your hardware via Ollama, or remotely via OpenRouter with your own API key.

Your local GPU stays available to the peer network in either configuration, which is why during setup the Node downloads the Qwen variant best matched to your hardware tier. The model is ready when you need it, and your machine can serve as a Critic peer for other Nodes when it is idle.

The components

OCC is split into a small set of cooperating parts. You don't need to understand them all to use OCC, but they explain how the system stays auditable as it grows.

Node

The runtime that lives on your machine. It loads a local Qwen model, asks the broker for relevant knowledge, runs the multi-agent deliberation, and exposes a chat-style interface. It works offline once knowledge is cached. It adapts to your hardware — from a laptop CPU to a multi-GPU server — through a tier system that scales context length and model size automatically. The Node also hosts Forge and Scout as built-in panels, plus a set of atomic tools (file workspace, document readers, audio transcription, pack catalog) and composite skills (deep web research, fact-check, document Q&A, code intents).

Expert packs

The unit of knowledge in OCC. Each pack covers one domain (Roman history, Docker, climate science, etc.) and follows a structured format inspired by Andrej Karpathy's LLM-wiki pattern: an index, a set of dense factual pages, cross-links between concepts, and an immutable record of the original sources. Packs are version-controlled, signed, and shipped as files.

Scout

The source-finding companion to Forge. You give Scout a topic and a scope; it searches across 15+ curated open knowledge databases (Wikipedia, Stanford Encyclopedia of Philosophy, arXiv, PubMed, Internet Archive, Project Gutenberg, OpenAlex, Crossref, GitHub, Wikisource, …) and returns a reviewable candidate list. You pick what to keep; Scout fetches; Forge builds. See Scout.

Forge

The pack-building workshop. You give Forge a set of curated sources — from Scout, or your own — and it produces a clean pack: extracted concepts, written wiki pages, cross-references between them, and a quality lint pass. Forge does not invent knowledge. It only synthesizes what you provide. Forge runs on top-tier proprietary models (GPT-5, Claude Sonnet 4.6) because a pack is built once and read forever — the opposite economics of the Qwen-only Node. See Forge.

Broker

A lightweight coordinator running on shared infrastructure. The broker hosts the published expert packs, exposes a full-text search index over them, and helps Nodes discover and exchange critic reviews with each other. The broker is not the source of authority — packs are. It is replaceable.

Who OCC is for

• Anyone who wants a capable AI assistant that respects their data, runs on their hardware, and is free of charge — for any reason or none.
• Practitioners who want an AI that cites real sources rather than producing plausible-sounding text from training data alone.
• Domain experts who want their field's knowledge represented faithfully in AI tools, with an audit trail and version control.
• Communities that want to maintain a shared, trusted body of knowledge rather than depend on whatever a single vendor's model happened to memorize.
• Researchers and operators who care about reproducibility, provenance, and the political economy of AI knowledge.

How the project is organized

OCC is open source and lives across a small set of public repositories:

• occ — the Node runtime, Forge, and the broker code.
• occ-registry — the list of source domains the community has approved as inputs for pack construction. Adding a domain requires a public pull request.
• occ-packs — the catalog of community-maintained packs. Each pack is its own folder, reviewable as a normal pull request.
• opencognitivecommons.org — this site, including the documentation you are reading.

All four are public. Issues, design discussions, and pack reviews happen in the open. There is no proprietary core.

Where to go from here

• Read Principles and design for the reasoning behind OCC's architectural choices and the deeper meaning of "community-curated".
• Jump to Getting started to install the Node and run a first query.
• See How OCC works for an end-to-end walkthrough of what happens between your question and the answer.
• Read Forge and Anatomy of a pack if you want to build or review packs.

---

OCC is a young project. The architecture is converging, the pack catalog is small but growing, and the governance process is being established as the community grows. The documentation in this section reflects the system as it currently exists, not aspirations. Anything not yet built is marked clearly in the Roadmap.