Atlas Thinking Workspace
Source: /Users/nitishchauhan/Downloads/Cursor-Extension-Technical-Specification---Google-Gemini---httpsgemini.google.comapp80f5cea89d2a9005.md
Phase: final
Index: Index - Atlas Thinking Workspace Technical Specification
Trajectory: Trajectory - Inner Map
Pipeline: CONSTITUTION - Publishable Asset Pipeline · 00 - Master Index
Status: draft
Where this one actually started
Not with “what if AI had a nicer UI.”
It started with a pile of features already large enough to lie, and a director demand: go through every document, name the intent under each feature, keep phase order honest, then do it again until nothing implementation-critical is still floating. The short version of the human prompt was basically: are you sure?
That question is the product philosophy in miniature. Atlas is not defined by how many surfaces it can spawn. It is defined by what it refuses to become under implementation pressure: another scrolling chat client with spatial stickers glued on.
What follows is the philosophy and architecture spine from that TRD pass. Feature density stays only where it proves the intent.
Atlas is not a chat client
Vision statement kept as written:
Atlas is not another AI chat client. It is a Thinking Workspace engineered to remove cognitive friction while preserving the natural flow of human thought.
Three principles decide later product calls. If a feature fights these, it does not ship as “core.”
Principle 1: Conversation is non-linear
Human reasoning branches: side explorations, tangential definitions, parallel comparisons. Atlas embraces spatial branching instead of forcing a single scrolling transcript.
Principle 2: Capture never interrupts thinking
Quick spawns, temporary scratchpads, gesture tears: zero configuration steps, no modal delay tax. If capture requires setup, the thought already left.
Principle 3: The computer organizes; the human thinks
Metadata tagging, title generation, folder structuring, relationship tracking, session compression: autonomous background work. The human stays in the reasoning loop, not the filing loop.
┌─────────────────────────────────────────┐
│ ATLAS ENGINE │
│ (The Thinking Workspace) │
└────────────────────┬────────────────────┘
│
┌─────────────────────────────┼─────────────────────────────┐
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ PRINCIPLE 1 │ │ PRINCIPLE 2 │ │ PRINCIPLE 3 │
│ Conversation is │ │ Capture Never │ │ Computer Organ- │
│ Non-Linear │ │ Interrupts │ │ izes; Human │
│ (Parallelism) │ │ Thinking │ │ Thinks │
└─────────────────┘ └─────────────────┘ └─────────────────┘
The ban that protects the product
To eliminate architectural refactoring later: do not build Atlas around a traditional chat schema.
Internal hierarchy:
Session → Workspace → Objects → Messages / content elements
- Session: master container for a discrete working state. Workspace coordinates, metadata, export records, memory graphs.
- Workspace: the 2D spatial canvas rendering active elements.
- Objects: any floating item on the workspace. Chat is one subclass of Object.
- Messages: data items inside Chat objects.
That ban is not pedantry. If Chat is the root noun, everything else becomes a plugin forever. If Object is the root noun, chat, PDF, browser, whiteboard, todo, table, sticky, and link collection share one canvas physics and one session lifecycle.
Foundation choice in the TRD: fork a local-first open-source UI (OpenMLC or Hugging Face Chat UI) so Markdown, streaming, and provider plumbing are not reinvented. Providers: OpenRouter, OpenAI, Anthropic, Google Gemini, local models via Ollama.
Responsiveness constraint (Cursor instruction): extreme responsiveness over raw feature density. Interactions must feel instantaneous at 60 FPS. UX should feel like lightweight desk cards, not heavyweight desktop windows.
Dual modes: hierarchy when you need it, space when you don’t
One toolbar toggle. Two thinking geometries.
| Mode | Intent | Structure |
|---|---|---|
| Conversation Mode | Deep analytical reasoning where logical hierarchy matters | Tree: main → 1.1 side exploration → 1.1.1 deep dive |
| Workspace Mode | Unstructured exploration and high-level synthesis | 2D canvas: objects float, resize, position freely |
Canvas engine behaviors that serve those modes:
- Free mode and auto-repulsion: overlap like real desk clutter when free; subtle physics when auto-repulsion is on so objects do not fully bury each other.
- Auto arrange: one shortcut into grid or side-by-side comparison columns.
- Minimap camera flight: corner overview; click flies the camera to that bubble.
- Session map sidebar and thread labels: list of open bubbles; labels like
main,side note,research,definition check.
Chat is one object among ten
Unified base class. Ten workspace objects:
- Chat bubble
- Markdown editor
- Browser (sandboxed)
- PDF viewer (highlight extraction)
- Image viewer
- Todo checklist
- Whiteboard
- Table / spreadsheet
- Link collection
- Floating sticky notes (zero-token local scratchpads)
Bubble state that actually matters
Per chat bubble, not global app chrome:
- Independent model selection (Claude on A, local Ollama on B, another model on C).
- Context isolation by default (fresh context window; cross-bubble injection only on demand).
- Category badges and auto color for glanceable workspace literacy.
- Importance tags: Important (long-term export), Normal, Disposable (excluded from permanent memory).
- Live status: Active, Thinking, Idle, Background Agent.
- Bubble memory: scroll, collapsed messages, selection, cursor, zoom.
- Bubble timer: quiet active-time tracking for time-allocation analytics.
Gestures are the branching API
Spatial interactions are not decoration. They are how thought forks without opening a settings panel.
- Throw bubble: drag outward from a message or selection with a stretch visual; release spawns a new floating chat carrying that selection.
- Shared clipboard (cross-chat drag): grab a response card from Bubble A, drop into Bubble B as a quoted reference block.
- Pin-to-main: pin from a side bubble embeds into the primary thread with an interactive backlink.
- Park and hover preview: flick toward top edge docks the bubble; hover shows prompt count and activity without full expand.
- Magnetic snapping: drag near another bubble for split-screen comparison.
- Promote to primary: reassign which bubble owns the session main thread.
- Snapshot: frozen read-only clone so later edits cannot destroy a good state.
- Relationships: drag one bubble onto another for a visual link without graph-editor theater.
Input that protects flow
| Shortcut | Action |
|---|---|
| Cmd/Ctrl + K | Universal command palette |
| Cmd/Ctrl + N | Quick spawn: floating chat, input already focused |
| Opt + Enter | ADHD spawn: parallel bubble beside current without losing typing flow |
| Double Space | Temporary scratch bubble: closes = destroyed, no storage write |
| Cmd/Ctrl + W | Close active bubble without confirmation modal |
In-chat controls that keep threads readable: collapsible answers; multi-level summaries (Headline / Key Points / Full); message numbering; timestamps; bookmarks and question markers; live in-bubble search.
Workers and memory: separate computation from conversation
Chat UI must not own background cognition. Seven autonomous workers read shared session data:
- Historian - temporal progression, focus durations, topic shifts
- Scout - links, docs, API parameters
- Compression - context distillation
- Summarizer - ongoing session summaries
- Question extractor - open questions into a central panel
- Relationship detector - suggests visual links between related bubbles
- Background research agent - long-running synthesis in minimized bubbles; toast on complete
Shared session memory indexes ten entity types: Questions, Insights, Projects, People, Files, Links, Models Used, Exports, Concepts, Open Loops.
Compression is product, not cleanup
Raw session data is not the durable unit.
Raw Session Data → Daily → Weekly → Monthly → Quarterly → Yearly dense knowledge
Live compression panel updates key questions, themes, decisions, and open loops during use. Long-term jobs densify daily digests upward. The point: knowledge gets denser over time, not infinitely larger.
Close the loop: search, replay, export
Universal search across questions, bubble transcripts, people/projects/links, exports and archives.
Session navigation: flat ids (S1, S2) and hierarchical tree ids; human-readable names from first prompt (Electron Setup, Python Script); bottom timeline of spawn/return events; workspace replay that restores panel geometry, zoom, and scroll as first-class product behavior, not a nostalgic screenshot.
Session closure workflow: closing the primary bubble offers close-session. On confirm: save, compress, export.
Example export directory:
Morning Research/
├── S1.md
├── S2.md
├── S3.md
├── summary.md
├── questions.md
├── session.json
└── workspace.jsonFormats: Markdown (with color tags and backlinks), JSON (raw session and positions), PDF, workspace snapshot image. Local, proprietary-free durable artifacts.
Build order so philosophy survives Cursor
The TRD’s phase sequence is itself a product claim: schema and canvas before gesture theater; workers and compression after the object model is real.
| Phase | Target | Deliverables |
|---|---|---|
| 1 | Core schema and foundation | OpenMLC/HF Chat UI fork; Session/Workspace/Object/Message/MemoryItem; IndexedDB + local file bridges |
| 2 | Spatial canvas | 60 FPS pan/zoom/drag/resize; Conversation vs Workspace toggle; minimap, repulsion, snap, dock, replay |
| 3 | Bubble engine and objects | Ten object types; multi-model, badges, colors, importance, viewport memory, timers; Cmd+K / Cmd+N / Opt+Enter / Double-Space |
| 4 | Gestures and cross-data flow | Throw, card drag-drop, pin-to-main, park; hover preview, snapshot, relationships |
| 5 | Workers and memory | Isolated worker architecture; seven workers; ten-entity session memory |
| 6 | Compression and export | Live compression panel; distillation ladder; universal search; multi-format export |
System data flow (kept tight): user input (canvas / shortcuts / gestures) → Electron/React canvas engine (60 FPS, Zustand) → Object Manager + AI Router → local storage and background workers → local filesystem exports.
Feature summary as intent map
| Module | Core feature | Underlying intent |
|---|---|---|
| Philosophy | Object-first schema | Avoid rigid chat constraints |
| Modes | Dual modes | Structured reasoning and spatial thought |
| Canvas | Minimap flight | Navigate without hunting |
| Canvas | Workspace replay | Reconstruct past thinking geometry |
| Objects | Ten workspace objects | One canvas environment for thinking tools |
| Bubbles | Multi-model per bubble | Compare models without global mode switches |
| Bubbles | Bubble memory | View state is part of cognition support |
| Inputs | ADHD spawn | Branch without focus loss |
| Inputs | Temporary scratch | Curiosity without permanent clutter |
| Gestures | Throw bubble | Thought branching as a body motion |
| Gestures | Shared clipboard | Cross-pollinate without copy ritual |
| Gestures | Pin-to-main | Elevate findings into the main thread |
| Workers | Seven AI workers | Background processing without UI lag |
| Memory | Knowledge compression | Prevent infinite transcript bloat |
| Export | Clean directory export | Local, legible ownership of the work |
What this thread was really hunting
Not a longer feature list.
A completeness-safe architecture that:
- Forbids chat-schema gravity.
- Makes capture cheaper than interruption.
- Treats compression and export as core modules, not end-of-sprint leftovers.
- Orders implementation so the desk-card feel and the object model land before agent theater.
If Atlas ships as a pretty multi-pane ChatGPT, the documents failed. If it ships as a session-first workspace where chat is one object among many, and the computer quietly densifies what you already thought, the philosophy held.
That is the standard the “are you sure?” pass was for.