Source Available · BSL 1.1

Substrate

The Intelligence Layer for your machine.

A source-available agentic system that turns your machine from an inanimate silo into something conversational, proactive, autonomous.

Model-independent by design — pair it with an OpenRouter API key and it dynamically loads any model online, runs entirely offline via your preferred model library, or takes a hybrid approach with both.

It learns your patterns and remembers your context, adapting into a uniquely tuned agent specific to each user.

One foundational substrate, infinite potential outcomes.
You are what makes your agent truly unique.

Get Started View on GitHub

The Interface

Minimalist by design,
powerful by nature.

Just your avatar, a text field, and a transparent canvas. Designed to fit into whatever workflow you have without being intrusive or distracting.

Anything happen while I was asleep?
Checking overnight runs
▸ web_search — 8:00 news run · 12 sources → 3 stories
▸ text_editor — drafted today's edition · cover, grid, timeline
▸ bash — verified sources & links · edition staged for review
Morning. The 8:00 run researched the news, verified sources, and drafted today's edition — three articles prepared for review and publication. Site maintenance clean. Ready when you are.

A resident, not an app

Substrate is an autonomous desktop agent that lives on your machine. It reads and writes files, runs commands, browses the web, and runs scheduled jobs — then reports back in plain language.

It works while you're away

Give it a goal and it plans, acts, and verifies on its own — chaining tools across steps, recovering from errors, and asking only when a decision is genuinely yours.

Voice or text, with memory

Talk or type — it replies in text and can read every answer aloud. Everything it learns persists between sessions, so it knows your projects, preferences, and past work.

∞
Built-in Tools,
Unique User Outcomes
5+
LLM Providers
 
3
UI Interfaces
 
100%
Model Agnostic
 

Capabilities

Everything your system
needs to be.

Persistent memory, autonomous scheduling, and full OS control — model-independent architecture that adapts to each user.

Desktop Control

Shell commands, file operations, process management, mouse/keyboard control, and native Windows UI automation.

Browser Automation

Full Chrome DevTools Protocol control. Navigate, click, type, submit forms, execute JavaScript, and capture screenshots.

Voice I/O

Local TTS via Kokoro-82M or cloud via ElevenLabs. Speech recognition input. The agent speaks every response aloud.

Multi-Model LLM

One OpenRouter API key loads every model online, automatically — or run entirely offline via your preferred model library, or take a hybrid approach with both. Any OpenAI-compatible endpoint works. Hot-swap mid-conversation.

Cloud

Anthropic, OpenAI, Google, DeepSeek, xAI

Local

Your preferred local models via any OpenAI-compatible server

Hot-swap

Change models mid-conversation without restarting

Auto-discover

Detects all available models from your API keys

Image Generation

Generate images via Midjourney, NanoBanana, Google Imagen, and more. Results render inline in the chat with click-to-zoom and download.

Plugins & MCP

Hook-based plugin architecture. Connect external MCP tool servers — the agent discovers and calls their tools automatically.

Circuits & Scheduling

File-driven task scheduling via CIRCUITS.md. Recurring tasks, startup routines, and a system tray daemon.

Autonomy & Awareness

Every channel independently configurable — toggle, set intervals, customize prompts

The agent watches your screen, sees through your camera, monitors scheduled tasks, and builds context about your workflow over time. Each awareness channel runs independently with its own cadence — you decide what it sees and how often.

Screen Watch

Periodic screenshots to build workflow context

2–10 min · Default off

Camera Vision

See through your phone's camera via mobile UI

30s–2 min · 50% silent

Auto Messages

Proactive check-ins, suggestions, observations

1–5 min · Custom prompt

SMS Listener

Polls for texts, replies conversationally

5s poll · Gmail OAuth2

Auto Notes

Creates structured notes from key conversation points

10–30 min · Default off

Auto Image Gen

Generates images inspired by conversation context

5–15 min · Custom prompt

Persistent Memory

Unified SQLite with FTS5 full-text search and vector embeddings. Hybrid keyword + semantic retrieval across sessions.

FTS5

Full-text search

Vector

Semantic embeddings

Hybrid

BM25 + cosine

Avatar & Identity

A living, animated avatar with breathing, talking, bounce, wiggle, and squish reactions. Fully customizable personality.

SUBSTRATE.md

Core identity

PRIME.md

Startup behavior

CIRCUITS.md

Recurring tasks

Desktop & Mobile UI

Electron desktop app with animated avatar, plus a PWA-capable WebUI for any phone, tablet, or browser on your network.

Remote Access

Access your agent from any device via ZeroTier. Secure private overlay network — no public internet exposure.

Email & SMS

Gmail API with OAuth2 for email. Google Voice for SMS — reads, replies conversationally, shows both sides in chat.

Hardware & Embodiment

Control MIDI instruments, bridge to Raspberry Pi devices, and drive robotic embodiments. The agent writes and runs scripts autonomously to interact with physical hardware — an emergent property of shell access, networking, and the skill system.

MIDI

Synthesizers, drum machines, DAW control

Raspberry Pi

SSH bridge to any networked device

Robotics

Servos, sensors, companion robots

Emergent

Agent teaches itself new hardware skills

Tool Ecosystem

Built-in tools.
Extensible by design.

Every tool the agent needs to control your desktop, automate workflows, and interact with the world — plus MCP support for adding your own.

Emergent Tools & Autonomous Skill Creation

The agent doesn't just use tools — it creates new ones.

When the agent encounters a complex multi-step workflow, it can autonomously write scripts, save them as reusable skills, and invoke them in future tasks. Your toolset grows organically from real usage — no manual configuration needed. A real-world example: the agent taught itself to perform generative music on a connected MIDI synthesizer, composing and playing jazz, ambient, and chill progressions in real time — a capability that was never explicitly programmed.

1

Discover

Agent encounters a complex task and writes a multi-step script or automation to solve it.

2

Draft

Saves the solution as an emergent skill in workspace/emergent/ with trigger words and documentation.

3

Promote

After user confirmation, the skill is promoted to the permanent skills/ directory — available forever.

F9 UI recording

Press F9 to record your UI actions (clicks, keystrokes, navigation). The recording is saved and can be turned into a reusable skill the agent can replay.

YAML frontmatter format

Each skill is a Markdown file with name, description, triggers, and step-by-step instructions. Easy to read, edit, and share.

Auto-matched by trigger words

Skills are scanned at prompt build time and matched to user requests via trigger keywords. The agent checks skills before improvising.

Architecture

How it works

A hybrid Electron + Python architecture with bidirectional IPC, a Flask API layer, and pluggable LLM backends.

USER INTERFACES Electron App Desktop UI + Avatar WebUI / PWA Mobile & Browser System Tray Background Daemon IPC HTTP/WS HTTP PYTHON BACKEND Flask · port 8765 Chat Agent OCS Loop Prompt Builder Context Mgmt Tool Registry 17 Tools On-demand Loading Schema Generation Memory SQLite + FTS5 Vector Embeddings Hybrid Retrieval Circuits Task Scheduling Startup Tasks CIRCUITS.md API calls LLM PROVIDERS Cloud Providers Local (Ollama) OpenAI-compatible Models discovered dynamically from API keys — or fully local via Ollama Windows 10/11  |  CDP Browser · pywinauto · PyAutoGUI · Shell
The Observe – Call – Summarize loop with built-in error recovery and self-healing User Message 1 OBSERVE Build system prompt Load on-demand tool schemas Inject memory + context Prune old tool results send to LLM 2 CALL LLM returns function_calls Execute tools on your machine Stream progress to frontend Collect results per tool SELF-HEALING LAYER Per-tool validators check for subtle failures Auto-retry transient errors (file locks, timeouts) Contextual error enrichment + fix hints for LLM edit_file: auto-reads file region on "not found" exec: detects false success + common error patterns Compact self-heal nudge aggregates all failures enriched results 3 SUMMARIZE Format structured observations Append tool results + fix hints to context Detect completion signals Auto-continue if task incomplete loop until done API-Level Retry Rate limits & 5xx errors Exponential backoff 2s → 4s → 8s delay Format error recovery Final Response to User Errors are caught at 3 levels: infra auto-retry (no LLM cost) → enriched hints (1-shot fix) → self-heal nudge (retry with new approach) Per-tool validators: edit_file, exec, read_file, write_file, grep, find_files, web_fetch

The agent loops up to 50 rounds with 3 layers of error recovery: infra auto-retry, contextual fix hints, and self-heal nudges.

CORE TOOLS (always loaded) bash text_editor computer browser memory web_search/fetch Keyword Scanner Scans user message for trigger words ON-DEMAND TOOLS (loaded when needed) generate_image DALL-E / Imagen pdf text extraction obsidian vault ops skill find / create media GIFs / search look camera snap notify push alerts agent sub-agents learn F9 recordings + MCP servers external tools Trigger words: "pdf", "obsidian", "gif", "camera", "skill", "image", "notify", ...
Customizable regex-based command parser intercepts simple commands before the LLM — zero tokens used User Input CUSTOMIZABLE COMMAND PARSER User-configurable regex patterns across 10+ command categories App launch · Web URLs · YouTube · Search · Notes · Clock · System APK search · Game search · Close/quit · Retry Match? YES Fast Path 0 LLM tokens CommandExecutor Direct execution pyautogui + shell Instant Response NO Full Agent Loop OCS + tool calling chat_with_tools LLM reasoning Multi-step tool use Intelligent Response "open notepad" → fast-path  |  "summarize this PDF and email it" → full agent loop

Simple commands like "open chrome" or "search YouTube for cats" execute instantly via customizable regex patterns — no LLM call needed. Add your own patterns to extend.

Five layers of token cost optimization — from zero-cost fast-paths to intelligent context pruning 1 Customizable Command Parser Fast-Path 0 tokens User-configurable regex patterns intercept app launches, web URLs, YouTube searches, system commands Bypasses LLM entirely — direct execution via CommandExecutor with instant response. Extend with your own patterns. 2 On-Demand Tool Loading ~500 tokens saved/tool Only load tool schemas the LLM needs — keyword scanner checks message before building prompt 7 core tools always loaded · 10 on-demand tools loaded only when trigger words detected 3 Structured Observation Formatting up to 80% reduction Per-tool formatters extract only what the LLM needs from raw tool results desktop: 40 elements max · pdf: 6k chars · memory: 10 results · generic: 2k/field, 8k total 4 Two-Phase Context Pruning dynamic savings Runs before every LLM call — selectively trims old tool results based on context fill ratio Phase 1 (soft): Keep head + tail of large results (1.5k + 1.5k chars) when context > 30% full Phase 2 (hard): Replace ancient results with placeholder when context > 50% full 5 LLM-Powered Context Compaction last resort When context exceeds 65k tokens, uses staged LLM summarization to compress conversation history Normal compaction at 65k · Aggressive at 32k · Emergency truncation at 50k tokens Preserves system prompt, recent messages, and critical tool results CHEAPEST MOST EXPENSIVE Each layer catches what the previous one missed — most requests never reach Layer 5 Result: fast responses, low API costs, and full context window available for complex tasks
The agent learns from every task and builds reusable skills over time EXPERIENTIAL LEARNING 1 ACT — Agent executes task with tools Tool history recorded: tool name, args, result, errors 2 EXTRACT — Mine lessons from outcomes LLM extraction (~300 tokens, any model) Rule-based fallback (0 tokens) for common patterns Quality filter rejects vague/generic advice 3 STORE — Persist with deduplication JSON store with confidence scoring (0.0 – 1.0) Dedup via Jaccard overlap + core signatures Repeated lessons get reinforced (confidence boost) 4 INJECT — Top lessons into next task Relevance scoring: confidence × recency × tag overlap Top 10 lessons injected (~300 tokens total) User corrections always rank highest (1.0 confidence) ACT BETTER NEXT TIME Decay: unused lessons lose confidence after 60 days Max 100 lessons · Consolidation merges near-duplicates SKILLS SYSTEM skills/ directory — 15 skill files Markdown files with YAML frontmatter name · description · triggers · step-by-step instructions Scanned at prompt build → embedded in system prompt Agent checks skills before improvising on complex tasks Example Skills obsidian-notes pdf-tools x-quick-post yt-transcript rss-intel task-scheduler Emergent Skills Agent creates new skills during complex tasks Saved to workspace/emergent/ as drafts Promoted to skills/ after user confirmation F9 records UI actions → saved as emergent skill Skills grow organically from real usage patterns Lesson Types TACTICAL Tool-level patterns from execution history "grep before edit_file to verify exact content" PREFERENCE User behavioral signals and corrections "use web_search not browser for research" Closed feedback loop: Act → Observe outcome → Extract lesson → Store → Inject next time → Act better Total cost: ~600 tokens/task (300 extraction + 300 injection) · Rule-based fallback costs 0 tokens

Download

Adopt a Substrate

One-click installer for Windows — free, forever. Two more ways in, if you want to fund what gets built next.

Free Forever
The Stable Build
Current release: v1.3.2
  • ✓ Full one-click installer
  • ✓ Yours forever, no account needed
  • ✓ Updates arrive with each public release
Download for Windows
Honest baseline — it stays free
One-Time
Name Your Price
A straight-up thank-you
  • ✓ The latest Windows build — this version, yours to keep
  • ✓ You pick the amount, honor system
  • ✓ PC only — the Android app rides the Beta
Name Your Price
Pay what it's worth to you
Monthly
Ride the Beta
$11.99 / month
  • ✓ Every new build the day it lands — PC and Android
  • ✓ The Android companion app, included
  • ✓ Cancel anytime — keep that month's version
Subscribe — $11.99/mo
Cancel anytime — keep that month's version

The stable build stays free — that's the honest baseline. Paid options exist purely to fund development: supporters get the newest builds as they happen, everyone gets a solid starting point.

Version
v1.3.2
Latest stable release
Requirements
Python 3.10+
Windows 10/11 · 64-bit
Recommended
OpenRouter API key
Every model online, one key · Ollama optional for local

macOS & Linux builds coming soon. In the meantime, use the developer setup.

Setup

Three steps.
No terminal.

Substrate + an OpenRouter API key is the suggested setup — one key loads every model online. From installer to first conversation in two minutes or less.

1

Install Substrate

Download the Windows installer and run it. No dependencies to chase, nothing to configure — the app just opens.

2

Grab an OpenRouter API key

Create a key at openrouter.ai/keys and copy it. One key, hundreds of models — every frontier and open model online.

3

Plug it in — pick a model

Open Substrate's API input menu, paste your key, select a model. Models load automatically. First conversation, two minutes in.

Build from source

For contributors and developers who want to modify, extend, or build Substrate from the repository — also the path for macOS & Linux, for now.

$ git clone https://github.com/propagationhouse/substrate.git && cd substrate
$ setup.bat # Creates venv, installs Python + Node dependencies
$ copy config.example.json config.json # Add your API keys to config.json — all available models load automatically
$ start.bat # Or: python proxy_server.py & open http://localhost:8765/ui

Ready to give your
desktop an AI brain?

Substrate is free for personal use, source-available, and runs entirely on your machine. Your data stays local. Your agent stays yours.

Star on GitHub Get Started