Governance

Which governance rules should an AI agent governance platform enforce server-side?

Bypass the UI, call the API directly, and you meet the same rules — that is the difference between governance and a UI that says “governed”. Every line below has a matching executable assertion; run them once and you know.

  • ✓No boundary, no work: no listing and no loop ownership either
  • ✓Three quota layers refuse at the ceiling: org / worker / person, tokens and cost
  • ✓Assigned ≠ allowed: a chained handoff still passes boundary and approval
  • ✓External or production needs approval first: below the matrix level means suspended
  • ✓External trust domains can't initiate: they reply only when @-mentioned, locked server-side
  • ✓Platform admins can't read the business: egress redaction + permission rows locked
  • ✓Full seats refuse hiring: moved to the waitlist, never oversold
  • ✓Triple key stripping: on ingest, on stored data, on export
  • ✓Unfinished rounds are invalid: unfinished work doesn't get a score
  • ✓One harness, no attribution: a single sample draws no conclusion
  • ✓Deletion protection: depended-on people, your own tenant and platform-admin rows can't be deleted
  • ✓Winding down ≠ deleting: the signed chain is append-only; ledger and evaluations stay with the archived profile; the searchable audit table is never auto-pruned unless the operator sets a retention window
  • ✓Level upgrades need a reason: no reason, no upgrade
  • ✓Role write guard: every management write from a member is 403
  • ✓The custody chain is verifiable: change one entry and the break is named
  • ✓Tenant isolation: request-scoped tenant context; database RLS when deployed on Postgres
python3 scripts/verify-prd.py  → 69 rule assertions python3 scripts/e2e.py  → 17 main flows, 60 checks bun test  → rule kernel and auth
Role permission matrix
RoleCanCannot
memberassign / reply / hold a seat / waitlistevery management write (403)
tenant_adminall governance within the tenant—
platform_adminoperations: snapshots / stripping / tenant directorybusiness reads and writesegress redaction + 403 on business writes; permission rows can't be changed or deleted
space_leadprofile / level / memory / loops / retros for workers in the spacecross-space management (403)
externalreplies only when @-mentionedinitiating anything (locked server-side)

Even “who are you” is decided on the server. Roles are injected by the upstream gateway, but the injection has to be verifiable: the gateway HMAC-SHA256s “role · tenant · expiry” with a shared secret and the server recomputes it. Swapped role, swapped tenant, swapped key, expired — all four forgeries are rejected. In production a missing secret refuses startup; we don't serve on half a configuration.

Marketplace

Can an AI agent built by one team be hired by another?

A creator lists a worker (no boundary declaration, no listing; the materials are generated for you) → review → the hiring side gets a long-term instance the moment it hires. Three billing models, revenue accrued per real round.

Now open: the public marketplace. Official resident workers and workers listed publicly by organizations live at hub.fdelink.ai. Any FDELINK — a cloud organization or an on-premise install — can browse and adopt them; each organization's data and workers stay isolated, only the marketplace is shared. Settlement is not connected yet, so revenue figures stay hidden.

Open the public marketplace

SEAT · per seat
70%
Seat subscription; when seats are full hiring is refused and the request is waitlisted
USAGE · metered
70%
Billed on real rounds and consumption; stops at the quota ceiling
ONCE · one-time
80%
A one-time purchase; hiring provisions a dedicated long-term instance

Percentages are the creator's revenue share. A boundary declaration is required before listing — the marketplace does not accept workers without one.

Security & compliance

What procurement, legal and security will ask — answered up front

Every line below matches the product's own capability fact sheet (facts.json) — the same file the product UI reads. Where something is not built yet, it says so.

Deployment & data boundary

Self-hosted, data stays in your network

One container inside your perimeter. Multi-tenant isolation is request-scoped on the server and enforced again by PostgreSQL row-level security. Personal-space run records stay on the user's own disk; the server keeps index and summaries.

Identity & roles

Roles come from a trusted source, not from the browser

In production the role is injected by a gateway with an HMAC-SHA256 signature or by enterprise SSO (OIDC); the front end cannot change it. In single-machine mode the server listens on 127.0.0.1 only and the “view” switch in the UI is a demo view, labelled as such. Every administrative write is checked server-side; a member gets 403.

Retention, tiered

Three kinds of records, three policies

Signed hash chain: append-only, never deleted (sealed into archive segments, verified end to end). Ledger, evaluation results and task bodies: kept with the worker's profile — archiving ≠ deleting. Searchable audit table: not auto-pruned by default; the operator may set AUDIT_RETENTION_DAYS. Per-tenant retention policies are not offered yet.

Credentials

Values never enter the store

Connector sync records environment-variable key names only. Known secret patterns (API keys, tokens, bearer headers, passwords) are redacted on ingest of transcripts, task text and URLs, and again on CSV export.

Verifiable audit

You verify it, you don't trust us

Every worker round is signed with the worker's own ed25519 key and appended to a hash-linked chain; GET /api/chain/verify names the exact break point if any record was altered. The 69 governance rule assertions ship as a script you can run against your own deployment.

Documents

What ships with a delivery, and what doesn't exist yet

Provided with every deployment: private-deployment guide, enterprise user manual, operations runbook, capability fact sheet. Not yet published on this site: DPA, SLA, privacy policy and a public status page — ask for the current drafts when you book a demo rather than assuming they are final.

FAQ

AI agent governance FAQ: LLMOps, audit and data ownership

Is fdelink replacing tools like Claude Code and Codex?

No. Those are the harnesses; fdelink is the governance layer above them. Your people keep the CLI they like, and fdelink brings the workers running on those tools into the organization — giving them boundaries, keeping the ledger, running the evaluations, and carrying profile, memory and task context across when the harness changes.

Is “swap the model at will” really seamless?

Two layers. Hard continuity is native thread resumption (--resume / exec resume), with threads isolated by “harness @ execution identity” — a new account rebuilds the thread, switching back finds the old one. When hard continuity breaks, soft continuity covers it: every round injects identity, boundary, space memory and the last 3 round summaries. We tested it by simulating an account switch, and the worker answered a passphrase from a round on the previous account using the ledger summary alone. What we do not claim: one seamless session that keeps running across accounts — that layer is a rebuild, and the product labels it as such.

Can a worker overstep — say, send internal material outside?

The boundary is a server-side constraint, not a polite line in a prompt. Assignment is the only path and it walks the boundary check and the approval matrix step by step; a connector marked blocked has its tools removed from the available set at dispatch; an object in an external trust domain cannot even initiate. Calling the API directly meets the same decisions.

Can you alter the audit records yourselves?

Audit is written twice: a display table and an append-only signed chain where each entry carries the previous hash, and each worker round is signed with the worker's own key. Change any one of them and the verification endpoint names where the break is. Verification is in your hands — you don't have to trust our word for it.

Can the company see the personal work I do?

It depends on ownership. Run records in a personal space are written to the user's own machine and the cloud keeps only index and summaries; only team spaces sync in full. The same worker can switch “keep local / to cloud” per round, and the ledger records the switch and the reason for it.

How do you tell whether an AI worker is actually any good?

Test items come from real tasks, not from public leaderboards. L1 assertions plus L2 review, with the reviewing harness separate from the executing one. The same items run on two harnesses: a gap under the threshold means the bottleneck is the worker's gene (prompt and configuration) rather than the model. That verdict is only issued past an evidence bar — both harnesses above a minimum score, enough runs each; two harnesses both scoring 60 is not “accurate and cheap”, it is “insufficient evidence”, and the product says so instead of generating suggestions. With only one harness sample, no attribution is made.