Teams
Invite members to a project. Assign roles — owner, write, read — and keep shared specs in sync across the team.
See output before dev starts
Aexol Studio
Studioforproductmanagers
Product specification tools that turn requirements into a visual spec, frontend mockups, and a cost forecast for stakeholders. Validate the architecture upstream, then hand the spec to engineering — PM leads the spec, dev executes it.
Project graph
Frontend mockups
Cost forecast
PM leads spec
Stakeholder sign-off
Versioned contract
Visual Spec Editor
Composespecswithoutwritingsyntax
A drag & drop canvas for building Aexol specifications.Nodes represent types, enums, roles, and workflows — wire them visually and the spec is authored for you. Real-time validation flags type mismatches, invalid references, and permission gaps the moment they happen.
- Drag & drop nodes for types, enums, roles, workflows
- Real-time validation as the graph changes
- Auto-generated Aexol spec from the canvas
- Syntax-aware round-trip — edit code or graph
spec.aexolvalid
type
enum
role
workflow
state
permission
●●●drag to canvas
inference pipeline
01OpenRouter
gpt-4o-mini
02Codex
gpt-4o
streaming artifacts · multi-provider
Inference Pipeline
Streamartifactsfromanyprovider
Run the full inference pipeline — parse, generate, stream — with multi-provider support. Route through OpenRouter or Codex (OpenAI) without changing your spec. Artifacts stream live into the editor as the model produces them.
- OpenRouter + Codex out of the box
- Streaming artifacts — see output as it is produced
- Provider-agnostic — one spec, many backends
- Per-project provider preferences and fallbacks
Artifact Branching
Git-likebranchesforgeneratedcode
Every inference run produces an artifact branch — a git-like snapshot of generated code. Compare branches, merge the best output, or roll back without touching your working tree. Diff artifacts across providers and prompts to choose the winner.
- Each inference run creates an isolated branch
- Diff artifacts across providers and prompts
- Merge or roll back without touching your tree
- Persistent artifact history per project
artifact branches
mainhead
—codex/erp-v2
+4gpt/schema-only
+2openrouter/full-pass
+7Project Management
Teams,billing,andaccesscontrol
Studio projects are first-class citizens. Invite teammates, manage roles, and control who can read, write, or own each project. Billing is per-project with transparent usage meters.
Access Control
Project-level ACLs with owner, write, and read tiers. Moderator write capability on shared projects; owner-only actions stay restricted.
Billing
Per-project billing with transparent usage meters. Track inference spend, storage, and seats per project.
Cloud Files
Ingest, update, and manage project files in the cloud. Reads for owner and shared-team members; writes for owners and moderators.
Shared Specs
Specs live with the project, not your laptop. Open Studio on any device and pick up exactly where you left off.
Project Access
ProjectAccess tiers — OWNER, WRITE, READ — govern every operation. Inference tasks inherit project access semantics.
preview · schema.graphql
# spec.aexol
type Supplier {
id: string
name: string
}
type Lot {
id: string
grade: string
}
// generated
type Supplier {
id: ID!
name: String!
}
type Lot {
id: ID!
grade: String!
}
Live Preview
Seegeneratedcodeasyoutypethespec
The Studio editor shows a live preview of generated code next to your spec. Change a type, add a field, wire a workflow — the preview updates in real time. No build step, no manual refresh.
- Side-by-side spec and generated output
- Updates in real time as the spec changes
- Syntax-highlighted preview with diff markers
- Pick the target language — TypeScript, Python, more
HOW A PM USES STUDIO
From requirements to a stakeholder-ready spec in five steps
No spreadsheets, no disconnected wireframes, no retroactive scope docs. One specification flows from definition to a forecast your stakeholders can approve before a developer writes a line.
STEP 1 — DEFINE
Compose the spec visually
Drag types, workflows, roles, and agents onto the canvas. Studio authors the .aexol file for you and validates every reference in real time — no syntax to learn.
STEP 2 — VISUALIZE
See the project graph
Studio renders an interactive graph of your architecture: nodes are types and roles, edges are references and transitions. Spot missing fields and invalid paths before a sprint is planned.
STEP 3 — MOCKUP
Preview frontend mockups
From the same spec, Studio generates frontend mockups and a live code preview next to your spec. Stakeholders sign off on what they will actually get, not a static wireframe.
STEP 4 — FORECAST
Forecast cost and scope
Studio shows the artifacts that will be generated and the selected model, so you forecast generation cost and scope before engineering starts. Scope conversations become evidence-based.
STEP 5 — HAND OFF
PM leads the spec, dev executes
Ship the validated spec to version control. Developers generate GraphQL, Prisma, API routes, and tests from it. Every change is a reviewable diff — the spec stays the source of truth.
Project graph
Visualizethearchitectureupfront
Studio renders your spec as an interactive graph the moment you add a type or wire a workflow. Nodes are types, enums, roles, and agents; edges show references and transitions. You catch the missing field or the dead-end workflow in a review meeting — not in a sprint demo.
- Interactive graph updates as you edit the spec
- Invalid references and unreachable workflows flagged live
- Share the graph with engineering as the implementation contract
- No separate architecture diagram to keep in sync
Spec graph preview
UserOrderPayment
Role: adminworkflow: checkout
Agent: supportwebhook: refund
✓ 0 validation errors — ready to forecast
Forecast for stakeholders
Artifacts to generate14
Target languagesTS, Python, Go
Selected modelGPT-4o
Est. generation cost$1.82
Est. eng. time saved~3 days
Forecast for stakeholders
Forecastscopeandcostbeforedev
Studio shows exactly what will be generated, in which language, and at what cost before you spend a token or an engineering hour. Bring the forecast to your stakeholder review and turn scope conversations from speculative estimates into evidence.
- Artifact count and target languages from the spec
- Generation cost estimate based on the selected model
- Engineering time saved vs. hand-writing the boilerplate
- Shareable forecast card for stakeholder sign-off
PM leads spec, dev executes
One spec, one contract, one hand-off
The PM owns the specification in Studio. Engineering generates the implementation from it. Every change is a diff in version control, so the spec never drifts from the code — and the PM never rewrites a requirements doc after the fact.
PM owns the spec
Define, validate, and version the .aexol file in Studio.
Dev generates from it
GraphQL, Prisma, routes, and tests come from the same spec.
Every change is a diff
Review the spec change the same way you review code.
KEEP READING
Related pages for spec-driven product teams
Agentic output forecast
Predict what the agent will generate and at what cost before you run it.
Ship code from specifications
The pillar guide to spec-driven development with Aexol.
The inference agent
How the agent parses the spec and writes validated artifacts.
Aexol vs GitHub Copilot
Why spec-driven generation differs from inline autocomplete.
FAQ
Questions product managers ask about Studio
Aexol Studio is a visual specification editor where PMs and BAs describe an application and see the generated output before any developer writes code. You get a graph of the project structure, frontend mockups, and a cost forecast you can share with stakeholders, so requirements are validated upstream rather than in a sprint review.
Ready to start
See your output before dev starts
Book a demo and watch a sales engineer turn your requirements into a visual spec, mockups, and a stakeholder forecast — on your own use case.