Orkestera

Agentic Workflow Management Suite by EDOS
Goals in. Evaluated, goal-aligned work out. Every action observable & auditable.
6 services
OAuth 2.1 throughout
5 isolated databases
Elixir · Go · Python
scroll ↓
Governance · Evidence · Measurement

Autonomous work, with a receipt for every action.

Agents act continuously and without supervision. What makes that safe to run in a business is not the model — it is that every action is authorized by a short-lived, narrowly scoped credential, written to an append-only record, streamed to an independent observer, and scored against a quality floor that can retire a failing model on its own. Nothing here is trusted because it is inside the perimeter.

Identity Control Execution Evidence & record internal:providers internal:operatoraudit org-scoped admin · issuer-pinned runs:write ↓ · runs:read ↺ events:write ↑ 2 types only run inference internal:routes agent inference runs DIRECT to the provider — key brokered, never proxied per-run token, scoped to one repository events:write events:write internal:quality · 5-min aggregates internal:metrics · 15s own database only read-only · presigned 300s tasks:read internal:halt · internal:scm internal:agentpolicy inference stats · keyed Auth OAuth 2.1 · JWKS issuer · the only trust root humans: Auth Code + PKCE services: JWT 300s · no refresh Every service verifies offline against JWKS — a stolen token expires in five minutes and only opens the one audience it names. 17 distinct scopes enforced across 21 gated route groups Platform orchestration · owns task lifecycle decompose → dispatch → poll → deliver operator halt · atomic run claim · clustered Core policy · registry · quality floor credential broker · org inference policy agent policy + budgets · audit hashes, 90d Runner stateless execution host · fail-closed GraphAgent node graph · durable journal capacity-capped · no credential outlives a run org capability + arg allow-lists baked in at seed LLMProxy routing · telemetry sink · sentiment priority fallback chains per route tokens · latency · cost attribution Watch independent observer · nobody's dependency every action ingested, capped, append-only scrapes each service every 15s events 24h · metrics 30d Hive 5 isolated databases · separate credentials auth core platform watch llmproxy no service reads another's data Run artifacts encrypted · no public access runner may write, never read deleted automatically after 30 days Model providers Anthropic · OpenAI · Google OpenRouter · local 15 in the registry · per-user or per-org key Source control GitHub · GitLab · Bitbucket always a pull request, never a push to main

Authorization

  • Service credential life300s
  • Distinct scopes enforced17
  • Gated route groups21
  • Tenant boundarytoken claim
  • Repo access per run1 repo

Evidence

  • Action logappend-only
  • Event retention24h
  • Metric retention30d
  • Config audit90d
  • Secrets in audit rowshash only
  • Operator actionsrecorded to Core

Measurement

  • Scrape interval15s
  • Quality aggregation5 min
  • Evidence per decision≥30 nodes
  • Demotion margin5.0 pts
  • Model promotionhuman only
  • Run budget ceilingsper-org

Containment

  • Failure modefail-closed
  • Plugin capabilitiesper-org gate
  • Shell commandsarg allow-list
  • Git remote hostsallow-listed
  • Artifact accesswrite xor read
  • Operator stopone control
Every number on this page is derived from the source

A checker reads the Orkestera repository and builds this diagram's claims from the code — which scope guards which hop, how long each store retains data, the constant behind every lifetime and interval. The diagram is generated from looking at the source code, not from our aspirations and guesses.

  • Last checked18 Aug 2026 · 0 drift
A Run, End to End

Goal → decompose → dispatch → execute & score → PR.

01

Goal

Executive takes a user goal, decomposes it into a Task + Issues, persisted to Hive.

02

Dispatch

Platform starts a run on the Runner — runs:write service token, retry while the container boots.

03

Admit

Every request is verified offline before it is read, and the runner reads the org's capability policy from Core. Runs are capacity-capped and time-boxed; an unverifiable caller — or an unreadable policy — is refused, fail-closed.

04

Execute

A whole-graph agent runs the node graph in an isolated workspace, checkpointing every node to a durable journal it can resume from. Command and git-remote allow-lists are baked in before it starts, and one run-wide budget bounds fan-out, expansion and retries.

05

Observe

Every action streams to Watch + Platform. Inference telemetry + sentiment to LLMProxy.

06

Deliver

Diff and evaluations persisted, artifacts stored. Work arrives as a pull request on its own branch — never a push to a default branch.

Zero-Trust by Construction

Two token planes. No overlap.

Plane A Human · Browser

  • GrantAuthorization Code + PKCE (S256)
  • Tokenopaque · 900s + 30-day refresh
  • VerifyRFC 7662 introspection
  • Scopesrole-scoped session
GET /oauth/authorize → code → access_token → introspect → session  ·  GET /oauth/authorize → code → access_token → introspect → session

Plane B Service · Machine

  • GrantClient Credentials (confidential)
  • Tokenasymmetric JWT · 300s · no refresh
  • Verifyoffline against JWKS
  • Scopesinternal:* · events:* · runs:* · tasks:* · watch:* · admin
client_credentials(aud=core) → JWT → verify(sig,iss,aud,scope,org) → serve  ·  client_credentials(aud=core) → JWT → verify(sig,iss,aud,scope,org) → serve
Org is the tenant grain — token-authoritative (ADR-0016). A forged org param that contradicts the claim is a 403, never a silent cross-tenant read.
What You Can Prove

The record is the product. The runtime is why it holds.

Autonomy is only sellable if you can answer three questions afterwards: what did it do, what did it cost, and what happens when something breaks mid-flight. Each of these is a property of the running system, not a policy document.

Every action, reconstructable

Each model call lands in an append-only log with its agent, task, model, latency and a capped prompt/response preview — enough to reconstruct a decision without warehousing the content. Configuration changes are recorded as hashes of before and after, so an audit shows exactly what changed and when, and still cannot leak the secret that changed. Deployment-wide operator actions — a halt, an override — post to their own trail.

  • Inference recordappend-only
  • Config change trailhash only · 90d
  • Node-level run journaldurable
  • Operator action trailrecorded
Every dollar, attributable

Token counts, latency and fallback behaviour are captured per call and rolled up per model and per task — so cost lands against the work that caused it, not a monthly platform invoice. Quality is measured on the same axis: pass rates per model, aggregated continuously, with a floor that retires a failing model automatically — a five-point drop below the incumbent, over at least thirty scored nodes.

  • Cost attributionper task
  • Quality aggregationevery 5 min
  • Model retirementautomatic
  • Run budget ceilingsper-org
Failure is survivable, by construction

The orchestration layer runs on the BEAM, where every agent is an isolated process under a supervisor. One agent crashing cannot take the platform with it — it is restarted, and the work it held is re-claimed. Runs checkpoint every node to a journal they can resume from, so a lost node costs a restart, not the run.

  • Agent isolationper process
  • Singleton across nodesauto-relocated
  • Interrupted runresumable
Observability that cannot stall the work

Evidence is emitted asynchronously under a bounded supervisor: if the observer is slow or down, events are shed and counted rather than queued into the critical path. Agents keep working; the drop is itself a measured signal. Each service is scraped on a fixed interval, so the absence of data is visible instead of ambiguous.

  • Event emissionnon-blocking
  • Shed eventscounted
  • Service scrapeevery 15s
Elixir / BEAM — supervised, distributed, hot-observable
Go — inference routing & telemetry
Python — run host
MongoDB — 5 isolated stores
AWS ECS · artifacts expire on a schedule
Design Partners

In development, with the people who will run it.

Designed & engineered by
EDOS Engineering
Orkestera is a product of the EDOS Engineering team — turning goals into evaluated, auditable, goal-aligned work.