Skip to content
Open-core, AGPL-3.0

Self-host the whole thing.Own every moving part.

Run the entire Ony stack on your own infrastructure under AGPL-3.0. Your data, your phone line, your signing keys, your servers. Nothing phones home, and there is no paywalled core. Install the package, bring up the stack, wire your agent.

$ pip install ony_
No phone home One-command Docker stack Bring your own keys Every feature, free forever
Quickstart

Running in three commands.

Install the connector, bring up the stack, and point your agent at it. Sensible defaults out of the box, full configuration when you need it.

install and enroll
# install the connector
$ pip install ony

# enroll this phone as a device
$ ony enroll
[ony] device decision_key issued
[ony] enrolled, ready to gate

The package ships the ony console script. Enrollment issues a per-device key so verdicts can be verified locally.

one-command stack
# clone and start the stack
$ git clone https://github.com/ony-ai/ony
$ cd ony
$ docker compose up -d
[ony] daemon, dashboard, telephony
[ony] stack healthy on :8088

The provided compose file brings up the daemon, the dashboard, and the telephony bridge together. Set your SignalWire credentials in the environment first.

wire the agent
# install the PreToolUse hook
$ ony hooks claude --install
[ony] hook wired into Claude Code

# then, inside your session
> /ony on
[ony] gating high-risk actions

The PreToolUse hook is the pre-execution gate. Type /ony awayinstead to be called for every actionable step.

Architecture

Four parts, all yours to run.

Four legible pieces with a clear trust boundary. The server is authoritative, the connector verifies, and you run every one of them.

Connector

The ony Python package, installed with pip. A typer CLI built on websockets, rich, and httpx that talks to the daemon over a WebSocket agent channel and verifies every signed verdict before honoring it.

Daemon and server

Owns session state and the approval cache, classifies risk server-side from its own taxonomy, signs verdicts per device, and appends every decision to the hash-chained audit log.

Dashboard

Enroll and revoke devices, review decision history with attribution, and verify the audit chain. Enrollment hands a device its decision_key so it can check signatures locally.

Telephony

Calls go out through SignalWire. On self-host you bring your own number and your own keys, and usage is billed pass-through by your provider, not by Ony.

Decision delivery is pause then resume, never keystroke injection:a daemon-cached approve or deny flag the hook consults, orclaude -p --resumewith the decision as the next prompt.
Ownership

No lock-in, no phone home.

Self-host means self-host. There is no hidden control plane, no metered core, and nothing that calls back to us.

  • Your data stays on your infrastructure, with no phone-home and no third party in the decision loop.
  • Your own phone number and telephony account, billed directly by your provider.
  • Per-device signing keys that you generate, hold, and rotate.
  • Every feature included, with no paywalled core and nothing held back for a paid tier.
  • AGPL-3.0 source you can read, audit, modify, and ship.
License

AGPL-3.0, with a commercial path.

Strong copyleft keeps the source open, with a hosted option for teams that cannot take on copyleft obligations.

What AGPL-3.0 means, plainly

  • You can run it, study it, modify it, and share it.
  • If you distribute it or offer it as a network service, you share your changes under the same license.
  • For internal use, you keep your own modifications to yourself.

Need to avoid copyleft?

Ony Cloud is the commercial hosted option. The same product, fully managed, with dedicated numbers per organization, team seats and roles, and managed key storage. No AGPL obligations to reason about, no ops to run.

Community

Contribute.

The roadmap is in the open. Issues, discussions, and ADRs live in the repo, and new agent connectors are welcome.

Open issues and discussions

File a bug, propose a feature, or talk through a design on GitHub. The architecture review and ADRs are in the repo, so context is one click away.

Send a pull request

Pick up a good-first-issue or fix something you hit yourself. The contract shapes are settled in the ADRs, so changes stay grounded and easy to review.

Add an agent connector

Every agent event normalizes into one AgentEvent shape, so the model is agent-agnostic. Adding support for a new coding agent is mostly mapping its events.

Clone it, run it,
make it yours.

The whole stack is on GitHub under AGPL-3.0. Bring it up with one command and own every part of the loop.

$ pip install ony && docker compose up -d