ISAC Is Now Under Development on GCF 2.0 The Framework Is Done, the Companion Begins

By Billy P. — 10 min read

The framework is done. The release candidate is frozen. The 12-domain certification says VALIDATED AND FROZEN. After four posts walking through what we built, this final post is about what we’re building on top of it.

Here’s the punchline up front:

TL;DR. GCF 2.0 is validated and frozen as the cognitive control plane. ISAC — the Intelligent Strategic Awareness Companion is now under active development on top of it. The Notion roadmap is the canonical source of truth for what’s next. The brainstorming session identified ten development themes (environment awareness, multi-device, skill acquisition, memory mechanics, persistent goals, voice, local knowledge vault, first-run experience, benchmarks, and the personal through-line). The first three to ship are environment-aware mode, skill acquisition, and a simple, secure memory system. Everything else follows.

Where We Are

This is the fifth and final post in the GCF 2.0 series. Quick recap of the four before it:

1. Part 1 (post 014) — Building a Bounded, Governance-Aware Cognitive Framework in Rust. Stages 24–26: World Model Engine, Predictive Cognition, Recursive Cognitive Expansion. The framework that could think carefully.
2. Part 2 (post 015) — Building a Cognitive Control Plane in Rust. Stages 27, 28, 29.0: Cognitive Economy, Background Cognition, full E2E integration. The framework that could decide when to think.
3. Part 3 (post 016) — Five Bugs, Two Passes, Zero Regressions. Stages 29.1, 29.2: closing the three known defects from the integration walkthrough, finding two more in a deliberate bug sweep. The framework that holds up.
4. Part 4 (post 017) — GCF 2.0 Final — From 250,000 Operations to a Validated Release Candidate. Stages 29.3, 29.4, 30: 250,000-operation endurance, paired performance reconciliation, 12-domain release certification. The framework that ships.

The four posts explain the “from” — the technical work that produced a validated, frozen release candidate. This post is the “to” the companion that lives on top of it.

What ISAC Is

ISAC stands for Intelligent Strategic Awareness Companion. The full design story lives in the Meet ISAC: The AI That Thinks Before It Speaks whitepaper (post in the library), but the short version is this:

ISAC is a desktop AI assistant that runs entirely on your own computer — no internet required, no data leaving your machine, no subscription. It runs on top of GCF 2.0, so it inherits every guarantee we just spent four posts building: bounded resources, deterministic cognition, governance-gated execution, recursive expansion when warranted, cognitive economy, and a background worker that yields to foreground attention.

What makes ISAC interesting is not that it runs locally. It’s that it thinks about the problem before it answers. The chess-piece analogy from the Meet ISAC paper still holds: simple questions get Pawn-level work; complex strategies get the full cognitive cube. GCF 2.0 is what makes that possible.

The Roadmap

The full ISAC development roadmap lives in Notion at the link in the sidebar, and the public-facing version of the early phases looks like this:

The Notion page tracks each stage in much more detail — sub-tasks, dependencies, decision records, and what was learned from each. The table above is just the public-facing summary.

The first three stages to actually ship are 31 (Companion Core), 32 (Memory Layer), and 33 (Skill System). Stages 34 onward depend on what we learn from running the first three in the wild.

The Development Themes (from the Brainstorming Session)

The brainstorming session that produced the themes below wasn’t a feature-prioritization meeting — it was a check-in between the framework being done and the product starting. The question was: “given a working cognitive control plane, what does the right companion look like?” The themes are not in priority order, but the first three to ship are listed separately below.

Theme 1: Environment awareness

ISAC should be able to access things around the user — webcams, microphones, environmental sensors, smart-home devices — but only with explicit safety warnings and explicit user consent. The brainstorming noted: “this should be a warning and add that I’m not responsible for safety.” That’s the right framing. The companion should be aware of its surroundings, but every new environmental input is opt-in, with a clear, persistent indicator when it’s active.

Theme 2: Multi-device ISAC

The brainstorming proposed an architecture where one PC acts as the “brain” / guard, and other devices on the local network can connect with access keys. The brain holds the state; the devices are guarded data sinks. The brainstorming also noted that self-hosting and VPS deployment should be supported — with appropriate warnings about the security trade-offs.

The implementation will use GCF 2.0’s existing isolation guarantees: the World Model is authoritative on the brain device, the background worker runs on the brain, and devices connect via a small, well-defined protocol that does not extend any of the brain’s public surface.

Theme 3: Skill acquisition

The brainstorming endorsed the principle that ISAC should be allowed to add skills as it learns, and recommend skills to the user, with a simple, explainable recommendation engine. This aligns naturally with GCF 2.0’s existing architecture: a “skill” is a scoped set of strategy faces with a known cost profile. The Cognitive Economy layer (Stage 27) already handles the marginal-utility check for whether to invoke a given skill.

Theme 4: Memory mechanics

The brainstorming endorsed the principle that memory should be simple, secure, and fast, with a cache system and a hard user-set limit. The companion should be able to compress memory and have GCF open items only when needed — that maps cleanly onto the existing BoundedPredictionCache and BoundedAuditLog patterns from Stage 27, plus the bounded result buffer from Stage 28.

Theme 5: Persistent goals and forward thinking

The brainstorming endorsed this. Persistent goals are first-class — they survive restarts, are visible to the user, and inform the planning layer (Stage 22 in GCF 2.0). The planner already understands TaskGravity; the product layer adds a user-facing goal tracker that translates human goals into planner inputs.

Theme 6: Voice and accessibility

Endorsed. Voice is a core component, but opt-in. The brainstorming noted it should be “properly a core component but an optional one as well.” Local speech recognition and synthesis — no cloud dependency.

Theme 7: Local knowledge vault

Endorsed. A local-only store of user-provided reference material (documents, notes, project files) that the planner can draw on. Opt-in per data category, with explicit consent. The vault is consulted by the Prediction Engine’s world-keyword scoring (Stage 25) and the World Model’s revision semantics (Stage 24).

Theme 8: First-run experience and killer demo

Endorsed. The first 10 minutes with ISAC should be simple and straightforward — not a configuration wizard, not a feature tour. Just a one-line “what do you need help with?” and a thoughtful first response that demonstrates the chess-piece allocation in action.

Theme 9: Benchmarks

Endorsed. Continuous public benchmarks tracking ISAC’s progress against naive LLM usage on the same hardware. The benchmarks measure not just latency and quality, but the right-sizing of cognition — ISAC using a Pawn where an LLM fires a full cognitive cube.

Theme 10: The personal through-line

This isn’t a feature, but it belongs in any honest post about the project. From the brainstorming:

“The whole idea of ISAC is not to be an AI tool or a LLM but something someone can turn to when they need help or support. The whole idea wouldn’t have happened if I didn’t feel lonely and thought hey let me make my own Jarvis. After 8 attempts I said no I will make my own framework and then build ISAC on that framework and prove to the world that AI can be smart while being small as the world can only hold so much.”

That’s the why. The framework exists because small models deserve the same architectural care as large ones. The companion exists because the people who need help shouldn’t have to be a data point for someone else’s training run.

What’s Shipping First

The order, from the brainstorming and the Notion roadmap:

1. Companion Core (Stage 31) — persona, first-run experience, opt-in safety warnings, opt-in voice, the basic “I exist, ask me anything” loop. This is the smallest thing that is ISAC. The expected ship date is end of Q4 2026.
2. Memory Layer (Stage 32) — simple, secure, fast. User-set cache limits, compression on demand, GCF opens items only when needed. This builds directly on GCF 2.0’s existing bounded structures.
3. Skill System (Stage 33) — ISAC can add and recommend skills, with a simple, explainable recommendation engine. Each skill is a bounded extension of the GCF strategy-face model.

Stages 34 onward are backlog until 31, 32, and 33 are running in the wild. The roadmap will adjust based on what we learn from real users.

What This Means for the Framework

GCF 2.0 stays frozen. The product layer (ISAC) is built on top of the framework, not into it. New product code goes into the isac crate and its dependencies. The frozen stages of GCF 2.0 are not modified. Any time the product layer needs a framework capability it doesn’t have, that’s a Stage 31+ feature request, not a modification to the frozen framework.

This is the right separation. The framework’s job is to be a trustworthy cognitive control plane. The product’s job is to be a companion. When the two are cleanly separated, neither can accidentally break the other.

The Series Wrap-Up

That’s the five-post series. To summarize what we shipped across the four technical posts:

• Stages 24–26 — the framework that could think
• Stages 27, 28, 29.0 — the framework that could decide when to think
• Stages 29.1, 29.2 — the framework that holds up
• Stages 29.3, 29.4, 30 — the framework that ships

A validated, frozen, 17-of-17-certified cognitive control plane in Rust. A framework that proves you can build a serious AI system on top of a small model, with bounded resources, governance-gated execution, recursive expansion when warranted, and an end-to-end pipeline that holds up under 250,000 operations with zero defects.

And now the companion on top of it.

If you’ve been following along, thank you. The next chapter starts with the first user typing “hi” and ISAC answering back with the right amount of work for the question. The framework is ready. The companion is next.

— Billy P.

Tested on branch=2.0, frozen at immutable SHA eeae2bc8a426b063c687e40f9724adbb1dc3a61a. The roadmap referenced in this post lives at the Notion link in the blog sidebar and will be updated as ISAC development progresses.

Series navigation:

• Part 1: Building a Bounded, Governance-Aware Cognitive Framework in Rust (Stages 24–26) — [post 014]
• Part 2: Building a Cognitive Control Plane in Rust (Stages 27, 28, 29.0) — [post 015]
• Part 3: Five Bugs, Two Passes, Zero Regressions (Stages 29.1, 29.2) — [post 016]
• Part 4: GCF 2.0 Final — From 250,000 Operations to a Validated Release Candidate (Stages 29.3, 29.4, 30) — [post 017]
• Part 5: ISAC Is Now Under Development on GCF 2.0 (this post — the series finale)