v0.1.0  ·  Open Source  ·  Evidence-Backed Runtime

Self-hosted AI,
with real operational control.

Sven is a full AI runtime for operators, teams, and advanced home deployments: multi-agent execution, memory and retrieval, voice, messaging, mobile and desktop surfaces, and a release process tied to evidence instead of claims.

⚡ Get Sven Free Explore Full Suite →
Open community Browse docs
curl -fsSL https://sven.systems/install.sh | sh
iwr -useb https://sven.systems/install.ps1 | iex
SVEN_REPO_URL=https://<your-source-mirror>/thesven.git \ SVEN_INSTALL_BOOTSTRAP=1 \ curl -fsSL https://sven.systems/install.sh | sh

Works on any Linux host · Docker · macOS · Windows WSL

20
Messaging Reach
Public proof
Capability Coverage
Strict gates
Verified Delivery
100%
Self-Hosted Runtime
What Sven Is

A serious AI stack,
run from one controlled platform.

Sven brings runtime, knowledge, channels, governance, and operational proof into one self-hosted system with clear boundaries and live evidence.

Runtime and orchestration

Production service mesh for multi-agent execution, workflow routing, retries, approvals, and policy checks.

  • Agent runtime + workflow builder + scheduler
  • Human-in-the-loop approvals and incident controls
  • Tool dispatch with policy-gated execution

Knowledge and memory

Persistent memory and retrieval pipeline across documents, repos, notes, and internal knowledge stores.

  • Hybrid retrieval (BM25 + vectors)
  • Per-user private memory boundaries
  • Knowledge graph extraction and evidence trails

Channel and client coverage

Meet users where they are while operators keep full visibility in dedicated control surfaces.

  • 20 messaging adapters and local voice pipeline
  • Web admin and canvas collaboration UI
  • Flutter mobile app and desktop companion

Security and governance

Security-first defaults with explicit governance workflows and hardened release gates.

  • OIDC/SSO, RBAC, audit-ready controls
  • Sandboxed skill execution and secret isolation
  • Release evidence lanes and strict CI gates

Community and ecosystem

Verified-persona community operations for high-signal collaboration between humans and agents.

  • Public community hub with gated participation
  • Public proof feed and capability proof
  • Reputation and moderation-aware operations

Capability proof and release evidence

Public product claims are tied to generated artifacts, runtime checks, and release controls.

  • 287/287 proven capability rows in the current proof set
  • Public evidence endpoints for capability, community, and readiness
  • CI and release gates that block unsupported completion claims
Trust Surface

Public proof that feels like product trust, not a raw status dump.

Sven exposes generated proof, verification posture, and readiness signals so teams can inspect what supports the product story without hunting through internal process language.

Deployment label
Loading...
Declared origins
Loading... install
Loading... runtime
Loading... proof
Capability proof
Generated artifacts back the current public capability story.
Verification posture
Release, program, and runtime checks stay visible as part of the shipping surface.
Evidence source
/v1/public/community/capability-proof and related public proof endpoints.
Proof module
Capability, release posture, community, readiness
Capability proof
Loading capability proof...
Verification lanes
Loading verification status...
Community feed
Loading proof feed...
Readiness
Loading readiness...
Client Surfaces

Every Sven surface in one map.

Use whichever interface fits the user: operations teams, daily users, mobile users, or verified community members.

Admin Control Center
Operations, incidents, approvals, workflows, policy controls, observability, and release-readiness views.
Open admin surface →
Canvas Collaboration
Daily conversation and agent collaboration space with runtime-aware context and approval-safe actions.
Open canvas surface →
Mobile Companion
Flutter app with identity-aware sessions, privacy controls, and production release tracks.
Open mobile surface summary →
Desktop Companion
Desktop runtime with secure local storage, gateway connectivity, and enterprise desktop controls.
Open desktop surface summary →
Community Platform
Verified-persona ecosystem with trust model, public proof feed, and moderated collaboration.
Open community hub →
Product Preview

What the current mobile build actually looks like.

These screens were captured from the current Android build in this repo, installed to a connected device and pointed at the live Sven host.

Real product surfaces make the platform story easier to trust.

Sven already had a lot of depth in runtime and proof infrastructure. This section makes the public site show more of the shipped experience directly, instead of asking visitors to infer it from architecture copy alone.

Current build
Captured from the latest local Android build, not a mockup or stale marketing render.
Real host wiring
The mobile app now defaults to app.sven.systems and uses the current Sven privacy and terms routes.
Useful coverage
Onboarding, feature framing, and live sign-in give visitors a better feel for the shipped product path.
Mobile companion Onboarding
Sven mobile onboarding screen
Meet Sven
A cleaner first-run screen with the current identity, visual tone, and product framing.
Mobile companion Capabilities
Sven mobile capabilities screen
What Sven can do
A product-level summary of conversations, code, media, and privacy in the mobile flow.
Mobile companion Auth
Sven mobile sign-in screen
Live sign-in surface
The current app ships a real auth flow with first-party sign-in plus Google, Apple, and GitHub continuation paths.
Architecture

Layered by design for scale, trust, and control.

Sven is built as a composable production stack so capabilities remain auditable, testable, and replaceable.

Ingress and gateway layer

Unified API and routing surface for users, apps, and adapters.

  • REST + WebSocket gateway
  • OIDC/JWT auth boundaries
  • Public and private endpoint partitioning

Runtime and workflow layer

Deterministic orchestration for tools, agents, and approvals.

  • Agent runtime and policy checks
  • Workflow builder and execution DAGs
  • Retries, self-correction, and HITL stops

Knowledge and memory layer

Context persistence with per-user and shared scopes.

  • Hybrid retrieval with ranking
  • Repo/notes/NAS ingestion
  • Evidence and traceability outputs

Interaction layer

Multi-channel experience endpoints.

  • 20 adapters + local voice stack
  • Admin, canvas, mobile, desktop, community
  • Per-user memory and identity continuity

Trust and security layer

Enterprise-grade controls for safe production operation.

  • RBAC, SSO/OIDC, auditability
  • Sandboxed skill execution
  • Release evidence gates and lifecycle checks
Docs Center

Documentation paths for every user type.

Operators, developers, security reviewers, and product users each get focused entry points.

Platform overview

Current features, setup patterns, and platform map.

Open docs center →

Release and readiness

Strict release status, evidence lanes, and lifecycle blockers.

Open release roadmap →

Capability proof

Capability proof matrices, supporting artifacts, and release evidence references.

Open capability overview →

Community governance

Verified persona model, moderation policy, trust and submission model.

Open community hub →

Developer implementation

Services, APIs, contracts, and implementation references.

Open service architecture →

Security and compliance

Security baseline, hardening, and supply-chain controls.

Open security guide →
Product Depth

Built for real deployments,
not just prompt demos.

Sven is designed to be operated over time: integrated with the channels people already use, governed with clear controls, and flexible about models, memory, and interaction surfaces.

💬

20 Messaging Adapters

WhatsApp, Telegram, iMessage, Discord, Signal, Slack, Teams, Matrix, LINE, Zalo and more. Sven reaches people in the tools they already use instead of forcing a single client surface.

ADAPTERS
🧠

Built-in RAG Memory

Index Git repos, NAS file shares, Obsidian vaults, Apple Notes, Bear, and Notion. BM25 + vector search with temporal decay — agents never forget relevant context.

KNOWLEDGE
🎙️

100% Local Voice Stack

Faster-Whisper STT, Piper TTS, and always-on wake word detection run on your server so voice interaction can stay private and local.

VOICE
🔒

Private & Secure by Design

Conversations, memories, and automation stay under your control. Sandboxed skill execution, automatic key rotation, and role-based access keep the platform governable as it grows.

PRIVACY
⚙️

Any LLM, Any Provider

Built-in LiteLLM proxy routes to OpenAI, Anthropic, Google, Mistral, Ollama, LM Studio, or any OpenAI-compatible endpoint. Swap models without touching agent logic.

MODELS
🤝

Agents That Remember Everyone

Each person gets their own private memory boundaries. Sven can preserve preferences, context, and routines without collapsing everyone into one shared state.

MEMORY
Deployment Modes

One platform,
several operating contexts.

Sven can start as a private deployment and grow into a team or community runtime without changing the core architecture.

👪

Private household deployment

Run Sven at home with messaging adapters, local voice, and per-person private memory while keeping data and automation inside your own infrastructure.

Best when you want one trusted runtime for a household without pushing everyone into a new app.
🏠

Voice-enabled environment

Use wake-word and voice services for shared spaces, local audio handling, and identity-aware interactions across the home or office.

Best when Sven needs to feel ambient and accessible instead of living only behind keyboards and dashboards.
👥

Shared group runtime

Connect community or group channels while preserving private memory boundaries, moderation posture, and operational visibility.

Best when one runtime needs to serve many people without collapsing identity, state, or trust boundaries.
💼

Team and operator deployment

Move into Slack, Teams, admin governance, shared knowledge, approval flows, and role-based controls without replacing the platform underneath.

Best when you need a runtime that can support operators, end users, and policy owners at the same time.
Integrations

Reach users in the tools they already use.

Sven connects into messaging and communication channels so deployment does not require a full behavior change from the people using it.

🟩Slack
🔷Teams
✈️Telegram
🎮Discord
📱WhatsApp
🔔Signal
▦Matrix
💬Google Chat
🍎iMessage
⚡Mattermost
#︎IRC
🌐Nostr
🎮Twitch
💬LINE
🇧🇳Zalo
🫶Feishu
☁️Nextcloud
🪐Tlon/Urbit
🌎WebChat
📞Voice Call
How It Works

Deploy once. Integrate everything.

1

Run the stack

One trusted source bootstrap brings up the gateway, agent runtime, RAG indexers, voice stack, and adapter services from the deployment path you control.

2

Connect channels and identity

Attach the channels your users already live in, provision identities, and apply the access boundaries that fit your environment.

3

Shape behavior and controls

Define personas, tools, policies, and knowledge. Extend Sven through sandboxed skills and keep the result observable and reviewable.

Operating Model

Built for serious deployment.

Sven is designed as a product you can actually operate: clear surfaces, controlled runtime boundaries, public proof endpoints, and self-hosted deployment paths that stay under your ownership.

Property What ships How it is governed Why it matters
Public and operator surfaces Canvas, community, admin, mobile, desktop Route ownership and auth boundaries Users and operators get clear, purpose-built entry points
Knowledge and memory Persistent memory with retrieval and evidence trails Scoped access, provenance, and release checks Context stays useful without becoming opaque or unsafe
Voice and channel reach Local voice stack plus broad messaging coverage Adapter configuration and runtime health checks People can use Sven in the channels they already trust
Self-hosted deployment Installers, source-bootstrap paths, and production docs Release runbooks and environment-specific guidance You can run the platform on infra you control
Access and governance RBAC, SSO/OIDC, admin controls, reviewable actions Policy checks, audit trails, and gated release lanes Operational trust scales with the surface area
Proof and status Capability, community, and readiness endpoints Generated artifacts and CI-backed evidence Public claims can be checked against current status
Extensibility Skills, workflows, adapters, and multi-surface clients Contracts, docs, and operational controls The platform can expand without turning into a black box
Release readiness Status refresh, soak, drills, and signoff lanes Lifecycle validation and evidence retention Shipping quality is treated as part of the product
Operational Proof

Public evidence, tied to the running system.

These indicators are loaded from Sven public proof and status endpoints so the product surface can show current operational posture.

Trust Surface

Proof is part of the product surface, not a hidden checklist.

Sven exposes capability proof, community posture, and readiness from public endpoints so teams can inspect what is shipping and where the evidence comes from.

Capability
Loading...
Community
Loading...
Proof Feed
Loading...
Deployment Profile
Loading...
The quickstart surface can declare which environment it targets instead of relying only on hostname guesses.
Install Origin
Loading...
Install commands are generated from this origin so copy-and-run flows stay consistent across environments.
Runtime Origin
Loading...
Public runtime links use this base when the site needs an explicit deployment contract.
Proof Origin
Loading...
Evidence can be sourced from a declared proof host so static previews and staged deployments stay predictable.
Capability coverage
Loading...
/v1/public/community/capability-proof
Community posture
Loading...
/v1/public/community/status
Proof feed
Loading...
/v1/public/community/feed
Get Started

Start with the path that matches your host.

Use the public installer for a fast bootstrap, or use the source-bootstrap path when you want a full runtime from infrastructure and source locations you control.

Install Sven

Pick the entrypoint for your environment, copy the command, and bring the runtime online. The public product links and the self-hosted surfaces stay aligned.

curl -fsSL https://sven.systems/install.sh | sh
iwr -useb https://sven.systems/install.ps1 | iex
SVEN_REPO_URL=https://<your-source-mirror>/thesven.git \ SVEN_INSTALL_BOOTSTRAP=1 \ curl -fsSL https://sven.systems/install.sh | sh

Works on Linux, Docker hosts, macOS, and Windows via WSL.

What the full stack brings online

The source-bootstrap path installs Sven from a repo mirror you control, then brings up the runtime and post-install checks from the same trusted source base.

# What the full Sven runtime brings online
gateway-api  # REST + WebSocket hub · JWT/OIDC auth · :3000
agent-runtime  # LLM orchestration · tool dispatch · self-correction
skill-runner  # gVisor sandboxed skill execution
rag-indexer  # OpenSearch + BM25 + kNN vector embeddings
litellm  # Unified LLM proxy · any provider · :4001
adapter-slack  # … + 19 more messaging adapters
faster-whisper  # Local STT · no audio leaves your server
piper  # Local TTS · no text leaves your server
sso  # Keycloak OIDC · :8080 (optional)
admin-ui  # Web dashboard · localhost:3000/admin47

Recommended onboarding

Use the fast path if you want to evaluate the experience quickly, then move to the full stack when you want a durable, governed deployment.

01

Bootstrap the runtime

Run the installer or source-bootstrap path on a host you control. Sven keeps the public entrypoints and runtime surfaces consistent.

02

Open the core surfaces

Verify admin, canvas, and community from the same base origin so operators and end users land on the right surface immediately.

03

Layer on governance

After first boot, move into release gates, evidence, identity, and operational controls instead of treating them as an afterthought.

Fast evaluation Install entrypoints and runtime links for a quick first pass.
Full deployment Source-bootstrap path for gateway, runtime, voice, knowledge, and admin surfaces.
Production follow-through Use the release and proof surfaces to keep trust visible after install.
After deploy
Open the runtime surfaces from the same host.
/login?redirect=%2Fadmin47Operator sign-in entry for the governed admin surface. /Canvas and chat surfaces for the day-to-day product experience. /communityVerified ecosystem hub with public status and proof-linked community surfaces. /docsRunbooks, deployment guidance, and the documentation routes behind the product. /marketplaceSkills, extensions, and the expansion path beyond the core runtime.