Tip: select any text on this page to bring up the Ask tooltip and question the Synedrix OS assistant about it.
The twelve principles, by cluster
Safety
Keeping an agent inside its laneBounded autonomy
Every agent operates within an explicit authority envelope: a boundary on what it's allowed to do that's written down and checked by the platform itself, not left to hopeful wording in a prompt.
Governance before execution
Governance is load-bearing infrastructure, not a wrapper bolted on after deployment: every consequential action is checked against policy before it happens, when stopping it still matters.
Shared context with scoped access
Agents share a context fabric of systems of record, operational memory, event histories, and telemetry. Least privilege is the default: an agent gets only the access its role actually needs.
Architecture
Keeping the system maintainable as it growsOrchestration is the center of gravity
Coordination quality, not raw model power, is what keeps working over time. The orchestration layer routes work, decomposes goals, and sequences tasks across specialised agents, so swapping in a better model tomorrow doesn't mean rebuilding how work gets coordinated.
Specialised agents over mega-agents
Narrow, testable, governable roles beat one agent that tries to do everything. Smaller roles are easier to test, easier to reason about, and don't take the whole system down when just one of them fails.
Deterministic idempotency, explicit state
Every side-effecting step carries an idempotency key and all state is declared, versioned and recoverable, so a run can be retried, replayed or audited from its record. The guarantee covers effects and state, never model reasoning.
Human control
Where human authority sits and how the system stays responsive. See the operating model for the organisational readingHumans stay above the automation layer
Humans define goals, constraints, policies, and escalation thresholds, and stay there as the system runs. Automation can prepare and recommend, but a human still sets the rules it operates inside: the principle is human oversight, not human exclusion.
Event-driven execution
Signals, approvals, failures, and callbacks trigger workflows the moment they happen, rather than on a polling schedule that checks in every few minutes and misses everything in between.
Accountability
How the system explains itselfExplainability and audit by design
The system can always answer three questions after the fact: what happened, why it happened, and under whose authority it happened, the same three questions an auditor or regulator would ask first.
Platform
The platform everything runs on, and the point of the whole systemOne substrate, many domains
The platform itself is domain-agnostic at its core: it has no idea whether it's running a trading desk or a helpdesk. Each industry contributes its own domain pack on top of the same shared orchestration, governance, memory, and observability foundations.
Trust is the real product
Trust is the ultimate output of the platform and the north star the other eleven principles serve.
Open by default, sovereign by design
Designed to run inside a customer's own infrastructure, on infrastructure that is open source wherever an open option exists, with one recorded exception: the inbound Hookdeck gateway. A regulated business can keep inference and data in-house, and no business data, agent decision, or operational logic has to leave its environment unless it chooses cloud inference.
Principles on a page prove nothing
Every principle above names the field, agent, or validation rule that makes it true at runtime: a constraint in the system, not a policy document beside it. Governance, authority boundaries, approval checkpoints where a person decides, and audit live at the OS layer, where no domain pack or business instance can opt out.
The twelve sit in five clusters: Safety, Architecture, Human control, Accountability, and Platform. Each principle's enforcement field is the constraint; the twelve-layer architecture shows where that agent or field lives in the stack.
“Trust is the real product.”
Principle 10 (Trust is the real product) is the north star the other eleven principles serve.
These principles guide the architecture being built. Synedrix OS is in active development.
Principles questions, answered
What the twelve principles require, how agents stay accountable, and how those constraints map onto the architecture. Ask the assistant for deeper, source-grounded detail.
What are the core principles behind Synedrix OS?
Twelve principles govern how the platform stays trustworthy: among them, human accountability stays above the OS, domain logic stays out of the core, every workflow is observable end-to-end, agents have explicit authority boundaries, durable memory is committed only through governed paths, and every side-effecting step carries an idempotency key, with any step that cannot be made idempotent reconciled or escalated instead of replayed.
How does Synedrix OS keep AI agents accountable and auditable?
Agents operate under explicit authority levels (recommend, approve, execute), policy-aware orchestration, escalation paths to humans, and full audit trails. No agent writes to production systems without orchestration visibility, and irreversible or regulated actions require declared approvals.
What are the canonical layers in the Synedrix OS architecture?
Twelve layers span human interface and goal/intent, through orchestration, agent runtime and agent registry, tool abstraction and memory, events, governance, observability, and finally domain pack and business instance configuration. Each layer has a clear owns / does-not-own boundary.