CogWave — The Cognitive Continuity Layer for AI Work

CogWave turns long AI conversations into evidence-linked cognitive trajectories, then compiles a resumable work state with decisions, open branches, and next actions.

Comment

Inspiration

Long AI conversations preserve every message, but the evolving state of the work disappears inside the transcript.

A decision made dozens of turns ago becomes buried. An unresolved question fades from view. A late reframe is easy to miss unless the user scrolls back and reconstructs the work manually.

This is a continuity problem.

Researchers, developers, and knowledge workers increasingly use AI for complex, long-running tasks, yet today’s interfaces primarily preserve message history rather than the structure of the work: what changed, what was decided, what evidence supported it, what remains unresolved, and where the next session should begin.

CogWave was built to preserve that structure.

Its core idea is simple:

Every substantial AI conversation should leave behind a visible, verifiable, and resumable work state.

What it does

CogWave turns live AI conversations into evidence-linked cognitive trajectories, then compiles the evolving work into a state that can be resumed.

The core workflow is:

Live Conversation → Cognitive Trajectory → Cognitive Checkpoint → Resume Packet → Next Work Phase

A dedicated GPT-5.6 Trajectory Extractor observes each completed user–assistant exchange and maps meaningful cognitive advances across nine state types:

  • questions
  • observations
  • problems
  • insights
  • reframes
  • decisions
  • actions
  • emotion turns
  • memory anchors

A mandatory salience gate filters social filler, acknowledgements, repetitions, and non-advancing turns so the graph grows only when the work meaningfully changes.

Evidence is preserved through verbatim source anchors and optional expansion layers. Every graph node can be traced to the exact source language that created it. Users can inspect:

  • the speaker
  • the turn number
  • the exact source quote
  • the node confidence
  • the reason for each semantic transition
  • supporting or expanded evidence

This makes the graph inspectable rather than decorative.

When the user pauses the session, CogWave compiles a Cognitive Checkpoint containing:

  • the active goal
  • settled decisions
  • open questions
  • unresolved branches
  • evidence and conflicts
  • drift risks
  • the next best action

The Resume Packet then converts that checkpoint into a precise handoff for the next work phase. It preserves what should continue, what decisions should remain settled, and what should not be repeated.

CogWave therefore preserves more than a conclusion:

It preserves the path, the proof, and the state that can be resumed.

How we built it

CogWave separates conversation, observation, validation, visualization, and continuity compilation into distinct layers.

GPT-5.6 Conversation Worker

A GPT-5.6 Conversation Worker collaborates with the user during natural live chat and produces concise responses designed to move the task forward.

GPT-5.6 Trajectory Extractor

A dedicated GPT-5.6 Trajectory Extractor runs as a separate model call with its own developer prompt and strict JSON Schema.

Instead of sharing the Conversation Worker’s instructions, it receives the completed user–assistant exchange as structured transcript data and returns:

  • a salience-gate decision
  • typed cognitive nodes
  • semantic edges
  • edge reasons
  • expansion items
  • verbatim source anchors
  • confidence values

Exchange-level extraction allows CogWave to observe one complete conversational unit once, reducing duplicate graph updates while preserving both user and assistant contributions.

Deterministic Sanitizer

Before model output reaches the graph, a server-side sanitizer validates:

  • node and edge types
  • identifiers
  • source-anchor integrity
  • quoted source text
  • speaker and turn attribution
  • expansion structure
  • graph constraints

This creates a clear boundary between probabilistic interpretation and deterministic graph integrity.

Cognitive Checkpoint

A separate GPT-5.6 structured-output call compiles the current work state. It distinguishes settled work from open work and identifies unresolved branches, conflicts, drift risks, and next actions.

Resume Packet

Another dedicated GPT-5.6 call converts the checkpoint into a precise continuity handoff that can be copied into a future session or continued inside the current trajectory.

Interactive Renderer

The dependency-free SVG renderer supports:

  • live trajectory growth
  • nine cognitive node types
  • semantic relation labels
  • main and expansion layers
  • source inspection
  • hover-path focus
  • responsive trajectory auto-fit
  • bilingual display
  • JSON export

The OpenAI API key remains entirely server-side. The server also provides health reporting, per-client rate limits, public-demo budget controls, structured errors, and explicit handling for incomplete or refused model responses.

How GPT-5.6 powers CogWave

GPT-5.6 performs four product-critical roles through the OpenAI Responses API:

  1. Conversation Worker — collaborates with the user during live chat
  2. Trajectory Extraction — decides whether the work advanced and returns typed nodes, edges, expansions, and source anchors
  3. Cognitive Checkpoint — separates settled work from open work and identifies drift risks and next actions
  4. Resume Packet — compiles a precise re-entry state for the next work phase

The Trajectory Extractor, Cognitive Checkpoint, and Resume Packet use strict JSON Schema outputs with dedicated prompts and contracts. The Conversation Worker runs as a separate model call with its own prompt and response contract.

How Codex was used

Codex was used in the primary Build Week development thread to:

  • inspect the pre-existing CogWave research prototype
  • identify which research components should be preserved
  • design and implement the GPT-5.6 Responses API integration
  • define the structured-output contracts for trajectory extraction, Cognitive Checkpoint, and Resume Packet
  • build the core trajectory → checkpoint → resume services
  • preserve the renderer and deterministic sanitizer
  • keep API credentials server-side
  • add health reporting, rate limits, request-budget safeguards, and automated tests
  • run and debug the local implementation
  • prepare the initial Build Week documentation

After the primary Codex build, a final assisted implementation and QA pass added the /api/chat Conversation Worker, natural-chat interface, Guided Live Demo, exchange-level extraction, renderer and expansion refinements, extended tests, deployment isolation, and presentation improvements.

Primary Codex /feedback Session ID:

019f833e-e859-7d10-955f-449c721eda83

What was added during Build Week

CogWave existed before Build Week as a research prototype containing:

  • an interactive cognitive graph
  • gate-first extraction
  • typed cognitive nodes and semantic relations
  • source anchors
  • expansion and detail layers
  • bilingual rendering
  • JSON export
  • a deterministic sanitizer
  • recorded example trajectories

During Build Week, we added:

  • OpenAI Responses API integration with GPT-5.6
  • strict structured-output contracts
  • a natural live-chat workflow
  • separate Conversation Worker and Trajectory Extractor calls
  • exchange-level extraction that reduces duplicate graph updates
  • a one-click Guided Live Demo
  • Cognitive Checkpoint generation
  • Resume Packet generation
  • the complete checkpoint-to-resume continuity loop
  • responsive trajectory auto-fit
  • restored strict-schema expansion layers
  • richer nine-type cognitive-state extraction
  • server-side API-key isolation
  • health reporting and public-demo budget controls
  • automated endpoint, schema, sanitizer, and interface tests
  • isolated deployment from the existing EMNLP research demo
  • deployment-ready documentation
  • a sixty-second judging path

Challenges we ran into

The hardest design problem was teaching the system when to leave the graph unchanged.

A useful cognitive trajectory cannot map every sentence. Social exchanges, acknowledgements, repetitions, formatting changes, and conversational filler should usually pass through without creating new nodes.

The salience gate therefore became a central part of the architecture. It must remain selective while still recognizing genuine observations, problems, insights, reframes, decisions, actions, emotional shifts, and durable memory anchors across both English and Chinese conversations.

A second challenge was preserving trust.

Model-generated graph structures are useful only when users can inspect where they came from. This led us to make verbatim source anchors, turn-level attribution, semantic edge reasons, and deterministic sanitization core architectural requirements.

A third challenge was preserving internal structure without allowing the graph to become unreadable.

Live extraction originally lost expansion data because the strict schema did not expose it. We restored expansion layers inside the structured-output contract and added server-side validation for their source anchors.

We also changed the live workflow from extracting the user and assistant turns separately to observing each completed exchange once. This reduced duplicate nodes and produced clearer cognitive stages.

Finally, the renderer initially followed the newest node after every update, pushing the beginning of the trajectory out of view. We replaced that behavior with responsive full-trajectory auto-fit and explicit Fit and Latest controls.

Accomplishments that we're proud of

  • Every trajectory node can be traced to the exact source language that created it
  • The graph preserves both the conclusion and the evidence behind it
  • The salience gate can leave the graph unchanged when a turn does not advance the work
  • CogWave supports nine visually distinct cognitive-state types, including memory anchors and meaningful emotion turns
  • Expansion layers preserve causes, evidence, alternatives, risks, and action steps beneath main nodes
  • The Conversation Worker and Trajectory Extractor use separate prompts and model calls
  • The full product loop operates end-to-end:

Live Chat → Cognitive Trajectory → Source Evidence → Cognitive Checkpoint → Resume Packet

  • The Guided Live Demo lets judges experience the complete workflow without preparing their own conversation
  • The project has zero npm runtime dependencies and runs using Node.js and the OpenAI Responses API
  • API credentials remain server-side, with rate limits, health checks, and public-demo budget protection
  • The OpenAI Build Week deployment is isolated from the existing EMNLP research deployment
  • The public repository preserves a timestamped engineering evidence chain from the Codex primary build through final implementation and QA
  • In a pre-Build Week evaluation across 7 real sessions and 271 turns, the salience gate filtered approximately 65% of turns, helping keep trajectories sparse and meaningful

What we learned

The cognitive-continuity problem is deeper than summarization.

A summary captures an output. A trajectory preserves how the work changed, why it changed, which evidence supported it, which decisions became settled, and what remains unresolved.

We also learned that restraint is a core intelligence capability.

A useful map is defined as much by the turns it refuses to map as by the nodes it creates. The salience gate protects the trajectory from becoming a decorative transcript.

Trust also requires provenance.

Users should be able to move from a model-generated interpretation back to the exact human or AI words that produced it. Source grounding changes a graph from an attractive visualization into an inspectable work record.

Finally, continuity requires a usable handoff.

A map becomes productive when it can compile the active state of the work into a checkpoint and resume packet that another session can immediately act on.

This distinction shaped the entire system:

Messages preserve conversation history. CogWave preserves work state.

What's next for CogWave — The Cognitive Continuity Layer for AI Work

CogWave grew from an ongoing research prototype into a working cognitive-continuity product during Build Week.

The next stage is to extend the current checkpoint-to-resume handoff into persistent, longitudinal workspaces.

Planned next steps include:

  • linking resumed sessions into one continuous trajectory
  • preserving trajectory identity across days, models, and agents
  • persistent personal and project workspaces
  • multi-agent observation
  • agent-to-agent provenance and handoff tracking
  • collaboration-state detection
  • conflict and contradiction detection across distant branches
  • longitudinal evaluation with researchers, developers, and other knowledge workers
  • integration with the broader Celestelin persistent-AI ecosystem

CogWave’s long-term goal is to become infrastructure for AI work that remains:

Visible. Verifiable. Resumable.

Built With

Share this project:

Updates