Three engines. One operating system for software production.

Primitiv is composed of three tightly-coupled engines organized around a central Product Registry. Every system passes through the full lifecycle — spec, plan, build, test, review, deploy, evolve. Governance is embedded programmatically.

01 · Core

Product Registry

The central source of truth for every system your organization runs. If it's not registered, it doesn't exist.

  • VisibilityLeadership can answer what systems exist, why, who owns them, and where they run.
  • Dependency graphsDeclared dependencies produce live system graphs that prevent hidden coupling.
  • Lifecycle stateDraft → in development → deployed → deprecated → archived. No abandoned systems.
  • Cost & usageAI cost rolled up per product, per team, per execution. Predictable and measurable.
  • Open APIsBearer-authenticated endpoints under /api/me/... consumed by the Primitiv IDE and your own tooling.

Registered systems · live● 6 active

Platform
billing-reconciler
Deployed · 3 deps
Internal
sales-dashboard
In dev · 2 deps
Ops
alerting-router
Deployed · 5 deps
Platform
auth-gateway
Deployed · 11 deps
Data
etl-customer-360
In dev · 4 deps
Ops
incident-journal
Draft · 1 dep
02 · Intake

Spec Engine

Intent becomes executable specs. No system is implemented without one.

  • Lifecycleidea → prespec → specification → architecture → plan → tasks → ready-to-build.
  • DefinesProblem, expected behavior, constraints, architecture, interfaces, dependencies, all machine-readable.
  • VersionedEvery spec is versioned; downstream artifacts are pinned to a spec version.
  • Feedback loopBug reports and feature requests feed back into the spec, not the codebase.
  • OutcomeA structured brief an agent can execute without ambiguity.

Spec pipelinelive

01Ideacaptured
02Prespecproblem framed
03Specificationstructured
04Architectureresolved
05Plan + tasksready to build
03 · Execution

Execution Engine

Coordinated AI agents turn validated specs into working systems. Deterministic. Reviewable. Never free-form.

  • Agent rolesSpecification, architecture, code generation, testing, review, each bounded to one stage.
  • Governed outputCode must follow the spec, the architecture plan, and Primitiv development standards.
  • ReplayableEvery run, every artifact, every decision, captured and replayable.
  • BYO LLMAnthropic, OpenAI, or self-hosted. Provider-specific logic isolated; no rewrites to swap.
  • Out of scopeFree-form code generation outside the pipeline is not compatible with Primitiv.

Agents working on a spec● 4 running

Agent · Spec
spec-writer-07
Producing structured brief from prespec.
Agent · Architecture
arch-planner-03
Resolving module boundaries and dependencies.
Agent · Code
impl-python-12
Generating implementation against spec v1.4.
Agent · Tests
test-synth-02
Drafting unit + edge-case suite.
04 · Governance

Governance Engine

A living constitution applied automatically to every spec and feedback. Conflicts surface as alerts. The rules evolve with the company.

  • Living constitutionStructured Domain → Section → Principle tree. Owned per domain (legal, security, finance, IT, structure). Ratified, versioned, editable.
  • LLM-as-judgeEvery spec and every feedback evaluated against the constitution. Cited fragments. Severity. Reasons.
  • Spec alignmentDoes the spec respect the principles. Does the implementation respect the spec. Both, continuously.
  • Feedback alignmentEvery customer signal checked against the constitution before it becomes a spec change.
  • Waivers & contestsBypass requires reason, duration, approver. Logged in the audit trail. Never silent.
  • Drift recheckWhen the constitution changes, every existing artifact is re-evaluated. Violations become work items.
05 · Release & Evolution

Deploy. Observe. Evolve.

Every deployed system stays traceable through the Product Registry. Systems are designed to evolve, not freeze.

  • Version controlEvery change linked to a spec version and the agents that approved it.
  • CI/CD orchestrationControlled pipelines. No manual bypass.
  • Release trackingWhat shipped, when, with what dependencies.
  • RollbackAny deployed version recoverable, any time.
  • Continuous monitoringErrors, performance degradation, security issues, dependency conflicts, watched by AI agents.
  • Maintenance by agentsRoutine fixes and upgrades handled by agents under the same governance as new builds.

A Primitiv-compliant system satisfies all seven of these.

  1. It is registered in the Product Registry.
  2. It is based on a formal specification.
  3. Its architecture is defined and validated.
  4. Its implementation follows the specification.
  5. Its behavior is tested and verifiable.
  6. It is governed against the living constitution.
  7. Its deployment follows controlled pipelines.
prmtv

Ready to see it running?

We're opening access to the next ten companies. Structured velocity, governed from day one.

Request access →