Principles
What we believe about the orchestration layer.
Atelier is built on six foundational commitments. They're not marketing — they're the design decisions you can read in the schema, the type system, and the trace. We wrote them down so the product stays honest as it scales.
- 01
Operations are software, not paperwork.
The playbooks that run a real organization — onboarding, delivery, capture, nurture, review — are software systems whether or not anyone calls them that. They have inputs, branching logic, state, and outcomes. Treating them as paperwork (Notion docs, Slack threads, tribal memory) is what makes ops feel chaotic. Treating them as software is what makes ops scale.
In practice
Flows in Atelier are typed, versioned, and observable. Every run leaves a trace. You can fork a Flow the way you fork a function — and your team's collective playbook becomes a real artifact instead of an oral tradition.
- 02
Agents are first-class citizens, not bolt-ons.
Most automation tools were designed before LLMs and bolted them on as a category of integration. That makes the agent feel like a guest in the workflow. We designed Atelier in the opposite direction — agent steps share identity, tenancy, memory, and trace timeline with every other step. Sage is not "the AI feature." Sage is the worker.
In practice
sage_skill is one of five core step kinds, alongside human_task, product_action, event_wait, and gate. Agent calls write to the same trace as human approvals. Sage Mnemosyne writes persist across Flows so the agent gets smarter about your org over time.
- 03
Identity is infrastructure, not a sign-in screen.
Most workflow tools treat each integration as a separate identity context — "connect to Slack with these creds, connect to Salesforce with those creds." That model breaks when the work spans products that should share an operator. Atelier inverts it: identity is the substrate, and products are participants in that substrate.
In practice
Every row in Atelier carries org_id. Every cross-product call carries a signed envelope with that org_id. RLS is enforced at the database level via the pc_runtime role. You don't configure a connector — you compose, because the identity layer is already shared.
- 04
Multi-tenant from row zero, not as an afterthought.
Retrofitting multi-tenancy onto a single-tenant database is one of the most expensive migrations a software company can do. We've seen it from inside enough times to commit, at the schema level, that Atelier would never be the company that has to do it.
In practice
Every atelier_* table has org_id NOT NULL and an RLS policy keyed on it. The pc_runtime role is the only path to data, and it carries org_id in the connection. Tenant isolation is enforced at Postgres, not application code — even a bug in the server can't exfiltrate cross-tenant data.
- 05
The trace is the source of truth.
You can't trust a system you can't observe. The most operationally mature companies we've worked with all share one trait: they instrument everything. Every step in a workflow leaves a durable record, with enough context that someone six months from now can answer "why did this run do that."
In practice
atelier_traces is append-only and SQL-queryable. Every step, retry, agent call, human approval, and gate evaluation writes a row with the context that produced it. Debugging is a SELECT, not a Slack thread.
- 06
We build for operators, not engineers.
The people who run your operations are not engineers. They are partners, directors, account leads, EDs, program managers. The best workflow tool for them is one that lets them author the playbook in the language they already use to describe it — not one that requires them to translate it into TypeScript first. Engineering escape hatches exist for the cases where they're actually needed.
In practice
Flows are authored via JSON + forms today, visual editor on the v1.1 roadmap. product_action and event_wait steps mean engineers can register new step kinds without operators needing to touch code. The default authoring surface is operator-shaped; the engineering hatch is right there when needed.
A note from the founder
Atelier is built inside Perpetual Core LLC by a team that has been running real operations on every product in PC Studio. We don't treat the orchestration layer as a moat — the engine is a standard that will eventually exist somewhere for every operator. We treat the implementation as a commitment to the people whose work depends on it being correct, observable, and honest about what it is.
Lorenzo Daughtry-Chambers
Founder, Perpetual Core
Open a workspace
Stand up your team's first Flow this afternoon.
Atelier opens in fifteen minutes with five starter Flows and every Perpetual Core product already connected. Evaluate for fourteen days; bring your team when you're ready.