Oryh
Health Uyari
- License — License: Apache-2.0
- Description — Repository has a description
- Active repo — Last push 0 days ago
- Low visibility — Only 8 GitHub stars
Code Gecti
- Code scan — Scanned 12 files during light audit, no dangerous patterns found
Permissions Gecti
- Permissions — No dangerous permissions requested
Bu listing icin henuz AI raporu yok.
Headless, AI-native ERP & CRM built for AI agents (Claude Code, Codex, OpenClaw, MCP). Software keeps the ledger; agents run the workflow.
Oryh — the AI-native ERP/CRM
Oryh is an ERP/CRM built for AI agents, not adapted to them. Self-hosted,
one company per deployment, open source.
Hosted service · Video walkthrough · Discord · X · YouTube · Apache-2.0
An AI-native ERP/CRM means three things here, each of them structural:
- The agent is the user interface. There are no data-entry screens.
Employees speak to the agent they already use — Claude Code, Codex, Hermes,
WorkBuddy and others of that class — and the agent files the timesheet,
raises the purchase order, matches the invoice. The console exists to
administer the workspace, not to do the work. - The server keeps facts; agents make the decisions. Oryh stores
customers and vendors, products and stock, quotations, orders, invoices in
both directions, payments and settlement, payroll — as durable records with
an audit trail. Which approver comes next, whether a discount is too deep,
what "our process" is: that is prose the workspace owns, read by agents,
never a configuration screen. - Skills instead of an SDK. A skill is markdown plus plain HTTP. Any
agent that can read a file and call a URL can run the company, and every
skill carries the server's own contract so the agent knows each parameter
before its first call. MCP is the same door for agents that speak it.
Bring your own agent. Skills are markdown instructions plus plain HTTP —
no SDK, no client library, nothing to keep in step with a release. So most
general-purpose agents work as they are: Claude Code, Codex, Hermes and others
of that class. Connect one once, and it works your company's records through
skills your workspace owns.
Just want to look? https://oryh.ai (or https://oryh.cn in China) runs the
same product as a hosted service — nothing to install.
Video walkthrough — Change the Rules. Run the Order. Verify the Shipment.: changing a workspace rule in plain English, running a sales order through an agent, and verifying stock reservation and shipment on the record.
git clone https://github.com/AIE-enginehub/Oryh.git
cd Oryh
docker compose up -d --build
docker compose logs api | grep -A6 "standalone workspace created"
The first build takes a few minutes; migrations then run on start. Whendocker compose ps shows four healthy services, open
http://127.0.0.1:8080/.
That grep is the whole point of the second command: first boot creates one
workspace, its administrator and a service key for agents, and prints them
once — after a hundred lines of migration output. Store both before you
move on. Change the password after signing in.
The workspace starts empty: no employees, no customers, no documents. It is
your company's records, waiting for your company's records. Which is why the
next step is not clicking around the console — it is connecting an agent.
If you are evaluating Oryh and prefer preloaded fictional records (Northwind Instruments — customers, inventory, open invoices, a project, and published
discount and approval rules), load the optional sample dataset once the stack is
healthy:
docker compose exec api python scripts/seed_sample.py
Connect your agent
oryh-connect is a bootstrap skill that carries no credential — only this
deployment's address. The agent installs it, opens the approval page, you sign
in and approve, and only then does the agent receive its own key and personal
skill bundle. Nothing is copied and pasted between the two.
curl -O http://127.0.0.1:8080/api/v1/connect-skill # oryh-connect.zip
http://127.0.0.1:8080/web/connect serves the same download in the browser.
Unzip it where your agent looks for skills:
| Agent runtime | Skill directory |
|---|---|
| Claude Code | ~/.claude/skills |
| Codex (app, CLI, IDE) | ~/.agents/skills |
| Copilot CLI | ~/.agents/skills |
| Hermes | ~/.hermes/skills |
| OpenClaw | openclaw skills install ./oryh-connect --global |
Then ask the agent to connect — /oryh-connect in the runtimes that take slash
commands, or plain words in the ones that don't. It opens a page in your
browser; you approve there. See device flow for what the
approval actually establishes, and capabilities and
skills for how a bundle is scoped to what its
principal holds.
Because the bundle carries this deployment's address, a copy downloaded from
one environment should not be reused against another.
What you get
- Documents and ledgers that already know their shape — timesheets,
expense claims with receipt extraction, contracts, purchase requests and
orders, sales quotations and orders, stock reservations and shipments,
invoices in both directions, credit and debit notes with invoice offsets,
payments with an append-only settlement ledger, general ledger (chart of
accounts, journal entries, accounting periods), project execution (tasks,
milestones, issues, frozen period reports, and cost/billing tracking),
payroll, and billing accounts for charge-to-account and points. - Your own object types on top: a warranty card, a site survey, whatever
the business actually tracks, with a JSON schema and a lifecycle you define. - Tenant-defined authorization — capabilities, roles, and per-credential
scoping, so an agent holds exactly what its principal holds. - Skills and MCP, not an SDK — an agent downloads a bundle of instructions
written for your workspace, with its credential rendered in (no CLI to
install, no client library to keep in step), or connects overPOST /mcp
with OAuth 2.1 under the same permissions, PostgreSQL RLS, and audit
attribution. - An audit trail with server-side attribution: who did what is decided by
the credential, never by what the caller says about itself. - Behaviour you change by writing a sentence — skills, approval routing
and lifecycle vocabulary are all prose this workspace owns, so "we do it
differently here" is a message to an agent rather than a customisation
project. See below.
Customising it is a conversation, not a project
Most of what a business calls "our process" lives in this system as prose.
The skills an agent works from are markdown; a workspace's approval routing is
a natural-language document the flow agent reads at decision time; lifecycle
state names are the workspace's own words. None of it is compiled, and none of
it needs a release.
So changing how the system behaves here is usually a sentence to an agent:
"When you report my todos, list titles and due dates only — do not expand
the linked record."
"Pay approved expense claims directly. We do not raise reimbursement
invoices."
"Call the post-approval invoice state
approved, notissued."
Each of those lands on a different knob — a skill's calibration, the
workspace's workflow definition, the lifecycle machine — and the admin's agent
knows which. All three take effect immediately, for everyone, with no fork, no
configuration screen and no deploy. Agents pick the change up on their next
session, and are told what changed rather than silently re-instructed.
What that is worth is mostly what it removes. In a traditional ERP the
same three changes are a customisation request, a developer, a test
environment and a release window — and the second one is often "not
supported", because the vendor decided that expenses become invoices and the
schema encodes that decision. Here the decision is text, so a workspace that
disagrees writes a different sentence.
Where prose stops. Calibration cannot widen what a skill may do: the
rendered text says the skill's own rules win on contradiction, and the server
enforces permissions, state transitions, settlement arithmetic and attribution
regardless of what any instruction says. Natural language decides how work is
done; it never decides what is allowed. That boundary is what makes editing
the prose safe enough to do casually.
What this is not
Headless is the substance of the claim, not a label: no page-first OA suite,
no BPM engine, and none of the six-month master-data configuration a
traditional ERP asks for before it holds a single document. There is a
console, and it is for administering the workspace — the work itself happens
through agents.
Running it
Requires Docker and about 2 GB of RAM. Configuration lives in .env; see.env.example for what a real deployment sets — at minimumORYH_BASE_URL and SMTP, once the deployment is reachable by more than you.
Pre-built multi-arch (linux/amd64, linux/arm64) release images are also
published to ghcr.io/aie-enginehub/oryh-api andghcr.io/aie-enginehub/oryh-console — set ORYH_API_IMAGE andORYH_CONSOLE_IMAGE in .env and run docker compose up -d to skip building
from source.
Upgrade by pulling a newer release and restarting: migrations run on start and
are idempotent. Back up with pg_dump against the db service; the database
is the whole state.
Optional: an unattended flow runner (--profile flow-runner) that drives
queues with your own agent runtime and model key. It idles until your
workspace has a flow skill and a subscription.
Documentation
Design notes for the parts where the modelling is the interesting bit:
- Receivables and payables — invoices,
payments, and why settlement is never a status - Billing accounts — one shape for money and points
- Customers — retail and B2B on one table, and why not a
Party layer - Payroll · Business rules ·
Device flow ·
Capabilities and skills
The API documents itself at /redoc, and /openapi.json is the contract the
console is compiled against.
Development
uv sync --extra dev
uv run --extra dev pytest
The suite runs on in-memory SQLite and needs no services. Postgres is what
deployments run on; sql/schema.sql is the snapshot the tests pin the ORM
against.
Relationship to the hosted service
https://oryh.ai is that hosted service, and the fastest way to see what this
is before cloning anything.
This repository is the product, exported from a private trunk at each release.
What stays private is the layer that runs it as a hosted multi-tenant service
for strangers — self-service registration and its review queue, the platform
operator console, and our own operations — plus the approval-flow skills the
hosted service maintains and calibrates.
Everything here is a complete single-company deployment, not a trimmed one.
Nothing is held back to sell you an upgrade. If you would rather build your
own multi-tenant service on top of it, the licence permits that and we do not
object; you will be rebuilding that operating layer, which is the honest
description of what we kept.
Licence
Apache-2.0. The name and logo are not covered — see
TRADEMARK.md. Security reports:
SECURITY.md. Contributing: CONTRIBUTING.md.
Yorumlar (0)
Yorum birakmak icin giris yap.
Yorum birakSonuc bulunamadi
