Skip to content

Architecture

A high-level map of how Dezycro is structured. For deeper dives, follow the links into the per-area pages.

Your code stays yours

Dezycro never reads your source code. There is no repository integration, no code upload, and no server-side code scanning — Dezycro works from your API surface and the artifacts your own agent produces, never your source.

  • Your coding agent reads your code — locally. When you run /<prefix>:dz-import-features or /<prefix>:dz-author (/<prefix>-dz-import-features / /<prefix>-dz-author in Cursor), it's your coding agent, on your machine, reading your files (the access it already has). Dezycro is never in that loop — the agent sends only what it writes: PRDs, TRDs, and the workbook.
  • publish-spec uploads your OpenAPI spec — your endpoint shapes, not their implementation.
  • The verifier runs against your running service over HTTP — it never touches your source files.

So what reaches Dezycro is: generated PRDs/TRDs, the workbook, your OpenAPI spec, test journeys, and verifier results. Your source, your repository, and your secrets never leave your environment.

Entity model

flowchart TD
  Tenant["Tenant (organization)"] --> Members["Members<br/>tenant-level roles"]
  Tenant --> PATs["Personal Access Tokens"]
  Tenant --> Billing["Billing<br/>plan · seats · AI token cap"]
  Tenant --> WS["Workspaces"]
  WS --> Playbook["Agent Playbook + notebooks"]
  WS --> Skills["Skills<br/>workspace + platform"]
  WS --> KB["Knowledge Base<br/>uploads · connector imports"]
  WS --> Projects["Projects"]
  Projects --> Features["Features — the unit of behavior"]
  Features --> PRD["PRD<br/>product requirements"]
  Features --> TRD["TRD<br/>technical design"]
  Features --> Workbook["Workbook<br/>journeys · tasks · decisions · issues · assumptions · verifier runs"]

See Auth & access for the tenant-vs-workspace distinction, and The Workbook for the inner workbook structure.

Core workflow

flowchart LR
  U["Upload documents<br/>Knowledge Base"] --> A["Author feature<br/>PRD + TRD<br/>AI chat · editor · /acme:dz-author"]
  A --> G["Generate tests<br/>Validation Center"]
  G --> V["Run verifier<br/>locally / CI"]
  V --> R["Released<br/>(locked)"]
  1. Upload Documents — feed existing specs and designs as RAG context.
  2. Author Feature — create the feature, then write its PRD + TRD via AI chat, the editor, or the /<prefix>:dz-author state machine.
  3. Generate Tests — open the Validation Center to generate journeys from the TRD.
  4. Run Verifier — the verifier binary is built per-feature from the OpenAPI spec; run it locally or in CI to validate journeys against your real service.
  5. Shipped — when all enforced journeys pass and the workbook gates are clear, the feature auto-transitions to VERIFIED. Promoting to SHIPPED (the project regression suite) is a deliberate user action.

The two product surfaces

Web app — app.dezycro.ai

  • Home — landing page: the workspace's projects, features, and open work; the workspace switcher sits in the header
  • AI Chat — conversational PRD/TRD authoring
  • Validation Center — test generation + review grid
  • Feature page — workbook tabs (journeys, tasks, decisions, issues, runs, coverage)
  • Notebooks — the Agent Playbook and any other notebooks
  • Skills — workspace and platform skills
  • Settings — tenant (billing, members, SSO, BYOK, audit logs) + workspace (members, skills namespace, Knowledge Base, Agent Playbook, Test Personas)

Dezycro CLI

  • /dezycro:init plus the /<prefix>:dz-* slash commands — platform skills synced per workspace, alongside your own workspace skills
  • The Agent Playbook delivered as team rules on every request through the local gateway
  • Companion V2 background hooks — verify gate, spec-publish nudge, trigger-based workbook sweep, coverage nudges, TRD quality gate

Both surfaces talk to the same backend, the same workbook, and the same verifier.

Behind the scenes

Beyond the two surfaces, a few capabilities are worth knowing about — all reachable through the MCP server and the Public API:

  • Identity & SSO — standard OIDC. Default login is Google; Enterprise tenants can connect their own identity provider for SSO. Personal Access Tokens authenticate programmatic access (CI, scripts, the Dezycro CLI).
  • Grounded AI authoring — PRD/TRD authoring and test generation are grounded in the documents you upload, via retrieval over your project's knowledge base. See Document ingestion.
  • Test generation — journeys are generated from your TRD as a background job you can poll for status.
  • Verifier pipeline — Dezycro builds a per-feature verifier binary from your OpenAPI spec, records run results, and computes coverage. The binary runs in your environment (local or CI), against your running service.
  • MCP & Public API — the same capabilities are available through the MCP tools and the Public REST API at api.dezycro.ai/api/v1/....

Data handling

Your data is stored encrypted and isolated per tenant — every request is scoped to your tenant on the way in. Enterprise tenants can request a single-tenant deployment as a paid add-on.

Dezycro stores your features, PRDs/TRDs, the workbook, journeys, verifier results, any documents you upload, and your OpenAPI spec. What it never receives: your source code, your repository, or your secrets — those stay in your environment; only your own agent reads them, locally (see Your code stays yours).