IKA Concierge Architecture

IKA versions + subdomain inventory

Frontends — IKA app lineage

Version	Stack	URL	Status
v1 (BI seed)	Vanilla HTML+JS+Three.js	dev-graph.ika.ai	Original BI dev that became msp's prompt bar / agent BI. Historical reference.
v2	Flutter (Dart)	dev-v2.ika.ai · v2.ika.ai	Frozen historical snapshot; reference only.
v3 (msp)	Vanilla HTML+JS+Three.js	msp.ika.ai	Final client-presentation build, frozen.
v3 (main)	Vanilla HTML+JS+Three.js	main.ika.ai	Active build target. Phase 1 hybrid mount; Phase 2 full React after Phase 1 ships.
v3 first dynamic tenant	Per-tenant deploy	<first-dynamic-tenant>.ika.ai	Slot is TBD.

Sister apps — non-BI IKA properties

Subdomain	What it is	Live status
intur.ika.ai	INTUR app (separate product)	Live
queplan.ika.ai	QuéPlan app (separate product)	Live
bench.ika.ai	Bench / benchmarking surface	502 — needs systemd unit on 8080.
rover.ika.ai	Rover landing	No DNS; likely retired.
dev-pz.ika.ai	PZ dev surface	530 — Cloudflare origin error.

Backend / supporting subdomains

Subdomain	Purpose	Live status
dev-api-v2.ika.ai	Backend API (Go @ :3044 via Cloudflare tunnel)	404 at root; functional under /api/...
dev-ws-v2.ika.ai	WebSocket / Socket.IO endpoint (gosf @ :9999)	Tunnel TCP-mode breaks real WS clients. Switch to HTTP + enable WebSockets in CF dashboard.

"IKA" means v3 unless explicitly stated. All forward development branches off main.

Active artifacts — the on-the-fly pages we've built

Every HTML page below is an artifact per the v25 spec — created via agent tool call, lives at a stable URL, owned by one neuron. Once the React Operations shell ships, each row becomes a tracked artifact entity in its owning neuron's grid (Row 5 of the 13-cell layout). For now they're directly on disk under build/web/bi/main/<name>/ and build/web/intur/....

URL	Title	Owning neuron (target)
main.ika.ai/ika-pro-architecture/	IKA Concierge Architecture (this page) — single source of truth for the v3 build. URL slug pending rename.	main / Engineering / Architecture
main.ika.ai/graphify/	Knowledge-Graph Tools — Comparison + Recommendation for IKA	main / Engineering / Research
main.ika.ai/ika-pro-architecture/#gstack	gstack vs IKA — Findings	main / Architecture
main.ika.ai/ika-pro-architecture/#hermes	Hermes Agent (Nous Research) vs IKA — Findings	main / Architecture
main.ika.ai/ika-pro-architecture/#karpathy	Andrej Karpathy — what to adopt for IKA	main / Architecture
main.ika.ai/ecc/	ECC (Everything Claude Code) — analysis for IKA Concierge	main / Architecture
main.ika.ai/odysseus/	Odysseus (self-hosted AI workspace) — what to adopt for IKA	main / Architecture
main.ika.ai/skills/	Anthropic Knowledge-Work Plugins — what to adopt for IKA Concierge	main / Architecture
main.ika.ai/superpowers/	obra/superpowers — engineering-discipline meta-skills, what to adopt for IKA Concierge	main / Architecture
main.ika.ai/ika-pro-architecture/#tokens	Token Optimizer Analysis — RTK + Alternatives	main / Architecture
main.ika.ai/ika-pro-architecture/#lab	IKA Lab — experimental BI shell	main / Architecture
main.ika.ai/design/	IKA — Design System	main / Design
intur.ika.ai/	IKA — INTUR (sister-product landing)	intur / root
intur.ika.ai/v2/	IKA — INTUR · v2 (Respuestas a Consultas)	intur / Proposals
intur.ika.ai/design/	IKA — Design System (INTUR mirror)	intur / Design
msp.ika.ai/agents/	IKA — MSP AI Agents (proposal)	msp / Sales / Proposals
main.ika.ai/pnud/	IKA Converter — PNUD Honduras (client tool)	main / Clients / PNUD
msp.ika.ai/prompts/	IKA · MSP Sitemap — Prompts & Destinations	msp / BI / Sitemap
main.ika.ai/steering/	IKA Steering — Two Brains, One System	main / Architecture
main.ika.ai/infra/	IKA Infrastructure	main / Engineering / Infra

Subdomain root rule: msp.ika.ai is served from /home/dev/ika/build/web/bi/ (the bi/ root). main.ika.ai is served from /home/dev/ika/build/web/bi/main/. Same code, different roots. So /agents/, /prompts/, /design/ live under msp's root only and must be linked at msp.ika.ai/<path>/; /pnud/, /steering/, /infra/ were moved to build/web/bi/main/ in v25.8 and now serve only on main.ika.ai. The main subdomain falls back to its SPA index for any path it doesn't have on disk. Rows above are linked at the URL that actually serves the file.

When a new artifact is created during the build (e.g. Mats asks IKA for a "report on X" → IKA produces an HTML artifact under the relevant neuron — see Auto-routing in the Artifacts section), its URL appears here automatically once the Artifacts grid is wired in Phase 1B / Sprint 2.

One product, two shells: BI (outer) and Operations (inner). Same URL, one hard toggle in chrome flips between them. BI can be turned off per-tenant. Both shells share one stack.

• React — Paperclip's existing UI is React; massive hiring pool; react-three-fiber for the icosahedron; every plugin we picked has a React wrapper.
• Vite — fast dev, code splitting, lazy routes.
• TypeScript — type safety at prosumer scale.

Multi-IKA per user

Target market is prosumer. A single user spins up multiple IKAs:

• N Business IKAs — one per company they run.
• N Personal IKAs — one per life context (own life, household, kids' activities, hobby club).

Tenant identity = {user_id, ika_id, scope: business|personal}. Isolation enforced by schema per IKA in one Postgres cluster + Row-Level Security policies. One PgBouncer transaction-pool serves all IKAs; RLS is the floor under every query so a missed WHERE clause still denies the row. Cross-IKA Builder feed and global search are joins inside one cluster.

Fractal UI — neurons all the way down

Every neuron contains sub-neurons, recursively. Soft cap at depth 6; agents see depth 0–3 ancestors + current + immediate children unless explicitly asked.

Every level is a "neuron" — same shell, same entity slots, same agents, same governance. Data model: neuron.parent_id → neuron.id. UI is one component that recurses. Loading is lazy per level.

13 first-class entities (per neuron)

• Sub-neurons — recursive containers.
• People — humans in the loop.
• Agents — per-neuron + global per-IKA AI workers. Can be assignees, never leaders.
• Projects — multi-task containers with phases.
• Tasks — atomic work units, assigned to people OR agents.
• Events — calendar items.
• Documents — files attached via Uppy + Companion.
• Notes — block-editor (BlockNote) free-form context.
• Forms — agent-driven typed data collection.
• Integrations — per-neuron MCP / API connections (inherits down).
• Skills — per-neuron capability bundles (inherits down).
• Automations — recurring agent-driven workflows (inherits down).
• Artifacts — created HTML pages owned by a neuron.

Tagline: "Their own JARVIS, IKA." One harness, N IKAs per user, fractal UI all the way down.

Core principle: every entity is draggable. Drop one onto another and the receiver becomes the container. Same gesture everywhere. Drag-and-drop is ADDITIVE — every entity also has "+ create child" UI.

Inside a neuron

Open any neuron and the body shows lists side by side (Sub-neurons · People · Agents · Projects · Tasks · Events · Documents · Notes · Forms · Integrations · Skills · Automations · Artifacts). Each list has its own search bar, "+" button, and drag-drop targets.

Drop matrix

Drag this →	onto Project	onto Task	onto Event	onto Neuron	onto Person
Project	No nested projects	—	—	Move project to neuron	—
Task	Assign to project	Make sub-task	—	Move to neuron	Assign to person
Event	Attach to project	Attach to task	—	Move to neuron	Invite to event
Note	Attach	Attach	Attach	Attach	Attach
Document	Attach	Attach	Attach	Attach	Attach
Person	Add to team	Assign / add to participants	Invite	Add to neuron	—
Person → Note · Person → Document · Person → Form · Person → Artifact: Add as participant / collaborator. Drag a person onto any element and they're attached. Same gesture everywhere.
Agent	Bind to project	Assign task	Bind to handler	Bind to neuron	—
Neuron	—	—	—	Becomes sub-neuron	—
Artifact	Cross-reference	Cross-reference	Cross-reference	—	—

Sole exception: projects cannot be dropped into other projects.

Cross-listing rule

When a task is assigned to a project, it appears in BOTH the project's list AND the neuron's outer task list. Same applies to events attached to projects/tasks, notes/documents attached to anything. Container relationship is data; listing is UI — one truth, multiple views.

Implementation

Frontend: @dnd-kit/core or react-dnd. Backend: each entity has polymorphic container_type + container_id. Drop = PATCH the container fields.

/#/<ika>/layer2[/<neuron-path>...][/<entity-type>/<slug>][?tab=<data|timeline|calendar>][&phase=][&subtask=][&drill=]

Builder is the agent-driver overlay used by Mats + IKA team to drive every tenant. End-user prosumers never see it.

Property	Decision
Shape	Single builder.js + builder.css overlay bundle. Sandboxed iframe with strict CSP and DOMPurify for any agent-rendered HTML.
Stack	Vanilla. Stays vanilla forever. Same bundle on every host (vanilla + React). Host-agnostic.
Visibility	Admin-only. Server-side conditional script-tag emission based on /api/v1/auth/me role. Non-admin sessions never download the bundle. Per-tenant toggle is belt-and-suspenders.
Backups	Snapshot the IKA frontend (HTML or React build) AND pin the Builder bundle version active at snapshot time. Builder DATA is always live — never frozen by backups.
God view	Separate route at builder.ika.ai for super-admin only. Side-by-side Builder instances, one per tenant. Same bundle, N data scopes.
Per-user scope	One Builder panel per admin, aggregating tasks/feed/Q&A from every IKA the user owns (filter chip per IKA). Cross-IKA isolation preserved at data layer.

designs may be outdated The screenshots below describe load-bearing card anatomy + behavior. Pixel-level visuals may be out of date until Mats's design refresh lands; spec text is authoritative.

Every entity card / content panel (task, event, project, neuron, note, document, form, person, agent, automation, skill, integration, artifact) opens as an overlay panel at chrome z-index — same portal as the v22 entity card, extending its behavior. Reference UX matches the "Project view (full)" screenshot above (which carries the designs may be outdated note — Mats also has updated screenshots of the content panels — project view full, task panel, event panel, etc. — coming; current entity-panel-behavior subsection is implementation-spec'd from his verbal description and pixel-level visuals will be added when screenshots arrive).

Behavior	How it works
Draggable	Header is the drag handle. Mousedown / touchstart on header → move via translate(x,y). Position persists per-user per-entity for the session (resets on app reload) via sessionStorage keyed by entityType + entityId.
Collapsible (accordion)	Chevron in the header toggles a .collapsed class. Collapsed = title bar only (~40px); expanded = title bar + full body. max-height transition, 200ms ease. Multiple panels can be open simultaneously and collapse independently — useful when juggling several tasks/events with one expanded at a time.
Extendable (drag-resize)	Bottom-right corner has a resize handle (Builder-feed style) via vanilla CSS resize: both on the panel container. Min 320×200; max = full viewport. Sized state persists per-user per-entity-type for the session.
Close	Click outside OR the X in the header.
Composes with cross-tab focus	Dragging or collapsing never changes the active tab. The "Show on Timeline" / "Show in Data" button works regardless of panel position or collapsed state.

Implementation: vanilla CSS resize: both for the corner handle + a small drag-listener on the header for translate; collapse = JS class toggle; persistence via sessionStorage.

The full color-token reference (sage #b5d5c8, gold #e6be64, dark base #0e1014/#161a22) lives at msp.ika.ai/design/. This section codifies the texture + state vocabulary that load-bearing chrome uses across the v3 build, so Path C engineers can paste it verbatim.

i) Textures — 7 surface tokens

Token	Background	Border	Radius	Use
Glass Panel	rgba(12,12,16,0.75) + blur(30px)	1px white/0.08	20px	Main content panels. Soft drop shadow.
Modal Surface	rgba(14,17,22,0.97) + blur(12px)	1px sage/0.12	16px	Modals, confirmations, identity.
Card Surface	rgba(255,255,255,0.03)	1px white/0.06	14px	ika-card / usecase-card / team-card.
Quote Block	rgba(181,213,200,0.04)	3px sage left border	0/12/12/0	Pullquotes.
Featured Card	rgba(181,213,200,0.06)	1px sage/0.15	14px	Discovery + featured surfaces.
Gold Featured	rgba(230,190,100,0.04)	1px gold/0.2	14px	"Llave en mano" + special elements.
Cursor Glow	radial-gradient(circle, rgba(181,213,200,0.06) 0%, transparent 70%)	1px white/0.06 dashed	—	Cursor-following soft glow.

ii) Sunken area pattern

Used for gate input fields, recessed input wells, anything that should feel "pressed in" / inside the surface. Same dotted radial-gradient texture as the canonical gate-pass input.

.sunken {
  background: rgba(10,10,12,1);
  background-image: radial-gradient(rgba(255,255,255,0.04) 1px, transparent 1px);
  background-size: 6px 6px;
  box-shadow:
    inset 4px 4px 12px rgba(0,0,0,0.8),
    inset -4px -4px 12px rgba(255,255,255,0.05);
  border-radius: 12px;
}

iii) Active-state outline gradient

When a summary box (KPI tile, donut card, dashboard cell) becomes active (focused / pinned / selected), it gets a 1px conic-gradient outline that animates. The base box stays the Card Surface; only the outline gains the gradient. Drop back to the static 1px white/0.06 border when inactive.

.summary-box.active {
  border: 1px solid transparent;
  background-image:
    linear-gradient(var(--card-bg), var(--card-bg)),
    conic-gradient(from 0deg,
      rgba(181,213,200,0.4),
      rgba(230,190,100,0.4),
      rgba(181,213,200,0.4));
  background-origin: border-box;
  background-clip: padding-box, border-box;
  animation: spin-outline 4s linear infinite;
}
@keyframes spin-outline {
  to { --angle: 360deg; }
}

Color tokens (sage / gold / dark base) and the full type ramp are documented at /design/ for the canonical reference; this section is the texture + state delta that didn't fit there.

Two-tier model:

Tier	What it is
Form Template	Reusable structure: list of typed fields, sections grouping them, default values, validation. Versioned.
Form Submission	A specific filled instance bound to a context entity (task / event / project / neuron). Carries answers + assignee + completion timestamp.

Field types

Date · Dropdown · Checkbox · Text · Title · Paragraph. Sections group related fields. Save Data submits.

Schema

• form_templates — id, neuron_id, name, sections JSON, version, created_by, created_at.
• form_submissions — id, template_id, template_version, context_entity_type, context_entity_id, assignee_id, answers JSON, status, submitted_at.

Source: "Timeline Algorithms" by Eng. Alvaro Hurtado Maldonado + Mats's verbal rules. Caveat: the v2 Flutter reference implementation had bugs — vet every algorithm before lifting; re-derive from the Hurtado PDF anything we can't verify.

1. Postulates (14)

#	Postulate
1.1	2D canvas: X = time, Y = rails (one entity per rail or shared by non-overlapping siblings).
1.2	User-specific view: each user sees their own assigned entities.
1.3	Hierarchical (projects + tasks). Parent's start/end auto-spans children.
1.4	Drag-and-drop. Parent drag = children move with it. Drag child outside parent = dissociate.
1.5	Anti-collider shifts elements along X-axis to resolve overlaps within a rail.
1.6	Resize parent = children auto-fit. Resize causing collision = shift conflicting elements without altering durations.
1.7	Initial state: only top-level shown; children load on expand.
1.8	Five zoom levels: Month · Week · Day · Hour · Minute.
1.9	Two-finger drag = pan. Pinch + mouse-wheel = zoom. Wrap with @use-gesture/react.
1.10	Left-side scroll indicator showing position within tracks.
1.11	Up to 10 extra rails available below visible tracks; created dynamically.
1.12	Continuous track: rails as floats (-8, 2, 5.5, 19), rendered as discrete integers.
1.13	External drag-drop integration (in/out of timeline).
1.14	Element creation from frontend or backend. Default duration = 1 day.

2. Rail algebra

Add at START → new_rail = first_rail − 10
Add at END → new_rail = last_rail + 10
Add BETWEEN two rails → new_rail = (prev_rail + next_rail) / 2   (interpolation)

3. Drag operations — 4 cases

Case	What happens
Drag to same object	Changes start date only; duration preserved. For parent entities, system prompts confirmation before moving parent + children.
Drag to existing rail receiver	Element assigned to existing rail. Lane-sharing for non-overlapping consecutive elements.
Drag to new rail (between two)	Creates new rail via interpolation (prev + next)/2. Elements below shift down by one.
Drag to neuron	Entity becomes part of target neuron.

4. Anti-collider

Scenario	Resolution
Future collision	Shift the dragged element forward in seconds until clear; recursive on subsequent collisions.
Past collision	Past element stays fixed; dragged element re-positioned.
Existing element clashes with newly-dragged	Move existing future element forward (preserves user's drag intent).
Hierarchical scope	Collision logic considers both X-axis time AND Y-axis rails; for parents, accounts for entire range of parent + children.

5. Element creation — 4 paths

Path	Behavior
Frontend (user click/drag)	getAvailableSlots finds free positions at start/end/within parent.
Backend autogenerate (automation)	Get parent's rail (railA) → next element's rail (railB) → place at (railA + railB)/2 if railB exists, else railA + 0.1.
Backend standard generate (new parent)	Place parent on last available rail + 0.1 offset; +0.2 per child.
Voice command creation	Same anti-collision logic; auto-shifts on collision.

6. Anti-unnecessary-space

When a new rail is created during drag/insertion, the system shifts elements UPWARD to close visual gaps while preserving parent-child hierarchy.

7. Priority module

Priority	Default placement
High	As CLOSE as possible to the current date.
Medium	Balanced placement.
Low	Placed FURTHER into the future.

Reciprocal: when an element is created far in the future without explicit priority, auto-assign LOW. Manual override always wins. Priority can auto-promote as deadline approaches.

8. Habits — recurrence as property (not new entity)

Recurrence is a PROPERTY on existing Tasks / Events / Form Templates. iCalendar RRULE shape (frequency / interval / byday / until / timezone). Each recurrence generates occurrences rows materialized lazily (on view, not on create) to bound storage. Edits propagate to future occurrences only by default; user can choose "edit just this one" / "edit all future" / "edit all".

Everything you can do via clicking or dragging in Operations should be doable by voice. Full scope: 12 entities × 8 operations × pronouns × undo × cross-session continuity. Implemented in waves.

Entity × operation matrix

Entity	Create	Read	Update	Delete	Move	Assign	Share	Set property
IKA	"create a new business IKA called Acme"	"open my Acme IKA"	"rename current IKA to Acme Corp"	"delete the Old IKA"	—	—	"share with carlos@…"	"set time zone to CST"
Neuron	"create a sub-neuron called Sports"	"open Sports"	"rename Sports to Athletics"	"delete the Empty neuron"	"move Basketball under Athletics"	—	"share Sports with my coach"	"set Sports' icon"
Project	"create project Q3 Launch in Marketing"	"open Q3 Launch"	"extend Q3 Launch by 2 weeks"	"delete Old Campaign"	"move Q3 Launch to Operations"	"add Carlos to team"	"share with the agency"	"set priority high"
Task	"create task Buy domain in Q3 Launch"	"what tasks are overdue?"	"push to next Friday"	"delete Acquire domain"	"make this a sub-task of Launch Plan"	"assign to Mats" / "assign to marketing agent"	"share with the contractor"	"mark complete" / "make recurring weekly"
Sub-task	"create sub-task Check pricing"	"find sub-tasks of Acquire domain"	"rename Check pricing"	"delete Check pricing"	"move Check pricing"	"assign to Carlos"	—	"mark complete"
Event	"create event Demo Friday at 3pm"	"what events today?"	"reschedule to Monday 10am"	"delete cancelled meeting"	"attach to Q3 Launch"	"invite Carlos"	"share externally"	"make recurring monthly"
Note	"create note Client feedback"	"find notes about INTUR"	"append to Client feedback"	"delete empty draft"	"attach to Q3 Launch"	—	"share with Carlos as Read"	"set permissions to Edit"
Document	"upload from desktop"	"find the brief PDF"	"replace with new version"	"delete outdated PDF"	"attach to task"	—	"share with the agency"	"set Read-only"
Form	"create Customer Interview form"	"show submissions from last month"	"add a Date field"	"delete unused form"	"attach to all Sales projects"	"send to Carlos"	"share with the agency"	"make recurring weekly"
Person	"add Jane Doe, jane@…, role Designer"	"find Carlos"	"update Jane's role"	"remove Jane"	"add to Marketing"	—	—	"set permissions to Full"
Agent	"create agent for Sales"	"what agents are running?"	"update Marketing agent prompt"	"deactivate unused agent"	"bind to all sub-neurons"	"assign task to Sales agent"	—	"set monthly budget to $500"
Automation	"create automation that posts daily standup at 9am"	"what automations in Sales?"	"change to 10am"	"disable broken automation"	"move to a different project"	"assign failure handler to Mats"	—	"pause for a week"

Conversational continuity (pronouns + context)

Pattern	Resolution
"create a task here"	Container = current neuron in the user's view.
"move it to ProjectY"	"it" = most recently created/edited entity in this turn.
"and add a sub-task: …"	Parent = the task we just created.
"do the same in HR"	Repeat previous operation with container = HR neuron.
"undo"	Revert last operation within voice session.

Confirmations + safety

Operation class	Policy
Create / Update / Move	Echo and execute. Tentative-placement applies.
Read	Show results.
Delete	Always confirm. Soft-delete to Recycling Bin with 5s undo toast.
Share / external recipient	Confirm recipient + permission level; triggers second-opinion if enabled.
Money / identity / permission changes	Always confirm + always second-opinion (non-bypassable).

OPS_MAP — per-IKA item map

One JSON file per IKA (operations_item_map.json) loaded into a global OPS_MAP on app boot, hot-patched over WebSocket on every CUD. Indexes: neurons · projects · tasks · events · notes · documents · forms · people (with platform_person_id) · agents · integrations · skills · automations · artifacts · vocab · aliases. Resolver runs in pure JS (<5ms exact + Levenshtein-≤2 fuzzy match) — zero LLM token cost on resolution.

SPINE — cross-IKA addressing

user_ika_spine.json per user, loaded once at login (~<100KB even for 10 IKAs). Indexes: ikas · top_neurons (depth 0–1) · favorites (top-30/IKA by frequency) · recent (last 50 across all IKAs) · people_federation (one row per real human via platform_person_id) · shared vocab. Resolver: three concentric tries — local OPS_MAP → SPINE → server-side resolver. Cross-IKA confirmation toast always echoes destination IKA name.

Tentative-placement pattern — never lose voice input

Voice utterance → IKA picks best guess → entity is persisted immediately with a tentative flag → confirmation modal appears as a passive toast → if dismissed/ignored, entity stays at IKA's best-guess location with a "does this belong here?" badge until reviewed.

Trigger	Badge
Cross-IKA placement	"Placed in Personal — does this belong here?"
Ambiguous neuron	"Placed in Marketing (also matched: Sales, Operations) — right home?"
Missing container	"Saved to Inbox — move to a project?"
Unparseable slot	"Couldn't parse 'next-next Tuesday-ish' — set a date?"
Cross-IKA assignee	"Assigned to Carlos (Acme) — same Carlos?"
Bulk dump	"5 tasks created — review placements?"

Schema: every CUD-able entity has tentative (bool) + tentative_reason + created_via_voice (raw utterance). Bulk-review surface: "Tentative items" view per IKA + global "Tentative across all my IKAs" view in chrome.

Implementation

• Classifier gate first — every voice utterance hits classifyPrompt(); identity short-circuit fires before the classifier on BOTH typed AND voice input. Voice owns STT + the post-classifier executor; everything between is shared with text.
• STT — existing IKA voice. Identity short-circuit voice ack: "soy IKA, …" spoken back, <IkaIdentityModal> opens visually.
• NLU — Claude Sonnet with tightly-scoped system prompt + JSON schema response. Cached prompt prefix (Layer 1).
• Resolver — pure JS over OPS_MAP / SPINE; <5ms.
• Validator + executor — server-side in Paperclip; ACL via RLS.
• Map rebuild — Paperclip recomputes per-IKA map on every CUD; debounced 250ms; pushed over WS.

The prompt bar treats IKA as a CLI. The Conversation Surface makes IKA a conversational entity the user can talk to — knows where they are in the UI, what they just did, who they are, and can both talk and act.

You wrote about this on 2026-03-12 — open that note, or generate fresh anyway?

  → "Q3 launch retrospective" (assessment, Marketing / Brand-launch, 4 backlinks)
    [Open]  [Generate anyway]

Every CUD-able entity (task · event · project · neuron · note · document · form · person · agent · automation · skill · integration · artifact) has a pin button that adds it to the user's MyPanel — the home dashboard / launch view that already exists in BI.

Behavior

• Per-user, cross-IKA. Lives in platform.user_pins(user_id, entity_type, entity_ref, ika_id, pinned_at, sort_order).
• Unpinning removes from MyPanel without touching the entity itself.
• UI: pin icon on every entity card and row; toggles. Voice: "pin this" / "unpin this".
• MyPanel renders as a 3-column grid mixing entities from any IKA. Clicking takes you into the host IKA + neuron.
• Briefings can pull pinned items as priority context.

Schema

• platform.user_pins(user_id, entity_type, entity_ref, ika_id, pinned_at, sort_order) — composite PK on (user_id, entity_type, entity_ref, ika_id).
• RLS: user_id = current_user_id().
• Endpoint: POST /api/v1/user_pins · DELETE /api/v1/user_pins/:id · GET /api/v1/user_pins (returns full hydrated list across IKAs the user can read).

Every CUD-able entity has a delete button that sends the entity to a per-IKA Recycling Bin. Not a hard delete.

Soft-delete shape

• Row gains deleted_at TIMESTAMP NULL + deleted_by UUID.
• Default queries filter WHERE deleted_at IS NULL.
• Recycling Bin is a chrome surface (per-IKA) showing deleted items grouped by type with restore / permanently-delete actions.
• Auto-purge: entries older than 30 days hard-delete (configurable per-IKA in Settings).
• Cascading deletes on recursive entities — deleting a project soft-deletes its tasks; restoring the project restores them.
• RLS-respecting (you only see deleted items from IKAs you can read).
• Soft-deleted items don't get tentative flags — the two patterns don't combine.

UX

• Delete button on every entity card / row.
• On delete: 5-second toast "deleted (in Recycling Bin)" with an Undo button that restores immediately.
• Voice: "delete this" → soft-delete + 5s undo toast. "restore X" / "show recycling bin".
• Recycling Bin chrome surface lists deleted items grouped by type with row-level Restore / Permanently delete buttons.

Endpoints

• DELETE /api/v1/ops/:type/:id — sets deleted_at = now().
• POST /api/v1/recycling/restore/:type/:id — sets deleted_at = NULL; cascades to soft-deleted children.
• DELETE /api/v1/recycling/purge/:type/:id — hard-delete.
• GET /api/v1/recycling/:ika_id — list deleted items in this IKA.

Every project has phases as first-class structure. Default phases:

1. Initiation
2. Definition
3. Research
4. Planning
5. Design (when applicable)
6. Development
7. Implementation
8. Follow-up

Phases are user-customizable per project. Each phase contains its own slice of tasks / subprojects / people / events / docs / automations. The phase ribbon at the top of the project view scrubs across phases; tasks within a phase aggregate up to the project-level "% Completed" radial.

Schema: phases table with project_id, order, name, start_date, end_date. Items reference phase_id (nullable).

Every Task / Project / Event carries a priority: High / Medium / Low. Used for:

• Sorting in lists (High first by default)
• Agent decision-making (when allocating budget across tasks, High wins)
• Notification thresholds (High pages humans; Low collects in digest)
• Timeline placement (High = near current date; Low = further future)

Schema: priority enum on tasks/projects/events. Default Medium.

Pomodoro tracks how much time the user is focused on their tasks overall — global flowstate time across all of the user's IKAs combined. Property of the user, not of any particular neuron or IKA.

• Default 25-minute focus + 5-minute break (configurable).
• Task-bound: choose a task in any IKA, hit focus, timer locks UI to that task.
• Aggregates: hours focused per day → global Flowstate chart in the user's chrome (top bar / profile area).
• Agents in any IKA can see "Mats is in flow until 22:15" and defer non-urgent pings.
• Per-neuron breakdown available as a derived view; canonical metric is the global total.

Storage: pomodoro_sessions at user level with user_id, ika_id, task_id, started_at, ended_at. Aggregation = single SUM over user's rows.

Concept	Question	Cardinality
Leader	Who is accountable for this happening?	Exactly one human, per project + per task
Assignee(s)	Who is doing the work?	Zero or more (humans + agents)
Permissions (ACL)	Who can see / edit / share?	Many — per the ACL

Level	Can
Full	Read + Write + Delete + share + change permissions
Edit	Read + Write
Comment	Read + add comments
Read	Read only
None	Hidden / not in queries

Inherited from parent neuron by default; overridable per entity. Schema: acl table — (entity_type, entity_id, principal_id, level). Enforced via Postgres RLS as the floor; ACL on top.

Every page we've created on the fly (/paperclip, /openclaw, /intur/v2, /queplan/marcas, /tokens, /gstack, /ika-pro-architecture) is an artifact. Self-contained HTML, lives at a stable URL, owned by one neuron.

Anatomy

• name — unique per IKA; URL slug.
• title — display title (changeable without breaking URL).
• html_path — disk path of the rendered HTML.
• thumbnail_url — auto-generated screenshot for the grid view.
• created_by, neuron_id (canonical home), linked_entities (cross-references).
• version + per-version snapshots; tags; per-entity ACL.

UX

Inside row 5 (full-width), Artifacts renders as a thumbnail tile sub-grid (auto-sizing 3-5 tiles per row). Click → opens artifact in a new browser tab. Hover → preview overlay with version + cross-references. Drag a tile onto a project/task → cross-reference. + button → naming dialog → opens an empty editor or imports HTML.

Schema

• artifacts — id, ika_id, neuron_id, name, title, html_path, thumbnail_path, created_by_id, current_version, tags.
• artifact_versions — per-version snapshot.
• artifact_links — cross-references from drag-drop into project/task/event/note.

Auto-routing — IKA decides where the output lives

The user shouldn't have to tell IKA where to save things. When the user asks for a write-up or a file, IKA picks the container and the entity type. Asks only when truly ambiguous. No babysitting required.

User asks for	IKA produces	Saves under	Deeplink shape
"report on …", "summary of …", "write-up", "analysis", "brief" (no file format mentioned)	Artifact (HTML)	Most relevant task / project / neuron	/.../artifacts/<slug>
"spreadsheet", "csv", "xlsx", "pdf", "docx", "word doc", "slides", "deck"	Document (file-bytes in SeaweedFS)	Most relevant task / project / neuron + appears in Documents list	/.../documents/<slug>
Ambiguous container	Either, at best-guess location, with v22 "does this belong here?" badge	Best-guess	Same shapes; badge surfaces in entity row

Container resolution — Artifacts

• Request scoped to a specific task → /<ika>/<neuron-path>/<project-id>/<task-id>/artifacts/<artifact-slug>
• Request scoped to a project → /<ika>/<neuron-path>/<project-id>/artifacts/<artifact-slug>
• Otherwise → in-focus neuron: /<ika>/<neuron-path>/artifacts/<artifact-slug>

Container resolution — Documents

• Task-scoped → /<ika>/<neuron-path>/<project-id>/<task-id>/documents/<doc-slug> · appears in both the task's documents list and the neuron's Documents cell.
• Project-scoped → /<ika>/<neuron-path>/<project-id>/documents/<doc-slug>
• Neuron-scoped → /<ika>/<neuron-path>/documents/<doc-slug>

Disambiguation rule

File-format keywords (spreadsheet, xlsx, csv, pdf, docx, word doc, slides, deck) → Document. Generic "report / analysis / summary / write-up / overview / brief" → Artifact (HTML, lives at a URL). When confidence is low, IKA persists at its best guess and tags with the v22 tentative-placement "does this belong here?" badge — user can confirm, move, or dismiss to keep the badge.

The MCP / API integration registry is global to a tenant's IKA, but each NEURON exposes only the integrations relevant to its domain. Per-neuron scoping = least-privilege for agents + cleaner UX.

Examples by domain

Neuron domain	Typical integrations
Finance	QuickBooks · Xero · Plaid · Stripe · banking · Expensify · Gusto
HR / People	BambooHR · Gusto · Lattice · Greenhouse · Slack · Workspace admin
Marketing	HubSpot · Mailchimp · Buffer · Canva · Photoshop · Adobe CC · Google Ads · Meta Ads
Sales	Salesforce · HubSpot · Pipedrive · Apollo · Calendly · Loom · Zoom
Operations	Linear · Jira · Notion · Zendesk · PagerDuty · Datadog · GitHub · GitLab
Personal — Home	Hue · Nest · Ring · SmartThings · Tesla · iRobot · Sonos · Apple HomeKit
Personal — Health	Apple Health · Whoop · Oura · MyFitnessPal · Strava · Cronometer
Personal — Family	Google Calendar · Cozi · school portals · pediatrician portal · TimeTree
Universal	Google Drive · Gmail · Slack · WhatsApp Business (agent-tool only) · web search · Computer Use

Inheritance + override semantics

Rule	Behavior
Inherit from parent	Sub-neuron inherits its parent's connected integrations by default.
Override at any depth	A descendant can ADD its own integrations OR DISABLE a parent's integration for this branch.
Cross-neuron drag	Copies the credential reference (not the credential — vault still owns it). Revoking at source revokes both.
Per-IKA root canonical	The IKA root (depth 0) holds all connected integrations canonically. Sub-neurons display the inherited subset.

Schema

• integrations — id, ika_id, type, credential_vault_ref, connected_at, status.
• neuron_integrations — neuron_id, integration_id, scope ENUM('inherits_down','neuron_only'), overrides_parent BOOL, override_mode ENUM('replace','and_also'), added_by, added_at.
• Default scope = inherits_down. Override default = replace; and_also mode = both rows fire.

Where Integrations are external connections, Skills are capability bundles — prompts + tools + scripts the agent uses to do something domain-specific. Skills are auto-activated from context: the LLM decides when one fires. Explicitly user-invoked actions live under Commands instead. Skills are also a component of a Plugin bundle (the outer role-shaped install unit per anthropics/knowledge-work-plugins compatibility).

Examples by domain

Neuron domain	Typical installed skills
Marketing	programmatic video skill (alternatives: Revideo Apache-2.0 / Manim BSD / FFmpeg pipeline / Veo-router via API) · Image generation (Nano Banana, Imagen, Midjourney router) · Brand-voice copywriter · Social-post composer · Newsletter formatter · A/B-test analyzer · design-motion-principles · frontend design toolkit
Sales	CRM-record summarizer · Cold-email composer · Proposal generator · Deal-status reporter · Customer-interview synthesizer · Pricing-comparison builder
Finance	Invoice extractor · Expense categorizer · Cash-flow projector · Tax-form filler · Reconciliation helper · Budget vs actual analyzer
HR / People	JD generator · Resume ranker · Interview-feedback synthesizer · Performance-review drafter · Onboarding checklist builder
Operations / Engineering	Incident postmortem drafter · ADR writer · Runbook generator (slash entries /security-review, /qa, /codex are Commands, not Skills)
Personal	Recipe generator · Grocery-list optimizer · Workout planner · Meal planner · Birthday-gift idea generator · Trip itinerary builder · Homework helper
Universal	Document summarizer · Translation · Web-research (meta-entries skill-creator, skill-search, /learn are Commands)

Skill anatomy

• SKILL.md descriptor — name, description (trigger-focused — must start with "Use when…", never workflow-summarizing — per Superpowers lift v25.12 / S3), version, allowed tools, allowed integrations, vetting tier, source URL, sha256, ed25519 signature, license (required), always_on BOOL (re-injected on every SessionStart hook event — default false).
• System prompt — domain-specific instructions.
• Tool list — Paperclip tools + neuron Integrations the skill can call.
• Optional code — for skills that need deterministic logic (e.g. PDF extractor uses pdfplumber).
• Examples + tests — prompt-output pairs that act as regression tests. RED/GREEN pair required for community-with-sig tier (publish blocked without it) — see Superpowers S4.

Two meta-capabilities (always available)

Capability	What it does	Type
skill-creator	Bootstraps a new skill from a description. Publishes drafts only; agents cannot invoke own drafts; explicit human publish required.	Command (post-v25.11 migration)
skill-search	Searches global vetted catalog + per-IKA catalog. Filters by domain, vetting tier, popularity.	Command (post-v25.11 migration)

Vetting tiers

Tier	Source	Install policy
Anthropic-shipped	Official Anthropic Claude skills	Auto-allowed
IKA-curated	Skills we vet + publish	Auto-allowed; flagged "Vetted by IKA"
Community-with-sig	Open-source skills with valid ed25519 signature + declared license	Allowed with one-click confirmation; manifest must declare license ("Not stated" → blocked).

Skills run in Firecracker microVMs (reusing Computer Use infra), not in-process. Hash re-fetched weekly with drift alerts. Per-IKA skill-count cap + weekly digest of new skills authored.

Schema

• skills — id, ika_id (or NULL for global), name, version, descriptor_json, sha256, signature, license, vetting_tier, source_url.
• neuron_skills — neuron_id, skill_id, scope ENUM('inherits_down','neuron_only'), overrides_parent BOOL, override_mode, installed_by, installed_at.
• skill_invocations — id, neuron_id, agent_id, skill_id, invoked_at, cost_tokens, outcome, trace_ref.

Where Skills are auto-activated from context, Commands are explicit user-invoked actions surfaced in a slash-command palette and as autocompletes on "/". The split mirrors anthropics/knowledge-work-plugins's skills/ vs commands/ separation (see /skills/). Same per-row inheritance shape as Skills / Integrations / Agents / Automations.

Examples by domain

Neuron domain	Typical commands
Sales	/call-prep · /call-summary · /forecast · /pipeline-review · /account-research
Marketing	/brand-voice-check · /campaign-plan · /social-post · /newsletter · /ab-test-analyze
Finance	/reconcile · /budget-vs-actual · /cashflow · /expense-categorize
Operations / Engineering	/security-review · /qa · /codex · /postmortem · /adr · /runbook
Customer Success	/ticket-triage · /escalation-draft · /kb-update
Product	/spec · /roadmap · /user-research-synth
Universal	/learn · /skill-creator · /skill-search · /plugin-install · /deep-research

Schema

• commands — id, ika_id (NULL = global), name, plugin_id (NULL if standalone), descriptor_json, sha256, signature, license, vetting_tier, source_url.
• neuron_commands — neuron_id, command_id, scope ENUM('inherits_down','neuron_only'), overrides_parent BOOL, override_mode ENUM('replace','and_also'), installed_by, installed_at.
• command_invocations — id, neuron_id, user_id, command_id, invoked_at, cost_tokens, outcome, trace_ref.

Commands run under the same Firecracker isolation + cost-cap governance as Skills.

Audit of github.com/obra/superpowers (Jesse Vincent, MIT, cross-platform coding-agent skills framework) — full page at /superpowers/. Different category from Anthropic's role-shaped plugins: Superpowers ships process discipline, not domain knowledge. Five adopts + two mechanical adopts; nine skips.

Five skills adopted as IKA-curated Engineering-neuron defaults

Skill	Why
brainstorming	Universal — also applies to Marketing/Product neurons
writing-plans	Pairs with our Tasks/Projects entities; structured output
systematic-debugging	Aligns with our "evidence over claims" preference
verification-before-completion	Default on agent-as-assignee task closure (the "done" button becomes a check, not a claim)
writing-skills	Lift its rules into the skill-creator system prompt

Skipped: dispatching-parallel-agents / using-git-worktrees / subagent-driven-development / finishing-a-development-branch (duplicate Paperclip + out-of-posture). Partial / opt-in: test-driven-development / executing-plans / requesting-code-review / receiving-code-review.

SessionStart hook contract

Superpowers ships a SessionStart hook on matcher startup|clear|compact that re-injects always-on skill content. Maps onto IKA's Conversation Surface context-assembly:

Hook event	IKA equivalent	Re-injection
startup	First turn of a new thread	Always-on skills + IKA universal preamble
clear	User invokes "new conversation"	Same as startup
compact	Auto-compaction truncates history	Re-inject always-on skills + last-N-message summary so discipline survives the truncation

Schema: always_on BOOL column on neuron_skills (default false); new skill_hooks table forward-compatible with Anthropic plugin hooks if/when they ship a hook schema.

Trigger-focused description rule

Skill description must say when to invoke ("Use when…"), never what the skill does. The LLM router reads description first; workflow-summarizing descriptions cause silent failures where the model follows the description and never loads the body. Enforced in skill-creator system prompt + publish-path validator (rejects workflow verbs like "does", "performs", "generates").

RED/GREEN skill test

Authors of community-with-sig tier skills must ship a test pair: prove the agent fails the task without the skill (RED), then succeeds with (GREEN). New skill_tests table; CI runs at publish-time + weekly drift check. Anthropic-shipped tier exempt; IKA-curated required for new authoring (existing skills back-tested incrementally with 90-day deadline).

What we do NOT adopt

• The "iron-law" TDD framing as universal — TDD is opt-in for Engineering, never global. Prosumer surface includes spike/prototype/exploratory work where tests-first is friction.
• The "invoke skill before ANY response, including clarifying questions" rule — too aggressive for a concierge with 100+ turns/day. Classifier gate already handles cheap routing.
• Cross-platform installer machinery for 7 agent platforms — we are our own platform; the same "one skill, many install paths" property is achieved through our wire-format compatibility with Anthropic's plugin.json.

Effort estimate: ~4 days for S1–S6 (skill import + hook contract + description-rule + RED/GREEN test + verification-default + skill-creator prompt update). All slot inside existing Skills + Commands + Plugins sections — no new entity needed.

Plugin = a role-shaped install unit bundling Skills + Commands + Integrations + Agents + Automations under one manifest. Adopted from anthropics/knowledge-work-plugins — full analysis at /skills/. Sits one level above the four (now five) per-neuron registries; install fans out into all of them; uninstall removes the fan-out.

Why this layer exists

Today our 6 onboarding templates already act as plugin-shaped bundles, but at the IKA level (top-level neuron + starter content). A Plugin is the same shape one scope smaller: per-neuron. Users install a Plugin into a Sales neuron and get the 5+ skills, 5+ commands, integration recommendations, agent templates, and automations that role typically needs — in one action.

Wire format — Anthropic-compatible

Plugin manifest mirrors Anthropic's .claude-plugin/plugin.json; connector wiring mirrors .mcp.json. Effect: any plugin from anthropics/knowledge-work-plugins (or any community plugin built to the same spec) installs into an IKA neuron without translation. Bidirectional benefit: IKA-built plugins also run in Cowork and Claude Code, growing distribution beyond our own surface.

The 11 Anthropic plugins → IKA neuron map

Anthropic plugin	IKA neuron domain	Auto-install in template
productivity	Operations (cross-cutting)	Company
sales	Sales	Company · E-commerce
marketing	Marketing	Company · E-commerce · Creativity
finance	Finance	Company (+ light-mode on Personal Finances)
customer-support	Customer Success	Company · E-commerce
product-management	R&D / Product	Company
data	Engineering / Data	Company · E-commerce
legal	Legal (sub-neuron of Operations)	opt-in
bio-research	R&D (vertical-specific)	Health (when clinical)
enterprise-search	Universal (root)	All templates — installs at IKA root, inherits down
cowork-plugin-management	Universal (meta)	maps to IKA skill-creator/skill-search meta-commands

IKA-original plugins (the gap Anthropic doesn't cover)

• HR / People — no upstream equivalent; opportunity to publish first.
• 6 Personal plugins (Family · Health · Social · Hobbies · Home · Travel) — Anthropic's catalog is enterprise-shaped; Personal is IKA's wedge.
• School — no upstream equivalent; closest is enterprise-search for cross-source research.

Plan: ship these as IKA-curated tier plugins; contribute back upstream post-v1.

Schema

• plugins — id, name, description, version, manifest_json (canonical plugin.json), mcp_json (canonical .mcp.json), source_url, sha256, signature, license, vetting_tier, ika_id (NULL = global, else per-IKA private).
• neuron_plugins — neuron_id, plugin_id, scope, overrides_parent, override_mode, installed_by, installed_at. Same five-field inheritance shape as the others.
• plugin_skills / plugin_commands / plugin_integrations / plugin_agents / plugin_automations — bundle-membership tables. A row on a component table optionally carries installed_via_plugin_id so uninstall only removes plugin-installed components, leaving user-added ones intact.

Vetting tier mapping

Anthropic-shipped tier expands to cover the official anthropics/knowledge-work-plugins repo + future Anthropic plugin catalogs. Same auto-allow + hash-drift + weekly-digest machinery; no manifest-checks for sources signed by the trusted org. IKA-curated + Community-with-sig tiers unchanged.

Differentiators we keep

• Per-neuron scoping + inheritance (Anthropic plugins install at user instance, no scope model).
• 3-tier vetting + license enforcement + ed25519 signatures (Anthropic has none).
• Firecracker microVM isolation (Anthropic runs in-process).
• Per-IKA cost cap + Token Stack routing (Anthropic has no budget layer).

Agents are Paperclip-managed AI workers bound to a neuron (or a task). They consume Skills + Integrations available in their neuron scope and operate under Paperclip's governance + budget rules.

Agent-as-assignee

Leaders can assign tasks/projects to agents. Agent becomes assignee; leader stays the accountable human. Agent moves task through pending → in-progress → submitted-for-review.

Inheritance

Same shape as Integrations / Skills / Automations. Schema: neuron_agents with scope ENUM('inherits_down','neuron_only') + overrides_parent BOOL + override_mode. Default scope = inherits_down.

Recurring agent-driven workflows scoped to a neuron. Triggered by events / schedules / state changes.

Inheritance

Same unified shape as Integrations / Skills / Agents. Schema: neuron_automations with scope + overrides_parent + override_mode. An Automation defined on Marketing fires on every project/task in Marketing AND every sub-neuron AND their descendants, until a descendant overrides.

All six link tables (neuron_integrations · neuron_skills · neuron_commands · neuron_agents · neuron_automations · neuron_plugins) share the same per-row schema. neuron_plugins is the bundle-level row whose install fans out into the other five — see Plugins.

• scope ENUM('inherits_down','neuron_only') — default inherits_down.
• overrides_parent BOOL
• override_mode ENUM('replace','and_also') — default replace.

Question	Answer
Where does a parent's row fire?	If scope='inherits_down', fires on the defining neuron AND every descendant, until overridden.
What data scope when firing on a descendant?	The firing-row's neuron RLS context — sees what an agent/skill/integration scoped to that descendant would see, not what the parent could see. SHARED quarantine still gates inbound shared content.
What does a descendant override do by default?	Replaces. Parent's row does NOT fire on this subtree; the descendant's row fires instead.
Is there an "and-also" mode?	Yes — override_mode='and_also': both rows fire on this subtree.
UX chip per row	"from <parent>" · "this neuron only" · "overrides <parent>" · "+ also from <parent>".

New users land on a template picker. Each template = a preconfigured top-level IKA (default neurons + skills + integrations + starter content). Six templates ship at v0.

The 6 templates

Template	Primary ICP	Default top-level neurons
Personal	Anyone running their personal life as a system	Family · Health · Social · Hobbies · Finances · Home · Travel
Company	Business owners / founders / B2B services	Operations · Marketing · Sales · HR · Finance · Customer Success · R&D
E-commerce	D2C brands / Shopify owners	Inventory · Orders · Suppliers · Marketing · Customer Service · Returns · Fulfillment
Creativity	Agencies · creators · production studios	Projects · Clients · Production · Distribution · Portfolio · Reviews · Pitches
Health	Athletes · biohackers	Workouts · Meals · Sleep · Supplements · Doctor visits · Medications · Symptoms
School / Student	HS / university / professional learners	Subjects · Classes · Assignments · Exams · Notes · Study Groups · Career

Starter prompts (5 hardcoded per template, in the v0 React bundle)

Template	5 starter prompts
Personal	"Create event for dinner with Mom Sunday at 7pm" · "Add workout to Health for tomorrow morning" · "Create note Vacation ideas in Family" · "Set recurring grocery-shopping every Saturday" · "Show me everything planned this week"
Company	"Create project Q3 Launch in Marketing" · "Add task to research competitors and assign to Carlos" · "Schedule 1:1 with Jane next Tuesday at 2pm" · "Create recurring weekly retro form" · "What tasks are overdue across all projects?"
E-commerce	"Create project for Holiday campaign" · "Add task refresh product photography by November 1" · "Set recurring inventory check every Monday" · "Create customer-feedback form" · "Show me orders from last week with low margin"
Creativity	"Create client project Acme Brand Refresh" · "Add task draft 3 logo concepts by Friday" · "Schedule review call next Wednesday at 10am" · "Make recurring weekly status form for client check-ins" · "Show all projects in Production phase"
Health	"Create recurring strength workout MWF at 7am" · "Add doctor visit October 15 at 3pm" · "Set meal planning task every Sunday evening" · "Log sleep quality as daily habit" · "Show Whoop data for past week"
School	"Create project for Calculus midterm in 3 weeks" · "Add tasks for chapters 5 through 8" · "Schedule study group every Tuesday at 6pm" · "Create recurring assignment-tracker form" · "Show upcoming exams sorted by date"

Onboarding flow

1. Welcome screen — "What are you using IKA for?" → 4 ICP buckets.
2. Template picker — show templates filtered + ranked by ICP.
3. IKA naming — user names the new IKA.
4. Bootstrap — agent provisions neurons, skills, integrations (OAuth click-through).
5. Starter content — template seeds 3-5 example projects + 5-10 example tasks/events/notes.
6. Prompt onboarding — first 5 example prompts as "Try this" buttons.
7. First-week guidance — daily nudges via in-product notifications.

End-user-facing catalog embedded in onboarding, the help menu, and contextual "Try this" hints inside Operations. Distinct from the internal voice command matrix.

Catalog entry

• title · example_text · language (en/es) · entity_type · operation · domain_tags · skill_required · screenshot · variations

Surfaces

Surface	Behavior
Onboarding step 6	5 starter prompts filtered by chosen template
Help menu	Browse-able catalog by entity type → operation. Copy + Run buttons.
Empty-state hints	Show 2-3 catalog entries relevant to the empty list.
Slash menu	Typing / opens catalog as typeahead.
Voice listening hint	Rotating ghost-text shows random catalog examples.
"Try this" toasts	After a successful action, suggest the next 1-2 logical prompts.

v0 implementation

Starter prompts hardcoded in the React bundle. popularity_score + prompt_runs telemetry catalog table deferred to v1.

Category	Examples	Connection method
Communication	Slack · Discord · Email · SMS (Twilio) · WhatsApp Business (agent-tool only)	MCP server or OAuth + API
Calendar / Scheduling	Google Calendar · Outlook · Calendly	OAuth + API
File / Storage	Google Drive · Dropbox · OneDrive · Box	Uppy Companion
Creative	Adobe Premiere · Photoshop · Illustrator · Figma · Canva	Adobe APIs / Figma REST / Photoshop UXP
Code / Dev	GitHub · GitLab · Linear · Jira · Vercel · Netlify	OAuth + API; many have official MCP servers
Finance	Stripe · QuickBooks · Plaid · banking APIs	OAuth + API (high-trust, governance gating mandatory)
CRM / Sales	HubSpot · Salesforce · Pipedrive	OAuth + API
Browser / Web	Playwright · web search · scrapers	Already in IKA stack
Computer Use	Anthropic Computer Use — drives any desktop app inside per-tenant ephemeral VM	Wrapped as Paperclip MCP plugin (see Computer Use section)

SaaS APIs cover ~70% of Operations automations. The remaining 30% live in apps with no API (Premiere, Photoshop, legacy ERPs). Anthropic Computer Use closes this gap — the agent literally sees a screen, moves a mouse, types on a keyboard. Wrapped as a Paperclip MCP plugin with per-tenant sandboxed VMs.

Capabilities

Capability	What the agent can do
Screenshot	Snapshot of current desktop / window
Mouse	Move, click (left/right/double), drag
Keyboard	Type strings, press individual keys (Tab, Enter, Esc, modifiers)
Scroll, window management	Switch apps, resize, minimize, focus
Vision-grounded reasoning	Claude reads the screen at every step (multi-modal API)

Architecture

• Per-tenant warm VM pool (Firecracker microVMs preferred; hardened Docker w/ seccomp + user namespaces as fallback). Sub-second session start.
• One container per session, never reused across tenants. Container destroyed at session end. Filesystem ephemeral; only the recording survives, attached to the originating Task.
• Egress allow-list per session — only the apps/domains needed for the task. Default deny.
• Recording non-bypassable — every session recorded; recording attached to the Task as a Document with permission inherited from the Task.

Credential model

Credential broker on the host, NOT clipboard inside the VM. The browser inside the VM talks to a host-side localhost proxy; the proxy injects the auth header for known domains and never exposes the secret to the VM process. For non-HTTP apps (Premiere license server, Photoshop activation, legacy thick-client logins), an OS-level keychain is mounted read-only into the VM with per-app entitlements. Vault holds underlying secrets encrypted. Clipboard- and autofill-based delivery are explicitly forbidden.

Governance — Computer Use + LLM council are OPTIONAL, default OFF

Both features are OPTIONAL in Settings → Governance, default OFF per IKA. Admin must explicitly enable each. Settings page surfaces a running monthly cost projection if either is enabled (Computer Use ≈ 10× normal text-turn cost; council ≈ 3× normal cost).

• Once enabled: second-opinion ON when triggers fire (money / identity / external recipient); council requires explicit "/council" prefix — never automatic.
• Snapshot before mutating actions; auto-revert on dispute.
• Default ToS allow-list ships EMPTY. Admin must explicitly add each app + check "I confirm my ToS with <App> allows automation". Every add written to audit log. Marketing copy lawyer-reviewed before first dynamic tenant. IKA ToS includes indemnification clause covering tenant-driven automation choices.

Vision cost optimization

• Take screenshots only on state-change events (after click, after key, after scroll), not every step.
• Crop to active window region.
• Downscale to 1024px max edge.
• Haiku for "is the page loaded?" sanity checks; Sonnet only for "what should I click?".
• System prompt cached (Layer 1).

Schema

• cu_sessions — id, ika_id, agent_id, task_id, app, container_id, started_at, ended_at, status, recording_path, cost_tokens.
• cu_app_policy — per-IKA: app name, allowed (bool), second_opinion_override (bool), notes.
• cu_recordings stored in SeaweedFS under cu/<tenant>/<date>/<session-id>.mp4 + per-frame screenshot index.

#	Layer	What it optimizes	Est. reduction
L1	Anthropic Prompt Caching	Cached prefix tokens at 90% off	30–50% per call
L2	LiteLLM proxy + semantic cache + smart routing	Cache near-identical queries; route low-stakes to Haiku. Every LLM call routes through it from day 1 even at 0% cache hit, so vendor switching is one config flip.	20–40% (depends on cache hit rate + Haiku-suitable fraction)
L3	RTK shell-output filter	Filters / dedupes / truncates noisy shell-command output BEFORE it enters the LLM context	60–90% on shell output
L4	Anthropic Message Batches	50% discount on non-urgent batched calls (24-hour SLA). Dream-cycle uses this by default.	50% on the batched portion
L5	Pattern cache for known intents	Deterministic responses for known query patterns — bypass the LLM entirely	~95% off when matched
L6	Graphify (code-graph)	Graph over codebase; agents query graph nodes + neighborhood instead of grep/dump	~71.5× on codebase Q&A (Graphify's documented number)

Combined target: 50–70% reduction on monthly token spend vs naive (L1–L5), plus multiplicative reduction on codebase-touching queries from L6. Hard cap: K=8 retrieved chunks per agent turn, server-side enforced. Thoughts TTL'd 24h then summarized; never feed back into agent context without explicit retrieval (per-IKA toggle default OFF).

IKA Lab is the experimental BI shell — Mats's prototype sandbox, served at main.ika.ai/lab/. Drag-drop layouts, magic-palette color wheel, lights, particle effects, and other unstable experiments live here before any of them get promoted into the main shell.

It is not a release target and not part of the v0 build plan; it is a parallel canvas. Patterns that earn their keep get ported to the React Operations shell during Phase 1 / Phase 2.

Color coding: safe permissive · notice attribution / acceptable copyleft · risk unverified / commercial.

gstack is an open-source LLM-security toolkit (MIT). The full comparison vs IKA lives at main.ika.ai/gstack/; this section anchors the inventory.

What we lift: gstack #6 — the 22MB prompt-injection ML classifier + canary-token format, vendored at /vendored/gstack/. This is a v0 launch blocker for any agent that ingests external content (web, email, files). Fail-closed when unavailable.

Opportunistic lifts: OWASP/STRIDE prompt templates for red-teaming. Everything else (auth, sandboxing, rate-limits) we already cover via Firecracker + per-IKA RLS.

Adopted

#	Adopt	Phase	Effort
H1	hermes-paperclip-adapter as agent class	v0	~½ day
H2	Honcho dialectic user modeling — federated platform.honcho_profile(user_id)	v0	~2 days + ½ day federation
H3	FTS5-style session search via Postgres tsvector (folds into RRF retrieval)	v0	~1 day
H4	agentskills.io standard for skill catalog	v0	~½ day
H5	hermes-agent-self-evolution (DSPy + GEPA)	v1 (≥50 skills required)	~3 days when adopted

Skipped

#	Skip	Reason
H6	Replace Paperclip with Hermes	Stack rewrite. Hermes is single-user-shaped; multi-tenant adaptation = months for no functional gain over the adapter.
H7	Multi-platform messaging gateway (Telegram / WhatsApp / Slack / etc. as user↔IKA chat surface)	All user↔IKA chat is through the IKA app or web only. Per-neuron Slack/Email integrations as agent tools remain in scope; user-facing chat surface does not.
H8	Daytona / Modal serverless terminal backend	Overlaps Computer Use + Firecracker. Switching abandons credential-broker design + signed-skill isolation pairing.
H9	Atropos RL / trajectory compression	Out of scope until we train our own model.
H10	Hermes voice-memo transcription	IKA voice already shipped.

Andrej Karpathy's open-source pattern catalog. Full analysis at main.ika.ai/karpathy/.

What we adopt: llm-council — multi-vendor council fan-out + reconciliation, used as our second-opinion governance middleware on high-stakes agent decisions (irreversible writes, external sends, financial actions). License verify pending before vendoring.

Everything else (nanoGPT, micrograd, LLM101) is reference reading, not lifted code.

Odysseus is a self-hosted, privacy-first AI workspace (MIT, Python + FastAPI). Opposite posture from IKA — they self-host model weights (vLLM/llama.cpp/Ollama); we use Anthropic. Despite the posture gap, two patterns lift cleanly. Full analysis at main.ika.ai/odysseus/.

Adopted (greenlit by Mats 2026-06-01)

#	Adopt	Phase	Effort
O1	Deep Research loop (plan → search → synthesize → reflect, ported from Alibaba DeepResearch). Core IKA Concierge capability — Pro and Enterprise both; sits above the classifier gate as a stakes-triggered escalation in the Conversation Surface. Output writes to Artifact entity with a "convert to Document" affordance for further editing. Pipes citations to assessments table. Per-IKA cost cap (same budget primitive as the rest of the token stack — no separate tier policy).	v0	~2 days (skeleton + assessments wiring + budget governance + UX)
O2	Cookbook decision-table pattern — single cookbook.pick(request) entrypoint collapsing the v17 threshold table, gstack #3 second-opinion gate, and the 6-layer token stack into one routing decision per request. Same shape as Odysseus's VRAM-aware fitter, different inputs (tier + budget + SLO instead of VRAM).	v0 (refactor)	~½ day

Watched (defer decision)

#	Watch	Reason
O3	Odysseus Memory skill-evolution loop (skills mutate based on invocation outcomes)	1-hour code-walk before specing v1 skill-evolution. Storage layer (ChromaDB) skipped — we're on pgvector + tsvector RRF.

Skipped

#	Skip	Reason
O4	OpenCode agent runtime as alt to Hermes-paperclip-adapter	Mats 2026-06-01: Hermes for now. No v1 bench.

O5vLLM / llama.cpp / Ollama model servingPosture — we use Anthropic. O6ChromaDB vector storeAlready on pgvector (schema-per-IKA + RLS). O7SearXNG web search, IMAP/SMTP email client, CalDAV calendar, multi-tab markdown editor, blind model comparison, image editing, file upload, 2FA layer, hardware GPU passthrough, native installAll map to per-neuron integrations / first-class entities / managed-platform layer in IKA — not built-in apps.

ECC (affaan-m/ECC, MIT, v2.0.0-rc.1) is a harness-native operator system for AI coding agents — 64 agents, 261 skills, ~25 lifecycle hooks, a continuous-learning subsystem. The 261-skill catalog itself is coding-vertical and out of scope for IKA Concierge, but the primitives underneath ride straight onto our existing per-neuron Skills / Commands / Plugins entities. Full analysis at main.ika.ai/ecc/.

Three highest-leverage adopts

#	Adopt	Why	Effort
E4	Instincts — atomic, confidence-weighted (0.3–0.9), domain-tagged, evidence-backed learned behaviors with a scope ladder (neuron → ika → global) and a promotion rule (seen in 2+ scopes → promote). Sits between Notes (raw) and Skills (formal) on the formality axis, and between assessments-about-the-world (gbrain lift #4) and skills on the self/other axis.	Highest-leverage primitive in the repo. IKA has nowhere to store claims about IKA's own behavior today; the dream-cycle observer can write instincts on the cadence we already pay for, without per-turn background-Haiku cost.	~3d
E1	Hook profile env-var — IKA_HOOK_PROFILE=minimal|standard|strict + IKA_DISABLED_HOOKS=…. Add a min_profile column to skill_hooks (v25.12) so a misbehaving hook can be turned down at runtime instead of requiring a migration.	~50 lines of plumbing for a graceful-degradation kill-switch on the hook pipeline we just shipped.	~½d
E3	Context-budget audit skill — scans per-neuron Skills / Commands / Plugins / Integrations, estimates token overhead (words × 1.3), classifies Always / Sometimes / Rarely needed, flags bloat patterns, emits a savings report. Ships as IKA-curated/context-budget + /context-budget command, with a MyPanel chip.	Once we have 30+ skills × 12+ MCPs per IKA, "why is the Conversation Surface slow?" becomes unanswerable without instrumentation. Builds the answer-surface before the question arrives.	~1d

Four more adopts (E2 fact-force gate on first write-per-file · E5 in-conversation cost/context monitor · E6 Brief-as-markdown for cross-channel handoff · E7 per-Automation write_scope_path freeze) detailed at /ecc/. Skipped: the 261-skill catalog · multi-harness manifest translation · ecc2/ Rust control-plane · NPM distribution · legacy commands shim · Tkinter dashboard · AgentShield. Reasoning at /ecc/.

Implemented on our own schema-per-IKA Postgres + ltree + pgvector. Total adopt-cost ~9.5 days. knowledge-graph (gbrain lifts, user content) is distinct from code-graph (Graphify, codebase, L6).

#	Lift	Axis	Effort
1	Typed-link extraction without LLM calls — deterministic markdown parser detects attended/works_at/reports_to/blocks/mentions via regex + grammar. Zero prompt-injection surface. Saves ~$30–120/mo/IKA at active scale.	COST	~2d
2	RRF hybrid search fusion — Reciprocal Rank Fusion of pgvector + tsvector results (score = Σ 1/(k+rank), k=60). ~50 lines in Paperclip retrieval handler.	RECALL	~1d
3	Backlink-boosted ranking — multiply retrieval score by log(1 + backlink_count). Free signal — graph already exists from lift #1.	SIGNAL	~½d
4	Compiled-truth schema — two-tier storage: events (raw timeline) vs assessments (curated, high-trust statements). Retrieval prefers assessments; falls back to events.	DISCIPLINE	~1d
5	Nightly dream-cycle as Paperclip heartbeat — per-IKA cron walks new events and writes/audits assessments + enforces backlinks + flags orphans. Cap 200 events/run, prioritized by typed-link density. Haiku for assessment-writer; Sonnet for citation-audit. Layer 4 Message Batches by default. Per-IKA budget separate from interactive.	SELF-HEALING	~3d
6	Skillify pipeline — 10-step checklist converts a one-off agent fix into a reusable, tested skill. Pairs with skill-creator meta-skill.	COMPOUNDING	~2d

People are federated single records living in platform.people. Per-IKA visibility via platform.ika_people linking rows. RLS-enforced.

Path	Detail
(a) Migration	One-time merge: for every IKA's people table, INSERT into platform.people with dedup heuristic = email match (canonical primary) + fallback (name + phone) fuzzy match with Levenshtein-≤2 on name AND exact phone match. Collisions land in a manual-review queue. Per-IKA ika_people linking row is created with the resolved platform_person_id. Migration is idempotent.
(b) RLS policy	CREATE POLICY platform_people_visibility ON platform.people FOR SELECT USING (EXISTS (SELECT 1 FROM platform.ika_people ip JOIN platform.user_ikas ui ON ui.ika_id = ip.ika_id WHERE ip.platform_person_id = platform.people.person_id AND ui.user_id = current_setting('app.current_user_id')::uuid));
(c) Backup atomicity	Single backup job covers platform schema + every ika_* schema atomically (pg_dump --schema=platform --schema='ika_*' in one transaction or via pg_basebackup). Restore replays the same set; partial-restore is forbidden (cross-schema FKs would dangle).
(d) DR runbook	After restore, run consistency check that every ika_people.platform_person_id resolves to an existing platform.people row; orphans surface in Builder DR-status panel for manual reconciliation.

Deletion + federation matrix

Action	What gets deleted	What stays
Delete IKA-A	IKA-A's schema (ika_a.*) including its ika_people linking rows; per-IKA conversation messages scoped via focused_ika_id get a tombstone marker; per-IKA artifacts.	platform.people rows that other IKAs still reference; platform.honcho_profile for the user; the system-wide conversation thread.
Person becomes orphaned (last ika_people link removed)	Soft-delete of platform.people row with 30-day grace. Recoverable if user re-adds the person to any IKA inside the grace window.	Audit log entries kept for legal-retention; redacted on user-initiated full-account-delete.
GDPR Art.17 erasure	Hard-delete every ika_* schema for that user; hard-delete platform.honcho_profile(user_id); hard-delete platform.conversation_* rows for that user; hard-delete orphaned platform.people rows.	Anonymized aggregates for ops + legal retention only.

platform.conversation_threads + platform.conversation_messages + platform.conversation_briefings all live in platform, NOT per-IKA. One thread per user across all their IKAs. Pane scopes context per-turn to the in-focus IKA (recorded as focused_ika_id on each message), but the THREAD is single + global. Briefings recompute downward — 4 per user, not 4×N.

• Mode: SSE-KMS (server-side encryption with KMS-managed keys).
• Key topology: ONE KMS key per IKA (matches schema-per-IKA). Buckets are per-IKA OR a single bucket with per-IKA key-prefix; either way every PUT names the IKA's KMS key id.
• Key custody: HashiCorp Vault. Auto-rotated annually (Vault transit engine handles re-wrapping; old key versions kept for decrypt of existing objects).
• Recovery: if a Vault unseal share is lost, restore from offline-stored Shamir threshold (3-of-5). If a per-IKA KMS key is lost, IKA's bytes are unrecoverable — soft-delete + 30-day notice to IKA owner before hard-delete. Documented in DR runbook.
• Required before first dynamic tenant.

Icon row at the top of the window, drag-rearrangeable, persistent per user. Each IKA renders as an icon (color + initial). Active IKA gets a ring. "+" at the end opens the new-IKA flow. Hover = tooltip with full IKA name.

┌─────────────────────────────────────────────────────────────────────────┐
│ row 0  [IKA-1] [IKA-2] [IKA-3] [+]                       (IKA chrome)  │  ← IKA switcher (icon strip, NOT Builder)
├─────────────────────────────────────────────────────────────────────────┤
│ row 1  ( BI | Operations )                                              │  ← BI ↔ Operations toggle
├─────────────────────────────────────────────────────────────────────────┤
│ row 2  [global search ........................]  [voice]  [chat-icon●] │  ← global search + voice + chat icon (unread count from briefings)
├──────────────────────────────────────────────────────────┬──────────────┤
│                                                          │              │
│              ACTIVE SHELL BODY (BI or Ops)               │  Builder     │  ← Builder feed = right-side panel sibling
│                                                          │  feed        │
│                                                          │  (admin-only)│
└──────────────────────────────────────────────────────────┴──────────────┘

• Mobile: row 0 collapses to a horizontal-scroll strip. 250ms tap-and-hold to enter drag mode; body scroll suspended while drag mode active. Tap-without-hold = switch IKA.
• Builder feed renders as a right-side panel sibling, NOT inside the switcher chrome.
• Chat icon shows unread count of conversation messages (briefings post into the system-wide thread async; the icon is the unread badge).

IKA switcher includes shared IKAs

Lists user's own IKAs (business + personal), then a divider, then shared IKAs (with shared-by badges).

Sprint-based delivery, no blocking. While building, the swarm never stops to wait on Mats — except at sprint review boundaries. Within a sprint, agents proceed; if a question arises, they make the best call (with v22 tentative-placement / "does this belong here?" badging) and surface it for Mats's later review. Sprint cadence: ~1 day swarm work + ~½ day Mats review buffer (default 1.5d sprint). Narrow features can run as ½-day swarm + same-day review.

Sprint progress bar (placeholder — live version ships into Builder chrome + the eventual product)

Next review: Sprint 0 kickoff — awaiting Mats greenlight. Live version (in Builder chrome + product): segment fill-percentage on current sprint + countdown to expected review deadline.

Sprint plan

Sprint	Scope	Length	Status
0 — kickoff	The 7 v0 blockers (B1–B7) + supporting infra: gstack prompt-injection lift, Paperclip fork + schema-per-IKA + RLS + platform schema, JWT-off-URL + WS-ticket, Computer Use credential broker, Skill signing + Firecracker, encryption-at-rest + age backups + KMS, Builder host-shell role-gate.	~1d	awaiting-review
1 — Phase 1 part A	React+Vite+TS skeleton in <div id="ika-react-root">; Operations shell mount inside vanilla; neuron tree; drag-drop; Forms; Phases.	~1.5d	pending
2 — Phase 1 part B	Leadership; Sharing; Search; Deep-linking; Artifacts grid; 13-cell layout completed.	~1.5d	pending
3 — Phase 1 part C	Voice matrix v0 (create + read on tasks/events/notes; expand in waves) + IKA Conversation Surface (classifier-gate + drawer + briefings ON + Honcho federated + system-wide threads).	~1.5d	pending
4 — Phase 1 part D	6 gbrain lifts (typed-link extraction, RRF fusion, backlink boosting, compiled-truth schema, dream-cycle, skillify) + 6-layer token stack adoption (LiteLLM at L2, Prompt Caching, RTK, Message Batches, pattern cache, Graphify).	~1.5d	pending
5 — Phase 1 part E	Onboarding × 6 templates + prompt catalog + Skills/Integrations/Agents/Automations with unified inheritance + MyPanel pin + Recycling Bin.	~1d	pending
6 — Phase 1 final	Integration + smoke test pass (E2E Playwright + a real prosumer walkthrough) + bug-fix loops.	~1d	pending
7 — Phase 2 start	Vanilla BI rewrite — re-implement charts, drill-downs, query overlay, palette, modal analysis.	~1.5d	pending
8 — Phase 2 finish	Three.js icosahedron via react-three-fiber inside the same React app + visual regression vs frozen msp.ika.ai.	~1d	pending

Total: 8 sprints, ~10–11 calendar days. Matches the v0 5–8d swarm-time + Mats-review-buffer estimate.

Term	Definition
IKA	The product. An AI-first management surface for a company or a life context. A user can own multiple IKAs; each is isolated by Postgres schema + RLS. v3 is the current generation.
Neuron	The fractal unit of organization inside an IKA. Top-level neurons are departments. Soft cap depth 6.
Sub-neuron	A neuron whose parent is another neuron. Same UI primitives — fractal all the way down.
SHARED top-neuron	System pseudo-neuron pinned at depth 0 of every user's IKA. Receives entities shared at the sub-entity scope.
MyPanel	The user's home dashboard / launch view. Renders the user's pinned entities (per-user, cross-IKA) as a 3-column grid.
Recycling Bin	Per-IKA chrome surface listing soft-deleted entities. Auto-purge after 30 days (configurable). Cascading restore.
Leader	The single human accountable for delivery of a project / task / event / form / neuron. Distinct from assignee.
Assignee	The human or agent doing the work. Many possible per entity; not the leader.
Owner	The user who created an entity, or who holds the IKA. The IKA owner has Full ACL by default.
code-graph (Graphify)	Graph over the codebase, scoped per repo. L6 of the token stack.
knowledge-graph (gbrain)	Graph over user content (notes, events, projects, decisions), scoped per IKA. Lives in each IKA's Postgres schema with ltree + pgvector.
Builder	The agent-driver overlay (top bar + side panel + feed + tasks + Q&A + snapshots). Admin-only. Vanilla, host-agnostic, sandboxed iframe with strict CSP + DOMPurify.
Builder bundle	Shipped JS+CSS payload at /builder.js, version-pinned by snapshot.
Host shell	The IKA app HTML page into which the Builder bundle is conditionally injected at server-render time based on the user's role.
Phase 1	Both Opus + Codex focused on building the React Operations shell INSIDE the existing vanilla shell on main.ika.ai — file-by-file hybrid mount via <div id="ika-react-root">. ~3–4 swarm-days.
Phase 2	After Phase 1 ships, both accounts focused on the vanilla BI → React rewrite inside the same React app. ~2–3 swarm-days. End state: one React app, no legacy vanilla.
Honcho	Plastic Labs's dialectic user-modeling microservice. Lifted to platform.honcho_profile(user_id) with optional per-IKA overlays — one canonical user-self model across all the user's IKAs.
Conversation thread	One thread per user, system-wide across all their IKAs. Lives in platform.conversation_threads + platform.conversation_messages. Pane scopes context per-turn to in-focus IKA via focused_ika_id.
Computer Use	Anthropic's sandboxed desktop-control capability. OPTIONAL, default OFF per IKA in Settings → Governance.
LLM council	Multi-vendor second-opinion middleware. OPTIONAL, default OFF, ~3× normal cost; user invokes per-turn with "/council" prefix when enabled.
Second opinion	Single-vendor (Codex) review of a high-stakes agent plan. Triggered by money / identity / external-recipient policies. OFF by default; admin opts in.
Dream-cycle	Per-IKA nightly Paperclip heartbeat that walks new events and writes/audits assessments + enforces backlinks + flags orphans. Cap 200 events/run; Haiku for assessment-writer, Sonnet for citation-audit; Layer 4 Message Batches; per-IKA budget separate from interactive.
Skillify	10-step pipeline that converts a one-off agent fix into a reusable, tested skill. gbrain lift #6.
RRF	Reciprocal Rank Fusion — score = Σ 1/(k+rank), k=60 — combines pgvector and tsvector retrieval. gbrain lift #2.
ltree / pgvector	Postgres extensions for hierarchical paths and vector embeddings.
RLS	Row-Level Security — Postgres feature that enforces per-row access policies inside the database. The floor under every query.
Phases	First-class structure inside a project: Initiation / Definition / Research / Planning / Design / Development / Implementation / Follow-up + custom.
Priority	High / Medium / Low chip on every task / project / event. Drives default sort + visual weighting + Timeline placement.
Flowstate	GLOBAL user-level metric of focused time across all the user's IKAs. Aggregated from Pomodoro sessions. Rendered in chrome.
Pomodoro	25-minute focus + 5-minute break loop bound to a task. Sessions feed the global Flowstate metric.
Forms	Two-tier (Template + Submission) typed data-collection primitive. Field types: Date / Dropdown / Checkbox / Text / Title / Paragraph.
Artifacts	On-the-fly created HTML pages owned by a neuron. 13th first-class entity.
Integrations	Per-neuron MCP/API connections. Inheritable from parent neuron with override.
Skills	Capability bundles installable per-neuron. Every skill row signed (sha256 + ed25519) and license-required; runs in Firecracker.
Automations	Recurring agent-driven workflows scoped to a neuron.
Events	Time-bounded items with start/end + invitees.
Notes	Block-editor (BlockNote) rich-text content attached to a neuron / project / task / event / person.
Documents	File-bytes attached via Uppy + Companion. Stored in SeaweedFS.
People	Federated human records living in platform.people; per-IKA visibility via ika_people linking rows. One canonical record per real human across all your IKAs.
Agents	Paperclip-managed AI workers bound to a neuron (or a task). Can be assignees but never leaders.
Projects	Containers for tasks. Have phases, leader, priority, status, dual radial.
Tasks	The unit of work. Recursive (sub-tasks).
Occurrences	Materialized instances of a recurring task / event / form (iCalendar RRULE). Materialized lazily.
Deep-link	Stable URL grammar that addresses any entity inside the fractal. Layer 1 (BI) + Layer 2 (Operations).
Layer 1 (BI)	The outer shell — charts, drill-downs, query overlay, palette, modal analysis, neuron icosahedron at BI level.
Layer 2 (Operations)	The inner shell — neuron tree, entity lists, drag-drop matrix, plugins, forms, phases, search, sharing.
msp / main / intur	Subdomain identifiers. msp = frozen client-presentation. main = active build target. intur = sister product.
Prompt-injection classifier	22MB ML model vendored from gstack #6. Launch blocker. Fail-closed when unavailable.
MCP	Model Context Protocol — the integration shape we use for every external service.
RTK	Shell-output filter from /tokens. L3 of the token stack.
LiteLLM	Vendor-agnostic LLM proxy + router + cache. L2 of the token stack. Every LLM call routes through it from day 1.
Message Batches	Anthropic Message Batches API — 50% off for non-user-blocking workloads. L4 of the token stack.
Prompt Caching	Anthropic Prompt Caching — re-use cached prefix tokens at large discount. L1 of the token stack.
SHARED	Pseudo-neuron rendered at depth 0 by joining the user's shares rows with scope = sub_entity. Receivers see only the shared entity + its descendants — no parent leakage.
OPS_MAP	Per-IKA item map (operations_item_map.json) loaded into a global on app boot. Indexes every entity for <5ms voice resolution.
SPINE	Per-user cross-IKA spine (user_ika_spine.json) loaded once at login. Indexes IKAs + top-neurons + favorites + recent + people_federation. Resolves cross-IKA voice commands without context-switching.
Tentative-placement	Voice utterance → entity persisted immediately at IKA's best guess with a tentative flag → passive confirmation toast → if dismissed, badge stays until reviewed. Voice input never lost.