We do not build "Features" (marketing units). We build "Capabilities" (atomic units of system potential). This shift creates a composable Intelligence Space where functionality is addressable, permissioned, and evolutionary.
To enable an Intelligence Space that can reason about its own abilities, we must formalize what "ability" means.
Every capability must have a unique, stable Identity (ID). If you cannot reference it by ID, it does not exist in the system.
Capabilities exist independently of the Agents that use them. Agents are merely collections of entitled Capabilities.
Capabilities define their dependencies. Complex abilities are built by composing atomic primitives, creating a directed graph of system potential.
A Capability has a lifecycle. It is born as a Concept, matures to Stable, and dies as Deprecated. The system must know where every capability stands in time.
export interface CapabilityDefinition {
readonly id: CapabilityId;
readonly name: string;
readonly domain: CapabilityDomain;
readonly status: CapabilityStatus;
// Behavioral Traits
readonly traits: ReadonlyArray<CapabilityTrait>;
// Architecture
readonly manifestation: CapabilityManifestation;
}We extend the capability model into a recursive systems architecture. Borrowing from Arthur Koestler's Systems Theory, we treat every component as a Holon: a system that is simultaneously a whole (containing subsystems) and a part (of a larger system).
Why does this system exist? Its teleological goal.
How autonomously does it act?
How visible is its internal state?
How does it change over time?
Every component must fulfill a universal contract to participate in the Intelligence Space. This ensures predictable composition and inspection.
interface SystemContract {
// Identity
readonly id: SystemId;
readonly purpose: SystemPurpose;
// Boundary
readonly interface: SystemInterface; // Provides
readonly dependencies: SystemDependencies; // Requires
// Behavior
readonly agency: SystemAgency;
readonly affordances: ReadonlyArray<Affordance>;
// Structure
readonly contains?: ReadonlyArray<SystemContract>;
}The Capability Registry is the single source of truth. It sits between the Code (Implementation) and the Experience (User/Agent).
Controls sidebar visibility and navigation state. Toggle the sidebar to focus on content or reveal navigation options.
Fuzzy-search through all available commands, navigation targets, and actions. Power-user interface for keyboard-first workflows.
Centralized modal and dialog management. Handles opening, closing, and stacking of modal dialogs.
Manages user authentication session lifecycle: login, logout, token refresh, and session persistence.
Access user profile, account settings, and session controls from the header menu.
Non-blocking notifications that appear briefly to confirm actions or report errors. Auto-dismiss with optional actions.
Toggle between light and dark themes. Respects system preference by default with manual override.
Manage user preferences including theme, notification settings, and keyboard shortcuts.
Explore all registered capabilities in the Intelligence Space. Browse the full catalog of features, their evolution status, affordances, and how they manifest across the application.
Your home base within the Intelligence Space. See recent activity, quick actions, and get oriented on what to do next.
Access interactive prototypes for capturing and structuring thought. Tools are evolved from experiments into production-ready features.
Understand the theory and methods behind effective thinking and sensemaking. Guides, tutorials, and conceptual foundations.
Manage your account, preferences, and integrations. Configure the Intelligence Space to match your workflow.
Development-only route for testing shell functionality, toast notifications, and UI components before integration.
A type-safe decision engine for selecting and constructing optimal LLM prompts based on task requirements (Zero-Shot, Few-Shot, Chain-of-Thought, ReAct).
Multi-agent dialogue interface for exploring ideas through conversation. Select one or more intelligence agents to engage with your thoughts.
The ability for the Intelligence Layer to reach outside the conversation context to execute code, search the web, or query the database.
Direct linking to specific Domain Primitives (Files, Thoughts, Users) using the @ symbol. Resolves ambiguity by explicitly binding symbols to their definitions.
Spawning a temporary "Side Conversation" to explore a specific tangent without polluting the main context stream. Merge insights back when complete.
Direct audio stream processing that captures speed-of-thought articulation. Bypasses the "Typing Bottleneck" to allow for rapid dumping of raw mental context.
Create, edit, and configure Councilors—specialized AI personas that assist in dialogue.
Switch between different Councilors during a dialogue session.
Iterate on designed instructions using natural language. Critique the output, and the system analyzes your feedback to mutate the underlying prompt—generating optimized versions for review. Build reusable systemic structures for artifacts like marketing content, code modules, or domain-specific building blocks.
Promote a single agent response from transient dialogue into a permanent Insight. Captured insights become topics on the Landscape Map—a structured knowledge graph connecting your discoveries across conversations.
Decompose a raw thought or message into structured primitives: Intents, Concepts, Tensions, and Invariants. Then synthesize a falsifiable Design Hypothesis—transforming intuition into actionable, testable propositions.
We shift our language from "Static Features" to "Dynamic Capabilities".
"Feature: The User can save files."
"Capability: File System Write Access."
Features describe user benefits. Capabilities describe system permissions.
"Feature Flag: Enable Beta UI."
"Lifecycle: Status = Beta."
Flags are binary toggles. Lifecycles are continuous states of maturity.
"The Pro Plan includes AI Chat."
"Pro Plan grants: capability.dialogue.*"
Plans are bundles of Capability IDs, not lists of marketing terms.
When capabilities are addressable data, Agents can query their own toolset. An agent can ask: "Do I have the capability to search the web?" and adapt its strategy accordingly.
We can compose custom "Agent Profiles" on the fly by mixing and matching capabilities. Create a "Research Agent" by combining [WebSearch] + [NoteTaking] - [CodeExecution].
Security is no longer a blanket "User" check. It is a precise check: "Does Actor X hold the Entitlement for Capability Y on Resource Z?"
The UI can automatically generate "What's New" modals or "Help" tooltips based on the Concept/Description metadata stored in the Capability Registry.
The current type system focuses on Definition. The following aspects are explicit non-goals for the initial registry but are part of the broader system vision:
An atomic unit of system potential. A discrete power that can be granted, revoked, or composed.
Replacing amorphous "features" with addressable data allows the system to reason about itself.
Something that is simultaneously a whole and a part. A basic unit of organization in biological and social systems.
Our "Systems" are holons: complete in themselves, yet parts of larger systems.
The functional goal or teleology of a system (e.g., Presentation, Storage, Behavior).
Allows architectural validation: "A Presentation system should not mutate Storage."
The level of autonomy a system possesses (Passive → Reactive → Proactive → Autonomous).
Critical for distinguishing between dumb UI components and intelligent agents.
The degree to which a system exposes its internal state to the environment.
Enables debugging, monitoring, and "glass box" user experiences.
How a system's state changes over time (Immutable, Configurable, Mutable, Adaptive).
Helps us reason about state management and side effects.
The grant of a Capability to an Actor (User or Agent).
Decouples "what exists" (Registry) from "who can use it" (Policy).
The concrete realization of a Capability in the UI (e.g., a button, a command, a shortcut).
Allows us to track where abstract powers touch the user experience.
The set of all UI locations where a capability is exposed.
Critical for "UI Budgeting"—ensuring we don't overcrowd the interface.
A behavioral characteristic of a capability (e.g., "Destructive", "Long-Running").
Allows the UI to handle capabilities generically (e.g., automatically adding confirmation dialogs).
The immutable, central source of truth for all Capabilities definitions.
The DNA of the system.
A bounded context that groups capabilities (e.g., Dialogue, Landscape, Synthesis).
Organizes the system into coherent mental models.
The evolutionary stage of a capability (Concept → Planned → Stable → Deprecated).
Communicates system maturity and roadmap transparency to the Thinker.
We ground our architecture in established computer science and distributed systems theory.
Modeling components as recursive wholes/parts enables fractal architecture.
Applying service discovery patterns to internal application features.
Granular permissions allow for precise composition of roles and agents.
The system should be able to inspect and modify its own capabilities.
Shifting focus from "User Benefit" (Marketing) to "System Potential" (Engineering).
Mapping abstract capabilities to concrete perceptible affordances.
Modeling components as recursive wholes/parts enables fractal architecture.
Applying service discovery patterns to internal application features.
Granular permissions allow for precise composition of roles and agents.
The system should be able to inspect and modify its own capabilities.
Shifting focus from "User Benefit" (Marketing) to "System Potential" (Engineering).
Mapping abstract capabilities to concrete perceptible affordances.