Laya: Your AI Command Center

https://laya.aay.sh

A cadence for professional orchestration.

Laya is an open-source, local-first AI notification command center that aggregates Slack, Gmail, GitHub, Jira, Notion, Outlook, and Calendar notifications — powered by local LLMs via Ollama and LM Studio, or cloud models like Claude and GPT with your own API keys. It intercepts events from your professional tools, performs autonomous research and action-staging using LLM-powered agents, and presents you with ready-to-approve Action Cards -- so the answer is ready before you open the notification.

Works with:

• Ollama and LM Studio (local LLMs)
• Claude models (Anthropic)
• GPT models (OpenAI)
• Gemini models (Google)
• Llama models and any OpenAI-compatible endpoint — via LiteLLM

Aggregates:

• Gmail
• Slack
• GitHub
• Bitbucket
• Jira
• Linear
• Notion
• Outlook (email and calendar)
• Google Calendar

How It Works

Your Tools (Jira, Slack, Gmail, Bitbucket, Calendar)
         |
         v
      n8n (local Node.js) -- normalizes events
         |
         v
   Laya Engine (Python) -- classifies, researches, stages
         |
         v
    Laya UI (Tauri + Svelte) -- Action Cards you approve or dismiss
         |
         v
      n8n -- executes approved actions (creates PRs, sends replies, etc.)

Key Features

• Multi-persona brain: Routes events to specialized AI personas (Engineer, Comms, Ops, Sales, HR, Finance) with domain-specific tools and prompts, with AI prioritization of every notification
• Card Workspaces: Agent workflows for complex tasks (bug fixes, code reviews) — interactive workspaces where you collaborate with a coding agent (Claude Code, Gemini CLI, Codex, Pi CLI, or Cursor Agent) through multiple approval steps
• Card Research: Launch on-demand deep research sessions on any card — a coding agent investigates with web search, semantic context, and sandboxed file access
• Agent inference backends: Run the classification/synthesis pipeline on an installed CLI agent's own quota instead of an API key — select a model of the form agent/<id>/<model> (Claude Code, Codex, Gemini, or Pi) for any stage. Claude Code enforces JSON schemas natively; other agents use best-effort schema + retry
• Spaces: User-defined contexts grouping event sources with per-space model and API key configurations
• Context Association: Automatically links related cards across platforms using semantic similarity and LLM confirmation. Learns from your corrections to improve grouping accuracy over time
• Cross-platform memory: Entity resolution links "BUG-1234" in Jira to "PR-891" in Bitbucket to "the payment bug" in Slack
• Daily Briefing: Morning summary of overnight activity, pending cards, and today's calendar with context
• Analytics Dashboard: Track events processed, time saved, LLM costs (broken down by feature and pipeline step), throughput over time, and approval rates
• Budget Tracking: Monitor LLM costs by feature (Pulse, Omni, Chat, Coherence, Corpus) with monthly caps and automatic pause when limits are reached. When running on agent inference backends, a separate window-based usage budget pauses ingestion as an agent's rolling quota nears its limit and auto-resumes when the window resets
• Chat sidebar: Ask Laya questions about your events, projects, context, and Corpus documents — and create, edit, or delete filter/classification/processing rules directly from the conversation
• Hybrid search: Chat and Coherence retrieval combine local vector search (ChromaDB) with lexical BM25 ranking over SQLite FTS5 (cards_fts/events_fts/documents_fts), merged via Reciprocal Rank Fusion, so both semantic and exact-keyword matches surface
• Coherence: Cross-platform entity search traces any person, ticket, or PR across all platforms using hybrid local search, with AI-generated narratives
• Corpus: Drop a PDF, DOCX, Markdown, text, CSV, JSON, or HTML file anywhere in the app and Laya parses, chunks, embeds, and indexes it locally. Chat answers from your documents with page-level citations, cards show the documents that mention their ticket or PR, Coherence traces include linked documents, and the same read tools are exposed over MCP. Files are read in place — never copied — and an AI summary is written at ingest
• Egress: Execute outbound actions (emails, Slack messages, PR comments) directly from Laya with preview-before-send
• Omni: Rolling cross-platform summary that answers "where am I right now?" with four temporal layers (Attention, Recent, Period, Milestone) and progressive AI compression
• Bookmarks: Pin important cards for quick access regardless of date or status
• Classification learning: Laya extracts rules from your priority/persona corrections and improves classification automatically over time
• Context learning: Laya extracts natural-language context rules from your link/unlink corrections and improves context association over time. Learned and manual rules are viewable and editable in Settings, and large rule sets are LLM-consolidated automatically
• Processing rules: Automated, optionally AI-evaluated rules that act on incoming cards (tag, route, run an agent, send egress). Every firing is recorded in a searchable firing log with its outcome (success / error / skipped) and reason
• Audit & export: Inspect dead events, ingestion errors, and rule-filtered events in one place; retry or clear failures, and export filtered events or the audit log as JSON over any time window
• On-prem repositories: Self-hosted Bitbucket Server / Data Center and GitHub Enterprise are supported via a per-repo host field (empty or the cloud domain ⇒ cloud)
• Dead event recovery: Failed events are tracked with error context and can be manually retried from the audit log
• Privacy-aware: Three-tier data classification with cloud/local processing options

Tech Stack

Project Structure

laya/
├── engine/                  # Python FastAPI backend
│   ├── laya/
│   │   ├── main.py          # Entry point (uvicorn server on :8420)
│   │   ├── config.py        # Settings, paths, agent detection
│   │   ├── api/             # REST + WebSocket endpoints (28 routers)
│   │   ├── db/              # SQLite (+ FTS5) + ChromaDB + 74 migrations
│   │   ├── pipeline/        # Event processing (ingest → route → stage → emit → trace → learn → context_learn → omni)
│   │   ├── documents/       # Corpus: parsers, chunking, ingest, entity linking, summary, search
│   │   ├── llm/             # LiteLLM client, agent inference backends, prompts, tools
│   │   ├── agents/          # Coding agent adapters (Claude, Gemini, Codex, Pi, Cursor)
│   │   ├── workers/         # Multi-persona LLM workers (engineer, comms, ops, sales, hr, finance)
│   │   ├── egress/          # Outbound action execution (9 platforms)
│   │   ├── integrations/    # n8n bootstrap & client
│   │   └── security/        # OS keychain integration
│   ├── requirements.txt     # Core Python dependencies (version ranges)
│   ├── requirements-ml.txt  # Optional: torch + sentence-transformers
│   └── requirements*.lock   # Exact pinned versions that get installed
│
├── ui/                      # SvelteKit + Tauri desktop app
│   ├── src/                 # Svelte 5 frontend (runes syntax)
│   │   ├── routes/          # Pages (feed, omni, coherence, corpus, dashboard, settings, workspace)
│   │   ├── lib/             # Components, API client, stores
│   │   ├── app.css          # Tailwind v4 + theme system
│   │   └── app.html
│   ├── src-tauri/           # Rust/Tauri shell
│   │   ├── src/
│   │   │   ├── lib.rs       # Tauri setup, commands, health polling, tray
│   │   │   ├── sidecar.rs   # Python venv lifecycle & engine spawning
│   │   │   └── n8n.rs       # n8n process management
│   │   ├── tauri.conf.json  # Tauri config (resources, icons, window)
│   │   └── resources/       # Bundled engine source (production builds)
│   ├── package.json
│   └── svelte.config.js     # Static adapter (SPA mode)
│
├── n8n/
│   └── workflows/           # Integration workflows (JSON, ~21 files: ingestion + executor per platform)
│
├── scripts/
│   ├── setup-dev.sh         # One-time dev environment setup
│   ├── dev.sh               # Start engine + Tauri dev server
│   ├── build.sh             # Production build
│   └── update_icons.sh      # Icon generation
│
├── landing/                 # Landing page
└── docs/                    # Architecture & design documents

Install

The fastest way to try Laya is a prebuilt release — no toolchains required.

1. Open the Releases page and download the installer for your platform:

2. Install and launch. You do not need Python, Node, or Rust installed to run a release build. On first run, Laya checks for a compatible Python (3.10–3.14; on Windows, an x64 build) and Node.js (20+) already on your machine and uses those if found; otherwise it provisions its own bundled runtimes. Either way, a local n8n instance is set up under ~/.laya/.
3. Add an API key (Anthropic, OpenAI, Google, …) or point Laya at a local Ollama / LM Studio endpoint, then connect your tools from Settings.

macOS: release builds are signed, so they open normally — just double-click to launch.

Want to build from source, hack on the engine, or contribute? Follow the Development setup below and read the contributing guide before opening an issue or PR.

Development

Prerequisites

You need three runtimes installed. Here's how to get each one:

Python 3.10+

• macOS: brew install python@3.12 (or download from python.org)
• Ubuntu/Debian: sudo apt install python3 python3-venv python3-pip
• Windows: Download from python.org (check "Add to PATH" during install)

Verify: python3 --version

Node.js 20+

• All platforms: Download from nodejs.org (LTS recommended), or use a version manager like nvm / fnm
• macOS: brew install node
• Ubuntu/Debian: curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - && sudo apt install -y nodejs

Verify: node --version && npm --version

Rust toolchain

Install via rustup:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Verify: cargo --version

Platform-specific dependencies

macOS:

xcode-select --install

Linux (Ubuntu/Debian):

Tauri v2 requires system libraries for GTK, WebKit, and app-indicator support:

sudo apt install -y libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev patchelf

Setup

scripts/setup-dev.sh

This script does the following:

1. Checks that python3, node, npm, and cargo are available
2. Creates a Python virtual environment at engine/.venv/ and installs dependencies from engine/requirements.txt
3. Installs npm packages for the UI (ui/node_modules/)
4. Installs n8n as a local npm package into ~/.laya/n8n_module/
5. Creates data directories at ~/.laya/data/ and ~/.laya/logs/

Running Locally

scripts/dev.sh

This starts two processes:

1. Python engine -- python -m laya.main (with hot reload) at http://127.0.0.1:8420
2. Tauri dev server -- npx @tauri-apps/cli dev which starts Vite at http://localhost:5173 and opens the Tauri window

n8n is managed automatically by the Tauri app -- it starts on launch (port 45678) and stops on quit.

Note: If the engine fails with "Address already in use", a stale engine process may be holding port 8420. The engine will attempt to kill it automatically on startup.

Troubleshooting

# Immediate (resets on reboot)
echo 524288 | sudo tee /proc/sys/fs/inotify/max_user_watches

# Permanent
echo 'fs.inotify.max_user_watches=524288' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Could not create default EGL display: EGL_BAD_PARAMETER. Aborting...

./Laya_*_amd64.AppImage --appimage-extract
mv squashfs-root ~/.local/share/laya-app        # or anywhere permanent
rm ~/.local/share/laya-app/usr/lib/libwayland-*.so.*
~/.local/share/laya-app/AppRun

npm error code EALLOWREMOTE
npm error Fetching packages of type "remote" have been disabled
npm error Refusing to fetch "xlsx@https://cdn.sheetjs.com/xlsx-0.20.2/xlsx-0.20.2.tgz"

mkdir -p ~/.laya/n8n_module
printf 'allow-remote=all\n' > ~/.laya/n8n_module/.npmrc
npm install --prefix ~/.laya/n8n_module n8n@2.15.0

hint: Wheels are required for `aiohttp` because building from source is disabled for all packages (i.e., with `--no-build`)

$laya = "$env:USERPROFILE\.laya"
Remove-Item -Recurse -Force "$laya\venv", "$laya\.deps_hash", "$laya\python" -ErrorAction SilentlyContinue
New-Item -ItemType Directory -Force $laya | Out-Null
$tag = "20260510"; $ver = "3.12.13"
$url = "https://github.com/astral-sh/python-build-standalone/releases/download/$tag/cpython-$ver+$tag-x86_64-pc-windows-msvc-install_only.tar.gz"
Invoke-WebRequest $url -OutFile "$env:TEMP\laya-python.tar.gz"
tar -xzf "$env:TEMP\laya-python.tar.gz" -C $laya       # creates .laya\python
Set-Content "$laya\python\.version" $ver -NoNewline
Remove-Item "$env:TEMP\laya-python.tar.gz"

cd ui/src-tauri && cargo tree -i openssl-sys

Engine API authentication

The engine's REST API requires an Authorization: Bearer <token> header on every route except GET /health. The Laya app handles this by itself: on each launch it generates a new token, shares it with the engine, and uses it for all of its own requests. There is nothing to configure for normal use, and the token is kept in memory only.

Running the UI in a plain browser. When you open http://localhost:5173 in a browser there is no Tauri window to supply the token, so give the engine and the UI the same value yourself:

# ui/.env.local (gitignored)
VITE_LAYA_ENGINE_TOKEN=<token>

# Standalone engine + Vite dev server
cd engine && source .venv/bin/activate && LAYA_ENGINE_TOKEN=<token> python -m laya.main
cd ui && npm run dev

# Or: the Tauri window and a browser tab side by side (dev builds only)
LAYA_ENGINE_TOKEN=<token> scripts/dev.sh

Vite reads .env.local when it starts, so restart npm run dev after changing the token. Release builds ignore a preset LAYA_ENGINE_TOKEN and always generate their own. If the UI cannot find a token, the startup screen says so.

Calling the API by hand. Start the engine with a known LAYA_ENGINE_TOKEN as above and send it as a bearer header:

curl -H "Authorization: Bearer $LAYA_ENGINE_TOKEN" http://127.0.0.1:8420/settings

A standalone engine started without LAYA_ENGINE_TOKEN creates a token and stores it in the OS keychain (service laya-engine, account laya_engine_api_token).

The n8n token. The bundled n8n workflows use a second, separate token, LAYA_N8N_TOKEN, sent as the X-Laya-N8n-Token header. It is accepted only on the four routes the workflows call (POST /events, POST /ingestion-errors, GET /repos, GET /metadata/{key}), which also accept the app token; it opens nothing else. The app generates it per launch and sets the same variable on the engine and on n8n. When you run the engine or n8n by hand, set LAYA_N8N_TOKEN to the same value on both (n8n reads it with $env.LAYA_N8N_TOKEN; the engine stores a keychain token under laya_n8n_token if the variable is absent, but n8n will not know that value).

Enforcement is staged so an upgrade cannot drop events: the engine runs in log mode (requests without the token are logged and accepted) until the startup workflow sync has pushed the header-sending template to every cloned workflow and the error handler, then switches to enforce and stays there. Settings → Integrations → n8n shows the mode, what is still blocking enforcement, and how many requests arrived without a valid token.

The OAuth redirect callback accepts requests without a token. The WebSocket at /ws is not authenticated yet.

Configuration

On first launch, the engine creates config files in ~/.laya/:

API keys (Anthropic, OpenAI, Google, etc.) are stored securely in your OS keychain and can be configured through the Settings UI.

The engine logs at INFO by default. Change verbosity from Settings → Data → Engine Log Level (DEBUG / INFO / WARNING / ERROR) — this maps to the logging.level key in settings.json and applies immediately, no restart. Set it to WARNING to record only warnings and errors and keep logs small. For a single run you can override it with the LAYA_LOG_LEVEL environment variable, which takes precedence over the setting (and also sets uvicorn's request-log level).

Custom Prompts

Laya's AI pipeline uses system prompts at every stage (routing, staging, summarization, chat, etc.). All prompts ship with sensible defaults, but you can override any of them by placing files in ~/.laya/prompts/:

mkdir -p ~/.laya/prompts

# Override the router prompt (controls event classification)
vim ~/.laya/prompts/router.md

# Override a worker persona
vim ~/.laya/prompts/engineer.md

Apply changes without restarting from Settings → Models → Custom Prompts → Reload prompts, which also lists the prompt files currently in use. From a terminal, the same reload needs the engine token (see "Engine API authentication"):

curl -X POST -H "Authorization: Bearer $LAYA_ENGINE_TOKEN" http://127.0.0.1:8420/prompts/reload

Available prompt files: router.md, stager.md, omni.md, group_summary_initial.md, group_summary_rolling.md, briefing.md, summarizer.md, summarizer_status_change.md, engineer.md, comms.md, sales.md, hr.md, ops.md, finance.md, chat.md, chat_title.md, chat_polish.md, chat_documents.md, document_summary_map.md, document_summary_reduce.md, learner.md, context_learner.md, trace_narrative.md, trace_summary.md, trace_filter.md.

Custom prompts fully replace the built-in default for that stage. If a file is deleted, the hardcoded default is used automatically. The engine never creates or modifies files in this directory. Use GET /prompts (with the same bearer header) to check which prompts are currently overridden.

Data Storage

Building for Distribution

Laya bundles the Python engine source into the Tauri app. On first launch, the app creates a Python virtual environment at ~/.laya/venv/ and installs dependencies automatically -- no Python installation is required on the end user's machine beyond what the app manages.

Build Command

scripts/build.sh

This does two things:

1. Bundles engine source -- copies engine/laya/, the requirements files and their lock files, and n8n/workflows/ into ui/src-tauri/resources/engine/
2. Builds the Tauri app -- compiles the Rust shell, bundles the SvelteKit frontend, and packages everything into a platform-native installer

Build Options

scripts/build.sh                                   # Build for current platform
scripts/build.sh --target x86_64-apple-darwin      # Cross-compile for Intel Mac
scripts/build.sh --universal                       # Universal binary (arm64 + x86_64)
scripts/build.sh --sign "Developer ID App: ..."    # macOS code signing
scripts/build.sh --skip-engine                     # Skip engine bundling (reuse previous)

Build Output

Note: macOS builds are unsigned by default. Unsigned apps trigger Gatekeeper -- users must right-click > Open to bypass. Pass --sign with an Apple Developer identity to produce a signed build.

Documentation

Architecture and design documents in docs/:

• System Architecture -- Component diagrams and service descriptions
• Event Schema -- The Laya Event schema specification
• API Contracts -- REST, WebSocket, and inter-service API definitions
• Database Schema -- SQLite tables (incl. FTS5), ChromaDB collection, and migrations
• Project Structure -- Repository layout and config file schemas
• Tuning Parameters -- Overridable pipeline, retrieval, and agent-budget settings
• n8n Data Persistence -- How n8n workflow data and credentials are stored
• Decision Log -- Architectural decisions with rationale

Deeper design docs (egress, AI processing rules, OAuth app distribution, pipeline lifecycle) live in engine/docs/.