MOS — Capabilities & Architecture

Underneath every feature, MOS runs the same loop. It is deterministic code that calls an LLM for reasoning — never an LLM that is trusted to run the loop itself.

The model doing the reasoning is a swappable component. Operational state — goals, plans, actions, results, memory, permissions — lives in MOS, not in the model's context window, and survives switching providers or upgrading models entirely.

The user talks to MOS — one conversational interface. Behind it, an Attention layer decides what deserves surfacing now versus what stays quiet, and routes work into goals, memory retrieval and internal agent roles.

MOS separates two different things that are easy to conflate:

AI Engines: Anthropic · OpenAI · Gemini · xAI (Grok) · Mistral · Groq · DeepSeek · OpenRouter · Any OpenAI-compatible endpoint (incl. self-hosted Ollama)

MOS does not depend on one proprietary AI vendor. Connect Anthropic, OpenAI, Gemini, xAI, Mistral, Groq, DeepSeek or OpenRouter with your own key — including OpenRouter via a real OAuth (PKCE) flow, no key-pasting required — or point a custom OpenAI-compatible endpoint at a self-hosted model (Ollama and similar work today). Every stored credential is encrypted at rest; provider usage belongs to you and is billed by that provider, not by Moseisley.

Moseisley is BYOK-only — it never pays LLM inference costs for you, on any plan. Every account connects its own OpenRouter key at signup; the MOS subscription covers the MOS platform, not bundled AI usage — see Pricing. Moseisley hosting its own local LLM/GPU compute for you is planned, not available yet.

The pipeline, precisely:

The original file is always kept — indexing failure never loses it. Retrieval is hybrid: PostgreSQL native lexical full-text search (indexed, not a LIKE scan) always runs, joined by semantic search — cosine similarity over embeddings from your own connected provider (BYOK) — whenever you've embedded content. Both are scoped to your tenant, and every result says plainly which one found it, never claiming semantic understanding it didn't use. There is no separate vector database: embeddings are ranked in plain PostgreSQL, so self-hosting never needs one either. Documents are deduplicated by checksum within your own account only. Cold-storage archival (e.g. Glacier) is a planned tier, not a live integration — nothing is silently moved anywhere colder today.

You interact with MOS, not with a roster of agents you have to coordinate yourself. MOS delegates bounded, tracked jobs internally:

Internal roles available for delegation today:

• ·Strategist — Strategy and prioritization
• ·Challenger — Attempts to prove the current strategy wrong
• ·X-Ray — Analyzes historical and current reality for missed money/time
• ·Radar — External market intelligence, swept on a schedule
• ·Auditor — Verifies predictions against outcomes; keeps calibration honest

Every delegation is bounded (a fixed cap per turn), assignment is explicit (a crew role or the user — never an invented agent), and execution state is one of a small closed set: pending, in progress, blocked, completed, cancelled. A goal can be paused and resumed; a blocked action carries an explicit, honest reason; a stale or crashed run is detected and surfaced for review rather than silently retried. Internal delegation detail (which role ran what, in what order) is visible in Activity/X-Ray for anyone who wants it — MOS doesn't hide it, it just doesn't lead with it.

Give agents permission and budgets, not unrestricted authority. Concretely:

• ·Five kill switches — including one master Emergency Stop — checked at execution boundaries, not by asking the model politely.
• ·Tool Broker — the single, deterministic gate between an agent and any real integration; agents never hold raw credentials.
• ·Policy Engine — evaluates every tool call against your configured permissions before it runs.
• ·Spend policy & approvals — free-only, paid-allowed, or ask-before-spending; a real approval request blocks the action until you decide.
• ·Sandbox execution layer — used for untrusted code paths (e.g. the Dev Agent's own patches); denies execution by default rather than silently downgrading isolation.
• ·Tenant isolation — PostgreSQL Row-Level Security on tenant-owned data, enforced at the database layer, not only in application code.
• ·Encrypted credentials (AES-256-GCM) and an append-only audit Ledger for every meaningful state change.

Deliberately not detailed here: exact sandbox runtimes, infrastructure topology, or anything that would help someone probe for a weakness rather than understand the architecture.

BYOK usage is never billed by Moseisley — your provider bills you directly for your own key's usage, and MOS's spend policy only controls when that spend is allowed to happen (never silently, never past your chosen limit). Hosted MOS is one flat monthly subscription for the MOS platform ($19/month after a 7-day free trial, still BYOK); the open-source code can also be self-hosted — see Pricing for current numbers.

Planned, not yet built: a dedicated phone app, glasses, wearables, and smart-home device adapters. Full-duplex realtime voice conversation is also planned — today is transcribe-then-send, not an always-listening line.

MOS includes a real MCP client: connect any Model Context Protocol server as a data/tool source, over the standard streamable-HTTP JSON-RPC transport, with the same policy and kill-switch enforcement as every other integration. What it returns is treated as untrusted content, like any external result.

• ·Open where possible — self-hostable, fair-code licensed
• ·Provider-independent — no proprietary model dependency
• ·Bring your own key — your usage, your cost, your data
• ·Standards-based — MCP over a bespoke protocol, where a standard exists
• ·Providers are replaceable — swap the model without losing state
• ·Persistent state outlives the model — goals, memory and permissions live in MOS

1. 1Create an account. Hosted at moseisley.sh, or self-host from the GitHub repo.
2. 2Connect an AI Engine. OpenRouter (OAuth or key), or any provider you already have a key for — including a local Ollama endpoint.
3. 3Optionally connect Intelligence Sources. Tavily/Brave for web, Gemini for YouTube, Grok for X, Groq for audio, Mistral for documents — each is opt-in and BYOK.
4. 4Create a Goal. Describe it in plain language. MOS compiles it into a metric, target and deadline.
5. 5Let MOS plan and act. It generates milestones and actions, assigns what it can to the crew, and asks before anything that costs money.
6. 6Add personal memory. Attach a document in chat and say "remember this" — MOS indexes it into your Personal Vault for later retrieval.

Prefer to self-host? The README has a five-minute Docker quickstart and an operations guide covering AI modes and deployment in detail.

• GitHub repository
• Create an account · Log in
• Pricing
• Community
• Legal & privacy