Native Intelligence

How the lab is meant to work as one system, from the 24 GB card that carries the heavy work down to the ARM cluster, and how far that has actually been built.

AI governance responsible use local inference evaluation human gates systems architecture

Where the intelligence runs

Most of it runs on Mothership, the host with the 24 GB RX 7900 XTX. That card carries the 27B tier for think-hard work and adversarial review, a 27B medical model for the nursing critic, and the mixture-of-experts and 30B coder models that ladder up for overnight planning. It is also where the 32B QLoRA trained and where the image pipelines were chosen over nine evaluation rounds. A silent driver-level stall was root-caused and guarded against on the same card, which is what made it dependable enough to be the heavyweight tier at all.

The orchestrator itself runs on the Hyper-V host, and the thinking that needs a large model goes to Mothership. BigHonker's RTX 3070 is the quick-chat host: the 8-9B model for routine questions and tool orchestration, plus the captioning tier, clock-locked after its own root cause. The Fellowship (the ARM cluster) takes the cheap end, tiny models as independent workers, chosen through the thousand-run gauntlet. Frontier models (Claude, Codex) are contractors, brought in on my explicit opt-in. The scheduler places each order across that ladder by declared capability, memory headroom, and energy price. That is the resource-intelligence half of the program, running today.

The end state

The intended end state is a Home AI I can talk to naturally. It works out what I am trying to accomplish and what it needs to know. Then it decides whether the work stays conversational or becomes a job, and which machine or factory (the order-taking runner on each host) fits. It investigates on its own where it can, asks me where it should, and completes the work without me orchestrating the fleet by hand. The end of that road is a local operator of the lab working alongside me.

Parts of that loop have already run, each under my authority and each behind gates. In the self-engineering campaign the local AI planned, edited, tested, and proposed changes to its own orchestrator, with the heavyweight tier on Mothership as its critic and a human promoting every change. It concluded on August 31, 2026 with a regression run graded outside the system that produced it. Managing multiple chats became conversations as first-class objects, built in one night and folded into the deploy gate. When a legacy 32-bit ARM device joined the cluster in September 2026, it exposed a gap: the AI could rebuild parts of its own orchestrator, but it could not do routine administration on an ordinary Linux host. That capability was built into the orchestrator, and the AI used it to bring the device in the same week. The device is not powerful, at four cores and about 1.4 GB of RAM. What matters is that the loop ran end to end.

What the history shows: 876 confirmed collaborations, 570 confirmed corrections

The lab holds months of operational history: plans, journals, corrections, tool calls and results, tests, orders and receipts, deployments, and failures. Two reconnaissance passes ran over it in August 2026 as factory orders through the lab's own extract, review, and findings payloads, with me driving the loop by hand through an agent session. The version that runs the same loop without a person at the controls was deployed the next day. The lab's own models did the first-pass grading; I spot-checked samples throughout, so the counts are a supervised internal signal, not a third-party audit.

The machinery behind those numbers is a four-step spine (extract, review, iterate, assemble) that runs as a self-cascading chain of factory orders with no polling loop. Review runs fleet-parallel across the GPU factories, every row must be grounded in an exact quote, and a row that fails grounding on two passes of the heavyweight tier is dropped, with the reason recorded. The findings document carries a human interpretation section and no automatic quality score. Kickoff is admin-only and pending-then-confirm, and after that the orchestrator only watches and reports.

As of September 2026 the self-driving version of that machinery has not run a campaign. It starts when I start it, and there are no findings from it yet. The model-labeled confidence on the corrections pass is uncalibrated, and its interpretation section is still a draft.

Two questions, one program

Resource intelligence asks where and how the lab should perform the work. The ladder above answers it, along with the scheduler that places orders across it. The cheap end has its own evidence: the tournament settled which tiny models earn a role, and the ensemble experiment, once its appraisal runs, will say whether more independent workers beat one larger model. Native intelligence asks whether the cognitive components themselves can learn to work more naturally inside this system. The groundwork for that is Mothership-side. Project 30 built the extract, review, and findings spine, and a separate cross-scale transfer experiment returned a clean negative result on projecting adapters across model scales. The 32B QLoRA proved a training path on a 24 GB card, the doctrine is the anchor corpus, and the planned training program sits on top. Answer both and the result is one thing I talk to, with the lab deciding how to think and how to execute. The resource-intelligence rule, from the compute charter:

"Use the least expensive source of compute and intelligence that reliably satisfies a task's quality + time requirements, while accounting for verification, energy, resource contention, and escalation. Sometimes that is ordinary code; sometimes one tiny model; sometimes seven tiny models; sometimes a 27B on the 7900 XTX; occasionally a larger, slower local model spilling to RAM. The architecture learns which strategy fits which task class — it does not assume one wins universally."

Local first: what to run and what to buy

Whether owning inference hardware beats per-token rates turns on utilization. It is arithmetic a buyer can run on their own traffic, hardware and power against per-token spend at their real load, and I have not run it at company scale. What running it at home has shown me is narrower. A platform-vendor dependency is a smaller risk than a frontier-model-vendor dependency. So the useful default is to own the hardware where the utilization is there, treat frontier models as specialty contractors, and keep the dependency on the platform instead of the model vendor.

That is how frontier models (Claude, Codex, ChatGPT) are used here: on a specialty basis, to work through architecture with me, review evidence, repair a missing capability, and hand control back. They do not babysit workers or burn tokens on work the local system already does. The work is written up so other people can attempt it on hardware they own, which is why the driver investigation and the 32B QLoRA recipe were published.

The boundaries

Three layers stay distinct, and the distinction is what keeps a learned model from becoming a liability.

A corollary from the charter: the orchestrator is identity, tools, retrieval, gates, routing, and execution loops. No model inside it is the orchestrator, and a Native Intelligence model would be one more component it can call.

The goal is also not a model that sounds like me or agrees with me. A good Native Intelligence component must still identify when I am mistaken, surface contradictory evidence, refuse unsupported conclusions, and disagree when the evidence warrants it. Training that produces more obedience while reducing independence is a regression. The charter's phrasing:

Understand the operator extremely well without surrendering independent judgment.

How it grows

Vertical slices: build one useful end-to-end experiment, measure it, widen the slice. Success is staged, and a training job completing is not on the list. Stage one has not run yet; stages two through seven are the plan, not progress.

1. Feasibility. Reproducibly train, serve, identify, and evaluate a text-model adaptation. (NI-0, not yet run.)
2. Behavioral signal. A controlled candidate measurably improves targeted collaboration behaviors against its base.
3. Capability preservation. Without unacceptable loss of general reasoning, tool, or coding ability.
4. Generalization. Gains survive held-out scenarios.
5. Operational usefulness. A candidate does useful work through the actual lab architecture.
6. Tiering. Multiple sized components in different fleet roles, if the evidence supports it.
7. Native operation. Learned intelligence, live context, deterministic authority, routing, and distributed execution work together, so that a request arriving in one place is planned, placed, executed, and verified without me routing it by hand.

The arms

Every project on this site is one of these, and each has its own page.

• The orchestrator: capability-matched scheduling, per-user grounding, standing invariants, canary-first self-deploy.
• Self-engineering: the AI proposes changes to its own orchestrator under human-only promotion.
• The 32B QLoRA and the image and identity work on Mothership: training on a 24 GB card, nine evaluation rounds, a consent-gated adapter registry.
• The library restructure, where the extract, review, and findings spine came from.
• The driver investigation and the 3070 investigation: the two root causes that made the GPU hosts dependable.
• Nursing and law pilots and the conversations suite: the orchestrator serving users other than me.
• The operations agent: chat-driven infrastructure control behind confirm-on-write.
• The ARM cluster, with its model tournament and ensemble experiment.
• The doctrine: the failure classes every agent in the lab is held to.
• The house: energy telemetry, a camera pipeline on the cluster, a voice layer through the orchestrator.
• Media for friends: the first users who are not me, behind a zero-inbound-port front door.
• Games, with one-button server orchestration through the same control surface.

Questions: nickcrowley97@gmail.com. Code, where ready: github.com/drhawktopus.