Build your agent once.
It's alive everywhere you already are.
Slack, your website, your app, texting you every morning — the same agent, on your machine, on any model. You own all of it.
Everything to build, run, and reach your agent.
Profile. Engine. Gateway. Reach. Vault. Each does one thing well — and you own all of them.
Your agent is a folder of text.
No SDK to learn, no wizard. agent.json says what it can do; SOUL.md says who it is. Commit it to git, review it in a PR, fork it like code.
{
"name": "assistant",
"model": "anthropic:claude-sonnet-5",
"tools": {
"preset": "full", // all 37 built-in tools
"composio": { "toolkits": ["gmail", "slack"] }, // 400+ SaaS
"mcp": { "linear": { "command": "npx linear-mcp" } }
},
"security": { "mode": "ask" } // pause on risky calls
}That's the whole agent. SOUL.md beside it is a plain-English system prompt — its personality and policies. preset picks from 37 built-in tools; composio and mcp connect 400+ SaaS apps and any MCP server — no engine code, no redeploy.
A real runtime — not a wrapper.
The same class of engine as Claude Code: streaming, parallel tool calls, sub-agents, retries, and compaction that keeps long tasks alive — for any model, all yours to self-host.
One process is the whole backend.
One command boots threads, streaming, the encrypted vault, schedules, and channels — the entire backend, on your machine. Keyless on the very first run.
$ ownware serve
✓ gateway on :3011
✓ 1 profile · keyless (ollama)
✓ vault · schedules · channels readyPOST /run starts a run and returns a threadId; GET …/events streams it back over SSE. That split is what makes it a reload-safe, multi-client service — not a loop you babysit.
One contract. Every surface.
HTTP in, server-sent events out. The CLI, the SDK, Slack, your website, a nightly schedule — every surface speaks the same wire. Adding one is a few steps, not a rewrite.
import { OwnwareClient } from '@ownware/client'
const agent = new OwnwareClient({ baseUrl })
await agent.run({ profileId, prompt })Your keys never leave your box.
Secrets live in an encrypted vault (AES-256-GCM). The engine works through an opaque handle, and the vault is built to keep the plaintext out of your logs, events, and database.
Your agent lands with 37 tools already wired.
Files, a guarded shell, real Playwright browser control, web search, image & speech, sub-agents, and cross-session memory — built into the engine. Add any MCP server or 400+ SaaS apps via Composio without touching engine code.
The same brain, everywhere you need it.
Every surface is just another client of the same contract. From raw HTTP to a schedule that texts you first.
Raw wire, any language
POST /run plus an SSE stream. Specified in OpenAPI + AsyncAPI.
Five lines in your app
@ownware/client — zero deps, Node and browser.
Slack, Telegram & more
The same agent answers in your channels — in-process, no second deploy.
It reaches back to you
Schedule a run daily; it delivers the result to your channel, unprompted.
Answer where your customers already are.
Five messaging channels, one brain. Flip one on with a token and the same agent replies there — no second deploy.
Slack
Socket Mode — replies and edits in-thread.
In-processTelegram
Long-poll — supports typing & live edits.
In-processDiscord
REST — typing & edits, per-channel threads.
In-processCloud API — mount its webhook route.
WebhookSMS
Twilio — signed webhook, mount the route.
WebhookThe honest answers.
Yes — the whole kit is Apache-2.0: the engine, the gateway, the 37 built-in tools, the channels, and every security primitive. Free for any use, including commercial. Ownware isn't a product you pay for; it's the runtime other people build their products on.
Never. It's self-hosted — your provider keys live in an encrypted vault (AES-256-GCM) on your machine, and all data stays in ~/.ownware/ on your box. Leave localhost and auth + TLS are forced on, or the server refuses to boot. That's a load-bearing promise, not a pricing tier.
A lot: 37 built-in tools including 17 real Playwright browser actions (navigate, click, type, screenshot, run JS), a guarded shell, file editing, web search + fetch, image generation, text-to-speech and transcription, sub-agents, and cross-session memory. Beyond that, connect any MCP server or 400+ SaaS apps via Composio — all declared in agent.json, no engine code.
Anthropic, OpenAI, Google, OpenRouter — or fully local via Ollama. Switching is a line of config. The very first answer works with no API key at all, running against a local Ollama model.
Five are shipped and tested: Slack, Telegram, Discord, WhatsApp, and SMS. Slack, Telegram and Discord run in-process — start the gateway and they're live with a token. WhatsApp and SMS are webhook-based, so you mount their route on your server. One agent answers on all of them; strangers are held behind fail-closed pairing.
Frameworks hand you parts and you own the loop's quality. Lab SDKs are excellent but locked to one company's models — and are still just libraries: no backend, no channels, no deploy story. Ownware is a Claude-Code-class engine for any model, wrapped in a backend that turns a folder of text into a live, reachable agent.
The engine, gateway, profile format, CLI, keyless first run, bind-safety, the @ownware/client SDK, five channel adapters, and schedules are shipped and tested. It's early and moving fast — the npm publish and the white-label chat UI are the next milestones.
Build your agent. Own all of it.
From install to a live, answering agent in minutes — no API key required to start.