Turn your working knowledge, examples, and operating requirements into a Turnstone-native agent package — persona, project, skills, templates — through a gated pipeline with your sign-off at every step.
Process Engine is a persona-and-skills generator for Turnstone: tell it what you want, share what you have, and it produces a complete Turnstone package through a gated pipeline. The engine runs on prompts. Turnstone provides the native governance surfaces Process Engine uses for persistent context and advisory evidence; operator approval remains the final authority at the defined gates.
Process Engine v1.9.6 is the prompts-only, Turnstone-native reference implementation. The prompt+code successor is Method Factory.
Tell it what you want to build, share any material you already have, and it produces a complete Turnstone-native package — project, persona, skills, templates — through a gated pipeline:
flowchart TB
A[Intent] --> B[Orient]
B --> C[Collect]
C --> D[Clarify]
D --> E[Objective]
E --> F[Summary Gate]
F -- operator confirms --> G[Pattern]
F -- material or intent unclear --> C
G --> H[Review]
H -- REVISE --> G
H -- operator sign-off --> I[Trial]
I -- FAIL --> G
I -- all PASS --> J[Ship]
J -- verify read-back --> L[Package live on Turnstone]
L --> M[Operator feedback to Triage]
M --> G
The meaningful operator gates are the Summary Gate (confirm material/intent/objective before generation), Review (operator accepts the reviewed package), Trial (operator accepts trial evidence/readiness), and Ship (operator authorizes deployment). Turnstone's prompt policy provides durable contextual guidance and the advisory judge provides review/trial evidence; neither silently replaces operator approval — the engine doesn't need to recite governance policy; Turnstone supplies the native mechanisms around it.
See a real run end to end: case study: a shop package built, trialed, and shipped.
- Intent before output — collects what you already have, clarifies what you mean, asks what "good" looks like before it writes anything.
- Input-agnostic intake — links, pasted text, files, store pages, existing skills, documents. Everything is assessed; incorporated or excluded with a recorded reason.
- Gates, not guesswork — nothing ships without your review; nothing ships untried. You are the gate; the engine's workflow carries the discipline and Turnstone supplies the native surfaces around it.
- Adapts, never copies — techniques are extracted and attributed, original instructions authored. Sources traced from intent through deployment.
Process Engine is domain-neutral in package structure, artifact-specific, and runtime-aware. It's been exercised on Etsy store management, supplement product listings, incident response, employee onboarding, database backup operations, and financial planning advisories — not just software engineering.
Process Engine runs on Turnstone because Turnstone's governance surface is what the engine produces. Every generated package includes governance objects — prompt policy and advisory judge rules — that provide persistent context and advisory evidence; the engine's "operator is the gate" philosophy maps directly to Turnstone's native approval surfaces.
| Harness | Governance surface |
|---|---|
| Turnstone | Full — projects, personas, roles, policies, prompts, judge, audit |
| Hermes | Agent runtime (skills, toolsets, tasks) — no governance objects |
| OpenClaw | Agent + channels (Discord/LINE) — emission-focused |
| Claude | Commercial harness — no governance layer |
The engine is built for Turnstone and deployed on Turnstone. Turnstone's native mechanisms — projects, personas, skills, prompt templates, the judge — are the engine's platform and governance surfaces; the model generates packages and the operator is the final gate.
| Skill | Role |
|---|---|
process-engine-core |
Entry point — identity, pipeline, routing, standards checklist. Load first. |
process-engine-pattern-author |
Generates the project/persona/skills package for an intent, to standard. |
process-engine-review |
Review gate — spec compliance, standards, scope, evidence, acceptance criteria. Operator sign-off is mandatory. |
process-engine-trial |
Trial harness — cases and trigger sets that prove an artifact performs correctly. |
process-engine-ship |
Deploys approved, trialed packages via Turnstone's native API; verifies by read-back. |
process-engine-triage |
Feedback sensor — converts issues/discussions into engine improvements. |
standards.md · safety.md · evidence-library.md · skill-anatomy.md · best-practices.md · intake.md · governance.md
persona.md — the engine's identity. templates/ — six session initial prompts.
Good fit:
- You use Turnstone and want to build agent packages (personas, skills, templates) with engineering discipline
- You care about intent clarification, evidence, review gates, and deployment verification
- You're comfortable working with an agent that asks questions before generating
Not a fit:
- You want a one-click UI or web interface (this is a skill-based workflow)
- You don't use Turnstone — see Method Factory, the platform-agnostic prompt+code successor
A session follows a fixed shape — the engine collects before it creates:
- You say what you want. "I want a skill that tracks workout routines."
- The engine collects. Anything to work from? A link, pasted text, a file, your store or product pages — after each addition it asks "Anything else?" until you say that's all.
- It clarifies, informed by what you shared. Questions reference your material and distinguish an example to match from one to improve on.
- It asks what "good" looks like. Even a vague vision of the end result shapes the objective.
- It confirms what it's working from. "Working from: N links + M text blocks (k sources unknown). Intent: X. Good looks like: . Generate?"
- You watch it through the gates. Pattern → Review → Trial → Ship, with your sign-off at each one. Nothing ships without you.
The engine never copies what you give it — it extracts the techniques and intent, authors original instructions, and attributes the sources it knows. And it's a helper, not a police officer: when something is worth knowing it tells you plainly and stays out of the way — you decide.
Process Engine runs on Turnstone. Full governance included:
- Create the project:
POST /v1/api/projects. - Create the persona:
POST /v1/api/admin/personas(base_prompt =persona.md).persona.mddefines the canonical Process Engine generator persona; deploy it under a distinct generator identity (e.g.process-engine-generator) so it does not collide with any development/maintenance persona used on the same Turnstone instance. - Create the six skills and six templates via the skills API (prompt_templates store); attach the seven references as skill resources on
process-engine-core. - Create the engine's governance wiring: the prompt policy and advisory judge rules.
- Verify by reading every created object back (GET), then run trials as the verification gate.
Process Engine began as a prompt-only experiment and proved itself in a real end-to-end run — a shop package built, trialed, and shipped. That run established the pipeline: Intent → Collect → Clarify → Objective → Summary Gate → Pattern → Review → Trial → Ship.
v1.9.5 strips the engine back to that original intent. Everything added during the evaluator era — tier systems, manifest mechanics, first-response discipline rules, governance boilerplate, release sealing — has been removed. Turnstone's native governance handles enforcement. The prompts focus on conversation and content generation.
The evaluator-era content and evidence are preserved at Method Factory, the prompt+code successor.
MIT — see LICENSE.
- Generation basis: addyosmani/agent-skills (MIT) — engineering discipline catalog
- Format standard: agentskills/agentskills (Apache-2.0 / CC-BY-4.0) — Agent Skills open format
- Platform: native turnstone mechanisms (projects, personas, skills, prompt templates, judge)