An autonomous exploration system that discovers what it didn't know it was looking for
npm install curiosity-engineAn autonomous exploration system that discovers what it didn't know it was looking for.
This is my passion project. Most AI tools work like search engines with extra steps: you ask for X, they find X. Curiosity Engine is different. It wanders. It follows threads. It makes unexpected connections and brings back things that surprise even me.
The difference between searching and discovering is the difference between "find me information about black holes" and "huh, I wonder why..." followed by three hours of rabbit holes. This is the three hours of rabbit holes, automated.
Think of it as an autonomous research assistant with ADHD and good instincts. You give it seeds - topics, questions, URLs that interest you - and it explores outward from there. It evaluates what it finds, follows promising threads, ignores dead ends, and surfaces discoveries that score above a threshold.
It doesn't try to answer questions. It tries to find questions worth asking.
``bash`
npm install -g curiosity-engine
Or from source:
`bash`
git clone https://github.com/katieblackabee/curiosity-engine
cd curiosity-engine
npm install
npm run build
`bashExplore from a topic or URL
npx curiosity explore "Why do we dream?"
npx curiosity explore "https://example.com/interesting-article"
$3
Run both the API server and web UI:
bash
Terminal 1: API server (port 3333)
npm run serverTerminal 2: Web UI (port 5173)
cd web
npm install
npm run dev
`Open http://localhost:5173
The web interface gives you:
- Interactive knowledge graph visualization (watch the connections form)
- Seed management (add, edit, explore)
- Discovery browser with significance filters
- Live exploration with real-time updates (very satisfying to watch)
- Settings configuration
$3
bash
cd web && npm run build
cd .. && npm run server # Serves from web/dist
`How It Works
1. Seeds: Start with something interesting - a phrase, a question, a URL
2. Explore: Follow threads across the web, extracting readable content
3. Evaluate: Score content by novelty, connection potential, explanatory power, contradiction, and generativity
4. Discover: Save findings that exceed the discovery threshold
5. Queue: Store promising threads for future exploration
6. Report: Surface discoveries via digests and the web interface
The evaluation is the interesting part. Not everything is equally interesting, and Curiosity Engine has opinions about what makes something worth paying attention to.
Configuration
Copy and edit:
bash
cp config/default.yaml config/local.yaml
`Key options:
yaml
curiosity:
exploration:
max_depth: 5 # How deep to follow threads
fetch_delay_ms: 1000 # Be nice to servers
source_timeout_ms: 30000 interestingness:
weights:
novelty: 0.30 # Is this new to me?
connection_potential: 0.25 # Does this link to other things I know?
explanatory_power: 0.20 # Does this help explain something?
contradiction: 0.15 # Does this challenge what I thought?
generativity: 0.10 # Does this spark new questions?
follow_threshold: 0.4 # Minimum score to follow a thread
discovery_threshold: 0.6 # Minimum score to save as discovery
threads:
max_open: 50 # How many threads to keep active
decay_days: 14 # Old threads lose priority
revisit_probability: 0.1 # Sometimes revisit old ground
reporting:
daily_digest: true
digest_time: "09:00"
breakthrough_alerts: true # Tell me about the really good stuff
breakthrough_threshold: 0.8
`Project Structure
curiosity-engine/
├── src/
│ ├── index.ts # CLI entry point
│ ├── config.ts # Configuration loader
│ ├── types.ts # TypeScript types
│ ├── seeds/ # Seed management
│ ├── explorer/ # Core exploration loop
│ ├── sources/ # Web adapter (more coming)
│ ├── evaluator/ # Interestingness scoring
│ ├── threads/ # Thread pool
│ ├── journal/ # Discovery storage
│ ├── reporter/ # Digests and alerts
│ ├── scheduler/ # Exploration timing
│ └── server/ # API server
├── web/ # React web interface
├── config/
│ └── default.yaml
└── data/ # Runtime data (gitignored)
API Endpoints
The server exposes these on port 3333:
GET /api/seeds List seeds
POST /api/seeds Create seed
GET /api/seeds/:id Get seed
PATCH /api/seeds/:id Update seed
DELETE /api/seeds/:id Archive seedGET /api/threads List threads
GET /api/threads/:id Get thread
GET /api/discoveries List discoveries
GET /api/discoveries/:id Get discovery
GET /api/graph Get graph data
GET /api/graph/expand/:id Expand node
POST /api/explore Start exploration
GET /api/explore/status Get exploration status
DELETE /api/explore Cancel exploration
GET /api/health Health check
WS /ws WebSocket for live updates
What's Implemented
- CLI: Full command set (explore, add-seed, list-seeds, digest, status)
- Web source: Fetching with Readability extraction, robots.txt respect
- Evaluator: Heuristic-based scoring across 5 dimensions
- Thread pool: Persistence, decay, priority-based selection
- Journal: Discovery storage with markdown export
- Reporter: Digest generation
- API server: REST endpoints + WebSocket
- Web UI: Graph visualization, seed/discovery management, live exploration
Current Limitations
- Web only: No code/academic/local file adapters yet (coming)
- Heuristic evaluation: LLM-based scoring not yet integrated
- Single-threaded: Parallel exploration not implemented
- Settings UI: Display only, doesn't persist changes yet
Philosophy
1. Curiosity over goals - The destination isn't known in advance. That's the point.
2. Depth and breadth - Follow deep threads, notice wide connections.
3. Surprise as signal - If it's predictable, it's probably not interesting.
4. Compounding knowledge - Today's discoveries are tomorrow's seeds.
5. Transparent process - Show the path, not just the destination.
This isn't a search engine. It's a discovery engine. The difference matters.
Development
bash
npm run dev # Watch mode
npm test # Run tests
npm run lint # Type check
cd web && npm run dev # Web UI dev
``MIT