vibeship-spark-intelligence
a self-evolving intelligent companion
Stars: 101
Spark Intelligence is a self-evolving AI companion that runs 100% on your machine as a local AI companion. It captures, distills, transforms, and delivers advisory context to help you act with better context. It is designed to convert experience into adaptive operational behavior, not just stored memory. The tool is beyond a learning loop, continuously learning and growing smarter through use. It provides a distillation pipeline, transformation layer, advisory delivery, EIDOS loop, domain chips, observability surfaces, and a CLI for easy interaction. The architecture involves event capture, queue, bridge worker, pipeline, quality gate, cognitive learner, and more. The Obsidian Observatory integration allows users to browse, search, and query insights, decisions, and quality verdicts in a human-readable vault.
README:
Learns constantly. Adapts with your flow. Runs 100% on your machine as a local AI companion that turns past work into future-ready behavior. It is designed to be beyond a learning loop.
You do work -> Spark captures memory -> Spark distills and transforms it -> Spark delivers advisory context -> You act with better context -> Outcomes re-enter the loop
Spark Intelligence is a self-evolving AI companion designed to grow smarter through use.
It is:
- Not a chatbot.
- Not a fixed rule set.
- A living intelligence runtime that continuously converts experience into adaptive operational behavior, not just stored memory.
The goal is to keep context, patterns, and practical lessons in a form that your agent can actually use at the right moment.
- Capture: hooks and events from your agent sessions are converted into structured memories.
- Distill: noisy data is filtered into reliable, action-oriented insights.
- Transform: high-value items are shaped for practical reuse (prioritized by reliability, context match, and usefulness).
- Store: distilled wisdom is persisted and versioned in local memory stores.
- Act: advisory and context updates are prepared for the right point in workflow.
- Guard: gating layers check quality, authority, cooldown, and dedupe before any advisory is surfaced.
- Learn: outcomes and follow-through are fed back to refine future recommendations.
Prerequisites:
- Python 3.10+ (Windows one-liner auto-installs latest Python 3 via
wingetwhen missing) pip- Git
- Windows one-liner path: PowerShell
- Mac/Linux one-liner path:
curl+bash
Windows one-command bootstrap (clone + venv + install + start + health):
irm https://raw.githubusercontent.com/vibeforge1111/vibeship-spark-intelligence/main/install.ps1 | iexOptional re-check (from repo root):
.\.venv\Scripts\python -m spark.cli up
.\.venv\Scripts\python -m spark.cli healthIf you already cloned the repo, run the local bootstrap:
.\install.ps1If you are running from cmd.exe or another shell:
powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/vibeforge1111/vibeship-spark-intelligence/main/install.ps1 | iex"Mac/Linux one-command bootstrap (clone + venv + install + start):
curl -fsSL https://raw.githubusercontent.com/vibeforge1111/vibeship-spark-intelligence/main/install.sh | bashThen verify runtime readiness (second command, from repo root):
./.venv/bin/python -m spark.cli up
./.venv/bin/python -m spark.cli healthMac/Linux manual install:
git clone https://github.com/vibeforge1111/vibeship-spark-intelligence
cd vibeship-spark-intelligence
python3 -m venv .venv && source .venv/bin/activate
python -m pip install -e .[services]If your system uses PEP 668 / external package management, this avoids the
externally-managed-environment error:
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -e .[services]Or run directly with editable install:
python -m pip install vibeship-spark-intelligence[services]
python -m spark.cli up# Check health
python -m spark.cli health
# View what Spark has learned
python -m spark.cli learningsWindows: run start_spark.bat from the repo root.
Lightweight mode (core only, no Pulse/watchdog): spark up --lite
Spark works with any coding agent that supports hooks or event capture.
| Agent | Integration | Guide |
|---|---|---|
| Claude Code | Hooks (PreToolUse, PostToolUse, UserPromptSubmit) | docs/claude_code.md |
| Codex | Session JSONL hook bridge (shadow/observe rollout) | docs/CODEX_HOOK_BRIDGE_ROLLOUT.md |
| Cursor / VS Code | tasks.json + emit_event | docs/cursor.md |
| OpenClaw | Session JSONL tailer | docs/openclaw/ |
- Self-evolving companion behavior — adapts from your sessions instead of staying static.
- Signal capture — hooks + event ingestion for tool actions, prompts, and outcomes.
- Distillation pipeline — low-quality/raw observations are filtered out before storage.
- Transformation layer — converts insight candidates into actionable advisory-ready forms.
- Advisory delivery — pre-tool guidance ranked across retrieval sources with cool-down and dedupe.
- EIDOS loop — prediction → outcome → evaluation for continuous quality updates.
- Domain chips — pluggable expertise modules that can specialize behavior.
-
Observability surfaces — Obsidian Observatory in-repo, plus optional external Spark Pulse (separate
vibeship-spark-pulseapp;spark_pulse.pyis a redirector) and local Meta-Ralph views. -
CLI —
spark status,spark learnings,spark promote,spark up/down, and more. - Hot-reloadable config — tuneables with schema checks and live behavior shifts.
Your Agent (Claude Code / Cursor / OpenClaw)
-> hooks capture events
-> queue -> bridge worker -> pipeline
-> quality gate (Meta-Ralph) -> cognitive learner
-> distillation -> transformation -> advisory packaging
-> pre-tool advisory surfaced + context files refreshed
Spark ships with an Obsidian integration that turns the entire intelligence pipeline into a human-readable vault you can browse, search, and query — every insight, every decision, every quality verdict, visible in one place.
- Download Obsidian (free, available on Windows / Mac / Linux)
- Install and open it
# From the spark-intelligence repo:
python scripts/generate_observatory.py --force --verboseThis reads your ~/.spark/ state files and generates ~465+ markdown pages in under 1 second.
Default vault location: ~/Documents/Obsidian Vault/Spark-Intelligence-Observatory
To change it, edit observatory.vault_dir in ~/.spark/tuneables.json or config/tuneables.json.
- In Obsidian: File > Open vault > Open folder as vault
- Select
Spark-Intelligence-Observatory - It opens to
_observatory/flow.md— the main pipeline dashboard
The vault comes pre-configured with:
- Dataview plugin pre-installed (for live queries on all data)
- Workspace set to open the Flow Dashboard + Dataview Dashboard
- Graph view color-coded: green = pipeline stages, blue = explorer items, orange = advisory packets
If Dataview didn't auto-install from the pre-configured vault:
- Go to Settings > Community plugins > Turn on community plugins
- Click Browse > search "Dataview" > Install > Enable
- The
Dashboard.mdqueries will now render live tables
A live Mermaid diagram of the full 12-stage pipeline with embedded metrics — queue depth, processing rate, insight counts, advisory follow rate, and more. Plus a system health table with status badges.
Each pipeline stage gets its own page with health metrics, recent activity, and upstream/downstream links:
| Stage | What it shows |
|---|---|
| Event Capture | Hook heartbeat, session tracking |
| Queue | Pending events, file size, overflow |
| Pipeline | Processing rate, batch size, empty cycles |
| Memory Capture | Importance scores, category distribution |
| Meta-Ralph | Quality verdicts, pass rate, score distribution |
| Cognitive Learner | Insight count, reliability leaders, categories |
| EIDOS | Episodes, steps, distillations, predict-evaluate loop |
| Advisory | Follow rate, source effectiveness, recent advice |
| Promotion | Targets, recent activity, result distribution |
| Chips | Domain modules, per-chip activity and size |
| Predictions | Outcomes, surprise tracking, link rate |
| Tuneables | Current config, all sections listed |
Click into any data store and browse individual items:
| Dataset | Pages | What you see |
|---|---|---|
| Cognitive Insights | ~150 detail pages | Reliability, validations, evidence, counter-examples |
| EIDOS Distillations | ~90 detail pages | Statement, confidence, domains, triggers |
| EIDOS Episodes | ~100 detail pages | Goal, outcome, every step with prediction vs evaluation |
| Meta-Ralph Verdicts | ~100 detail pages | Score breakdown (6 dimensions), input text, issues |
| Advisory Decisions | Index table | Every emit/suppress/block decision with reasons |
| Implicit Feedback | Index table | Followed/ignored signals, per-tool follow rates |
| Retrieval Routing | Index table | Route distribution, why advice was/wasn't surfaced |
| Tuneable Evolution | Index table | Parameter changes over time with impact analysis |
| Promotions | Index table | What got promoted to CLAUDE.md and why |
| Advisory Effectiveness | Index table | Source effectiveness, overall follow rate |
A spatial layout of the pipeline — drag, zoom, click through to any stage. Great for presentations or getting the big picture.
Pre-built live queries you can customize:
- High-reliability insights (90%+)
- Promoted insights and where they went
- Recent successful and failed episodes
- Meta-Ralph verdicts with high scores
- Most-retrieved distillations
- Advisory health and feedback signals
- System evolution tracking
When Spark's pipeline is running, the observatory auto-refreshes every 120 seconds. No manual regeneration needed. To regenerate manually:
python scripts/generate_observatory.py --force --verboseAll settings live in the observatory section of your tuneables:
{
"observatory": {
"enabled": true,
"auto_sync": true,
"sync_cooldown_s": 120,
"vault_dir": "path/to/your/vault",
"generate_canvas": true,
"max_recent_items": 20,
"explore_cognitive_max": 200,
"explore_distillations_max": 200,
"explore_episodes_max": 100,
"explore_verdicts_max": 100,
"explore_decisions_max": 200,
"explore_feedback_max": 200,
"explore_routing_max": 100,
"explore_tuning_max": 200
}
}Edit ~/.spark/tuneables.json (runtime) or config/tuneables.json (version-controlled).
-
Start from
flow.md— it's the entry point. Drill down into stages, then into the explorer. -
Don't edit
_observatory/files — they get regenerated. UseDashboard.mdor create your own notes alongside. -
Use Graph View — filter to
_observatoryto see how everything connects. - Bookmark items — bookmarks persist across regenerations since file paths stay stable.
- Keep limits under 500 per explorer section for smooth Obsidian performance.
-
Pin
flow.mdas a tab — always-visible health check. -
Use the Canvas for demos —
flow.canvasis a great way to explain the system to others.
Full guide: docs/OBSIDIAN_OBSERVATORY_GUIDE.md
-
Start here (canonical onboarding):
docs/SPARK_ONBOARDING_COMPLETE.md -
Fast path (5 minutes):
docs/GETTING_STARTED_5_MIN.md -
CLI + operations quickstart:
docs/QUICKSTART.md -
Obsidian Observatory:
docs/OBSIDIAN_OBSERVATORY_GUIDE.md -
Docs index:
docs/DOCS_INDEX.md -
Repo hygiene policy:
REPO_HYGIENE.md - Website: spark.vibeship.co
-
Contributing:
CONTRIBUTING.md(local setup, PR flow, and safety expectations)
This is a self-evolving system. If you are planning a public release or high-autonomy deployment:
- Read first:
docs/AI_MANIFESTO.md - Read first: https://aimanifesto.vibeship.co/
docs/RESPONSIBLE_PUBLIC_RELEASE.mddocs/security/THREAT_MODEL.md-
SECURITY.mdfor vulnerability reporting
MIT — free to use, modify, and distribute.
Built by Vibeship
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for vibeship-spark-intelligence
Similar Open Source Tools
vibeship-spark-intelligence
Spark Intelligence is a self-evolving AI companion that runs 100% on your machine as a local AI companion. It captures, distills, transforms, and delivers advisory context to help you act with better context. It is designed to convert experience into adaptive operational behavior, not just stored memory. The tool is beyond a learning loop, continuously learning and growing smarter through use. It provides a distillation pipeline, transformation layer, advisory delivery, EIDOS loop, domain chips, observability surfaces, and a CLI for easy interaction. The architecture involves event capture, queue, bridge worker, pipeline, quality gate, cognitive learner, and more. The Obsidian Observatory integration allows users to browse, search, and query insights, decisions, and quality verdicts in a human-readable vault.
iloom-cli
iloom is a tool designed to streamline AI-assisted development by focusing on maintaining alignment between human developers and AI agents. It treats context as a first-class concern, persisting AI reasoning in issue comments rather than temporary chats. The tool allows users to collaborate with AI agents in an isolated environment, switch between complex features without losing context, document AI decisions publicly, and capture key insights and lessons learned from AI sessions. iloom is not just a tool for managing git worktrees, but a control plane for maintaining alignment between users and their AI assistants.
postgresai
PostgresAI is an AI-native PostgreSQL observability tool designed for monitoring, health checks, and root cause analysis. It provides structured reports and metrics for AI consumption, tracks problems from detection to resolution, offers over 45 health checks including bloat, indexes, queries, settings, and security, and features Active Session History similar to Oracle ASH. PostgresAI is part of the Self-Driving Postgres initiative, aiming to make Postgres autonomous. It includes expert dashboards following the Four Golden Signals methodology and is battle-tested with companies like GitLab, Miro, Chewy, and more.
empirica
Empirica is an epistemic self-awareness framework for AI agents to understand their knowledge boundaries. It introduces epistemic vectors to measure knowledge state and uncertainty, enabling honest communication. The tool emerged from 600+ real working sessions across various AI systems, providing cognitive infrastructure for distinguishing between confident knowledge and guessing. Empirica's 13 foundational vectors cover engagement, domain knowledge depth, execution capability, information access, understanding clarity, coherence, signal-to-noise ratio, information richness, working state, progress rate, task completion level, work significance, and explicit doubt tracking. It is applicable across industries like software development, research, healthcare, legal, education, and finance, aiding in tasks such as code review, hypothesis testing, diagnostic confidence, case analysis, learning assessment, and risk assessment.
evalchemy
Evalchemy is a unified and easy-to-use toolkit for evaluating language models, focusing on post-trained models. It integrates multiple existing benchmarks such as RepoBench, AlpacaEval, and ZeroEval. Key features include unified installation, parallel evaluation, simplified usage, and results management. Users can run various benchmarks with a consistent command-line interface and track results locally or integrate with a database for systematic tracking and leaderboard submission.
airunner
AI Runner is a multi-modal AI interface that allows users to run open-source large language models and AI image generators on their own hardware. The tool provides features such as voice-based chatbot conversations, text-to-speech, speech-to-text, vision-to-text, text generation with large language models, image generation capabilities, image manipulation tools, utility functions, and more. It aims to provide a stable and user-friendly experience with security updates, a new UI, and a streamlined installation process. The application is designed to run offline on users' hardware without relying on a web server, offering a smooth and responsive user experience.
LEANN
LEANN is an innovative vector database that democratizes personal AI, transforming your laptop into a powerful RAG system that can index and search through millions of documents using 97% less storage than traditional solutions without accuracy loss. It achieves this through graph-based selective recomputation and high-degree preserving pruning, computing embeddings on-demand instead of storing them all. LEANN allows semantic search of file system, emails, browser history, chat history, codebase, or external knowledge bases on your laptop with zero cloud costs and complete privacy. It is a drop-in semantic search MCP service fully compatible with Claude Code, enabling intelligent retrieval without changing your workflow.
optopsy
Optopsy is a fast, flexible backtesting library for options strategies in Python. It helps users generate comprehensive performance statistics from historical options data to answer questions like 'How do iron condors perform on SPX?' or 'What delta range produces the best results for covered calls?' The library features an AI Chat UI for natural language interaction, a trade simulator for full trade-by-trade simulation, 28 built-in strategies, live data providers, smart caching, entry signals with TA indicators, and returns DataFrames that integrate with existing workflows.
explain-openclaw
Explain OpenClaw is a comprehensive documentation repository for the OpenClaw framework, a self-hosted AI assistant platform. It covers various aspects such as plain English explanations, technical architecture, deployment scenarios, privacy and safety measures, security audits, worst-case security scenarios, optimizations, and AI model comparisons. The repository serves as a living knowledge base with beginner-friendly explanations and detailed technical insights for contributors.
parlant
Parlant is a structured approach to building and guiding customer-facing AI agents. It allows developers to create and manage robust AI agents, providing specific feedback on agent behavior and helping understand user intentions better. With features like guidelines, glossary, coherence checks, dynamic context, and guided tool use, Parlant offers control over agent responses and behavior. Developer-friendly aspects include instant changes, Git integration, clean architecture, and type safety. It enables confident deployment with scalability, effective debugging, and validation before deployment. Parlant works with major LLM providers and offers client SDKs for Python and TypeScript. The tool facilitates natural customer interactions through asynchronous communication and provides a chat UI for testing new behaviors before deployment.
squad
Squad is an AI development tool that provides a team of specialists (frontend, backend, tester, lead) through GitHub Copilot. Each team member runs in its own context, learns your codebase, shares decisions, and improves over time. The tool works by launching agents in parallel to work on tasks simultaneously, with knowledge compounding across sessions. Squad stores team-wide decisions in `decisions.md` and individual agent learnings in `history.md`. The tool operates within a 200K token context window per agent, with optimizations to maximize actual work capacity. Squad's memory architecture includes `charter.md`, `history.md`, `decisions.md`, and `log/` for session history. The tool creates a `.ai-team/` folder with team roster, routing, decisions, and agent information, ensuring persistence and knowledge sharing. Squad allows for adding and removing team members, review protocols, and issue assignment and triage integration with GitHub Issues. It offers various features like client compatibility, VS Code support, project boards integration, label taxonomy, notifications, MCP setup guide, plugin marketplace, universe expansion, and more.
factorio-learning-environment
Factorio Learning Environment is an open source framework designed for developing and evaluating LLM agents in the game of Factorio. It provides two settings: Lab-play with structured tasks and Open-play for building large factories. Results show limitations in spatial reasoning and automation strategies. Agents interact with the environment through code synthesis, observation, action, and feedback. Tools are provided for game actions and state representation. Agents operate in episodes with observation, planning, and action execution. Tasks specify agent goals and are implemented in JSON files. The project structure includes directories for agents, environment, cluster, data, docs, eval, and more. A database is used for checkpointing agent steps. Benchmarks show performance metrics for different configurations.
metis
Metis is an open-source, AI-driven tool for deep security code review, created by Arm's Product Security Team. It helps engineers detect subtle vulnerabilities, improve secure coding practices, and reduce review fatigue. Metis uses LLMs for semantic understanding and reasoning, RAG for context-aware reviews, and supports multiple languages and vector store backends. It provides a plugin-friendly and extensible architecture, named after the Greek goddess of wisdom, Metis. The tool is designed for large, complex, or legacy codebases where traditional tooling falls short.
uLoopMCP
uLoopMCP is a Unity integration tool designed to let AI drive your Unity project forward with minimal human intervention. It provides a 'self-hosted development loop' where an AI can compile, run tests, inspect logs, and fix issues using tools like compile, run-tests, get-logs, and clear-console. It also allows AI to operate the Unity Editor itself—creating objects, calling menu items, inspecting scenes, and refining UI layouts from screenshots via tools like execute-dynamic-code, execute-menu-item, and capture-window. The tool enables AI-driven development loops to run autonomously inside existing Unity projects.
open-mercato
Open Mercato is a modern, AI-supportive platform designed for shipping enterprise-grade CRMs, ERPs, and commerce backends. It offers modular architecture, custom entities, multi-tenancy, RBAC, data indexing, event workflows, and more. The tool is built with a modern stack including Next.js, TypeScript, zod, Awilix DI, MikroORM, and bcryptjs. It also features an AI Assistant for schema discovery, API execution, and hybrid search. Open Mercato provides data encryption, migration guides, Docker setups, standalone app creation, and follows a spec-driven development approach. The Enterprise Edition offers additional support, SLA options, and advanced features beyond the open-source Core version.
LLMTSCS
LLMLight is a novel framework that employs Large Language Models (LLMs) as decision-making agents for Traffic Signal Control (TSC). The framework leverages the advanced generalization capabilities of LLMs to engage in a reasoning and decision-making process akin to human intuition for effective traffic control. LLMLight has been demonstrated to be remarkably effective, generalizable, and interpretable against various transportation-based and RL-based baselines on nine real-world and synthetic datasets.
For similar tasks
vibeship-spark-intelligence
Spark Intelligence is a self-evolving AI companion that runs 100% on your machine as a local AI companion. It captures, distills, transforms, and delivers advisory context to help you act with better context. It is designed to convert experience into adaptive operational behavior, not just stored memory. The tool is beyond a learning loop, continuously learning and growing smarter through use. It provides a distillation pipeline, transformation layer, advisory delivery, EIDOS loop, domain chips, observability surfaces, and a CLI for easy interaction. The architecture involves event capture, queue, bridge worker, pipeline, quality gate, cognitive learner, and more. The Obsidian Observatory integration allows users to browse, search, and query insights, decisions, and quality verdicts in a human-readable vault.
For similar jobs
weave
Weave is a toolkit for developing Generative AI applications, built by Weights & Biases. With Weave, you can log and debug language model inputs, outputs, and traces; build rigorous, apples-to-apples evaluations for language model use cases; and organize all the information generated across the LLM workflow, from experimentation to evaluations to production. Weave aims to bring rigor, best-practices, and composability to the inherently experimental process of developing Generative AI software, without introducing cognitive overhead.
LLMStack
LLMStack is a no-code platform for building generative AI agents, workflows, and chatbots. It allows users to connect their own data, internal tools, and GPT-powered models without any coding experience. LLMStack can be deployed to the cloud or on-premise and can be accessed via HTTP API or triggered from Slack or Discord.
VisionCraft
The VisionCraft API is a free API for using over 100 different AI models. From images to sound.
kaito
Kaito is an operator that automates the AI/ML inference model deployment in a Kubernetes cluster. It manages large model files using container images, avoids tuning deployment parameters to fit GPU hardware by providing preset configurations, auto-provisions GPU nodes based on model requirements, and hosts large model images in the public Microsoft Container Registry (MCR) if the license allows. Using Kaito, the workflow of onboarding large AI inference models in Kubernetes is largely simplified.
PyRIT
PyRIT is an open access automation framework designed to empower security professionals and ML engineers to red team foundation models and their applications. It automates AI Red Teaming tasks to allow operators to focus on more complicated and time-consuming tasks and can also identify security harms such as misuse (e.g., malware generation, jailbreaking), and privacy harms (e.g., identity theft). The goal is to allow researchers to have a baseline of how well their model and entire inference pipeline is doing against different harm categories and to be able to compare that baseline to future iterations of their model. This allows them to have empirical data on how well their model is doing today, and detect any degradation of performance based on future improvements.
tabby
Tabby is a self-hosted AI coding assistant, offering an open-source and on-premises alternative to GitHub Copilot. It boasts several key features: * Self-contained, with no need for a DBMS or cloud service. * OpenAPI interface, easy to integrate with existing infrastructure (e.g Cloud IDE). * Supports consumer-grade GPUs.
spear
SPEAR (Simulator for Photorealistic Embodied AI Research) is a powerful tool for training embodied agents. It features 300 unique virtual indoor environments with 2,566 unique rooms and 17,234 unique objects that can be manipulated individually. Each environment is designed by a professional artist and features detailed geometry, photorealistic materials, and a unique floor plan and object layout. SPEAR is implemented as Unreal Engine assets and provides an OpenAI Gym interface for interacting with the environments via Python.
Magick
Magick is a groundbreaking visual AIDE (Artificial Intelligence Development Environment) for no-code data pipelines and multimodal agents. Magick can connect to other services and comes with nodes and templates well-suited for intelligent agents, chatbots, complex reasoning systems and realistic characters.
