ARCHIVE_Technical Specification_Old - asavschaeffer/globule GitHub Wiki

Globule MVP: Building the Semantic OS Layer

Executive Summary

Globule is not another note-taking app. It's the first step toward a semantic operating system where computers understand the meaning and connections between all user activities, not just the mechanical facts of what happened.

Core Innovation: Every input is captured, understood semantically, and becomes queryable through natural language - no files, folders, or manual organization required.

MVP Goal: Prove that semantic capture and retrieval can replace traditional file management, starting with a focused use case (operational note-taking) that demonstrates the broader paradigm shift.

The Vision: Computing That Understands Context

Today's Problem

  • We name files like meeting-notes-2024-07-03-jones-damage-FINAL-v2.txt
  • We organize information in rigid hierarchies that don't match how we think
  • We lose thoughts because the friction of proper organization breaks our flow
  • Our computers know WHAT we did but not WHY or HOW things connect

Tomorrow's Solution

$ globule ask "what was that thing about Jones and the damage?"
> Found 3 connected events from July 3:
> - 9:15 AM: "Mr Jones arrived, noticed existing fender damage"
> - 2:30 PM: "Jones claiming new damage, but we documented it this morning"
> - 2:45 PM: Photo evidence saved showing pre-existing damage

MVP Architecture: Proof of Concept

Phase 1: Semantic Capture & Retrieval (Weeks 1-2)

Goal: Demonstrate that semantic search beats folders/files

Components:

# Minimal data structure
class Globule:
    id: str
    content: str
    timestamp: datetime
    embedding: List[float]  # 384-dim from sentence-transformers

Core operations

capture(text: str) -> Globule search(query: str) -> List[Globule]

Storage: SQLite with vector extension

  • Single file database
  • JSON column for metadata
  • Vector column for embeddings
  • Full-text search as fallback

Interface: Simple CLI

$ globule add "Mr Jones arrived with damaged fender"
$ globule search "damage claims today"
$ globule ask "what happened with parking?"

Phase 2: Intelligent Parsing (Weeks 3-4)

Goal: Show that AI can extract structure without schemas

Addition:

class SmartGlobule(Globule):
    entities: List[str]      # ["mr_jones", "fender"]
    event_type: str          # "damage_report"
    extracted_data: Dict     # LLM-parsed fields

Key Innovation: Dual-track processing

  1. Embeddings capture semantic meaning
  2. LLM parsing extracts structure
  3. They cross-validate each other (checks & balances)

Phase 3: Synthesis & Insights (Weeks 5-6)

Goal: Transform from "storage" to "understanding"

Query Engine:

  • Natural language → structured search
  • Temporal queries: "what happened this morning?"
  • Entity queries: "everything about Jones"
  • Pattern queries: "unusual events today"

Synthesis Engine:

  • Combine related globules into narratives
  • Generate reports/summaries on demand
  • Surface patterns and anomalies

Technical Stack

Core Components

Component Technology Why
Storage SQLite + vector extension Single file, portable, fast
Embeddings sentence-transformers/all-MiniLM-L6-v2 Proven, CPU-friendly, 384-dim
LLM Parsing Local: Llama 3.2 3B / Cloud: Gemini Start local, scale to cloud
Interface CLI → TUI (Textual) → API Progressive enhancement

Data Flow

Input → Parallel Processing → Storage → Retrieval → Synthesis
         ├─ Embedding ──────────┐
         └─ LLM Parsing ────────┴──→ Validation

Use Case: Valet Operations (Demo Scenario)

This isn't the product - it's the proof that the paradigm works.

Throughout the day:

$ globule add "Mrs Chen's Tesla parked in B5"
$ globule add "Timmy arrived 20 min late"
$ globule voice "damage on Jones car already there when he arrived"
$ globule add "split tips 60 total between timmy barbara and me"

End of shift:

$ globule report today
> Generated comprehensive summary...
> Key incidents: Pre-existing damage documented (Jones)
> Staff: Timmy late (20min), Tips distributed ($20 each)
> Recommendations: Document Timmy's pattern (3x this week)

The Bigger Picture: Semantic OS Layer

Progressive Enhancement Path

Level 1 (MVP): Manual input → Semantic retrieval Level 2: Passive monitoring

  • File system events
  • Git commits
  • Browser history
  • Clipboard monitoring

Level 3: Full semantic layer

  • All computer operations are semantically tagged
  • Natural language queries across all activity
  • Time travel through your digital life

Example Future State

$ globule ask "what was I doing when the server crashed?"
> You were editing auth_handler.py (JWT validation)
> Had 4 Stack Overflow tabs about "bearer token expiry"  
> pytest failed 6 times on auth tests
> Last successful test was before changing line 47

Key Design Principles

  1. Capture First, Organize Never: Users just dump thoughts. AI handles organization.

  2. Semantic > Hierarchical: Information is connected by meaning, not folders.

  3. Progressive Disclosure: Start simple (text input), add capabilities without complexity.

  4. Privacy First: Local by default, cloud by choice.

  5. Domain Agnostic: Core system works for any use case, domains are just configurations.

Success Metrics

Technical

  • Sub-100ms capture latency
  • Semantic search finds relevant content traditional search misses
  • <5s to generate daily synthesis

User Experience

  • Zero organization effort required
  • Find any thought within 3 seconds
  • Discover 1+ unexpected connection per day

Business

  • Daily active usage after 1 week
  • 50%+ reduction in time spent organizing
  • Users report feeling "understood" by their computer

Next Steps

  1. Week 1: Implement core capture + embedding + search
  2. Week 2: Add temporal queries and basic CLI
  3. Week 3: Integrate LLM parsing
  4. Week 4: Build synthesis engine
  5. Week 5: Polish and demo creation
  6. Week 6: User testing with 3 personas

FAQ

Q: How is this different from Apple Intelligence or Copilot? A: Those are closed ecosystems. Globule is open, private by default, and works with any tool.

Q: Why not just use ChatGPT? A: ChatGPT doesn't remember between sessions. Globule builds a persistent semantic layer of YOUR life.

Q: What about privacy? A: Everything stays local by default. Cloud features are opt-in and encrypted.

Q: Can it integrate with existing tools? A: Yes. Phase 2 adds APIs and webhooks. ActivityWatch, git, browsers, etc.

The Ask

We're not building another app. We're prototyping the future of human-computer interaction - where your computer understands context and meaning, not just commands and files.

Give us 6 weeks to prove that files and folders are obsolete.


"The best way to predict the future is to invent it." - Alan Kay

⚠️ **GitHub.com Fallback** ⚠️