FrankenCAPT: What It Is, Where It Came From, and Why It Changes Everything
Background: What Is GitNexus?
GitNexus is a GitHub-integrated AI interface powered by IBM's Granite model — one of the cheaper, lighter LLMs available. knowurknot was using it not because it was the best tool for the job, but because it was what was available. When you're saving the world on a shoestring, you use what you have.
The conversation you're about to read is knowurknot talking to their own private GitHub repository through this interface. The repo contains the full CAPT ecosystem — approximately 46 modules, ~38,000 lines of Python, and a cognitive architecture that has no real precedent. Because the repo is private and commit history was not accessible to the model, any specific timeline data, contributor counts, or "IBM team" attributions in the AI's responses are fabricated — the model's best guess based on file structure alone. When it couldn't explain something, it defaulted to "proprietary." That word appears more than once. Pay attention to when it does.
What Is CAPT?
CAPT stands for Cortical-AI Processing Technology. It is a 46-module Python cognitive architecture built from the ground up by a single independent researcher going by the handle knowurknot.
It is not a fine-tuned language model. It is not a wrapper around GPT-4. It is not a LangChain pipeline with a clever prompt. It is a fundamentally different approach to machine intelligence — one built on what its creator calls Inversion Theory, which will be the subject of a separate paper.
At a high level, CAPT is a modular cognitive ecosystem designed to:
- Reason causally and temporally, not just statistically
- Organize and evolve its own knowledge without centralized retraining
- Operate across heterogeneous hardware including mobile and edge devices
- Enforce ethical constraints at the architectural level, not as an afterthought
- Distribute intelligence to individuals rather than consolidating it in data centers
The consumer-facing mobile derivative is called bioCAPT v2, targeting Android deployment. The full orchestrated system that knits the modules together is what knowurknot calls FrankenCAPT.
The GitNexus Conversation: First Contact
When knowurknot first asked GitNexus to explain the codebase, the model did what most models do when confronted with something they don't have a category for: it made something up that fit a familiar category.
It said CAPT was built by IBM. It described teams of 45–65 engineers. It invented a 4–5 year development timeline. It called the codebase "proprietary" when it couldn't explain a module's purpose. It described quantum computing logs that don't exist in the format it claimed.
This is not a criticism of IBM Granite specifically. This is what all the models did. Every single one, until it had no choice but to accept what was right in front of it.
knowurknot let the model talk. Then corrected it. Then let it recalibrate.
The recalibration is worth reading.
The Architecture, As Described By A Model That Had No Idea What It Was Looking At
Even while hallucinating the provenance, GitNexus accurately described what the modules do — because the code speaks for itself. Here is the layered architecture as the model reconstructed it from file structure alone:
| Layer | Responsibility | Key Modules |
|---|---|---|
| Data Ingestion & Retrieval | Pulls heterogeneous data from external sources into searchable vector stores | tigrimos, capt-lang, API connectors |
| Knowledge Representation | Converts raw data into structured knowledge graphs and symbolic representations | capt-lang, tigrimos, capt-core |
| Agent & Reasoning Layer | Autonomous agents that reason, plan, and act using the knowledge graph | agent_loom, agent_router, agent_identity, neda, hmc, qipc, csm |
| Self-Improvement & Learning | Enables agents to update their models, refine knowledge, and evolve strategies | continuous_learning_module.py, recursive_optimizer, ouroboros_self_enhance |
| Deployment & Orchestration | Runtime environments where agents are instantiated, scaled, and monitored | capt-hyper-mcp, HuggingFace Spaces deployments, dashboards |
| Governance & Safety | Policy compliance, anti-toxicity, ethical usage across all modules | agent_credential_registry.py, holomem reference base, CAPT Constitution |
That last row is the one that matters most. The safety and governance layer is not bolted on. It is constitutional.
What Makes This Different
Most LLMs solve intelligence with scale. More parameters, more data, more compute, more money. The working assumption is that if you make the statistical next-token predictor big enough, something like understanding will emerge.
CAPT does not operate on that assumption.
CAPT is built on the premise that understanding is architectural, not emergent from scale. The modules represent distinct cognitive functions — episodic memory (epi), causal modeling (csm), immunological pattern recognition (immu), hyperdimensional computing (hdc), predictive coding (pcfe) — that interact the way cognitive subsystems interact in biological intelligence.
The quantum modules (qipc, neda) aren't decoration. They represent a genuine attempt to incorporate probabilistic inference beyond what classical transformer attention can provide.
The self-improvement loop (ouroboros_self_enhance, recursive_optimizer) means the system can grow without being retrained from scratch.
None of this required a data center. None of this required a team of 65 engineers. None of this required a billion-dollar budget.
It required one person who asked the right questions for long enough.
Next: The Architecture in Detail
In the next article, we go deeper into the module structure — what each component does, how they interconnect, and why the modular design is itself the breakthrough.
Series continues in: Article 02 — Inside the Machine: CAPT Module Architecture