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 /dezycro:import-features or /dezycro:author, it's your Claude Code 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

Tenant (organization)
├── Members (users with tenant-level roles)
├── PATs (Personal Access Tokens)
├── Billing (plan, seats, AI token cap)
└── Workspaces
    └── Projects
        ├── Ingested Documents (RAG knowledge base)
        └── Features  ← the unit of behavior
            ├── PRD (product requirements)
            ├── TRD (technical design)
            └── Workbook
                ├── Journeys (test scenarios)
                ├── Tasks (units of work)
                ├── Decisions (committed choices)
                ├── Issues (current blockers)
                ├── Assumptions (unverified beliefs)
                └── Verifier runs (execution history)

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

Core workflow

Upload Documents ──→ Author Feature  ──→ Generate Tests   ──→ Run Verifier   ──→ Released
   (RAG)              PRD + TRD            LogicStudio          locally/CI         (locked)
                      via AI / chat /
                      /dezycro:author

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 /dezycro:author state machine.
3. Generate Tests — open LogicStudio 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

• Mission Control — landing page; workspace switcher, recent activity, quick links
• AI Chat — conversational PRD/TRD authoring
• LogicStudio — test generation + review grid
• Feature page — workbook tabs (journeys, tasks, decisions, issues, runs, coverage)
• Settings — tenant (billing, members, SSO, BYOK, audit logs) + workspace (members, defaults)

Claude Code plugin

• 8 /dezycro:* slash commands
• 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 plugin).
• 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).