M1Spec Join the waitlist

The first AI-native software delivery system

Stop stitching AI tools together. Start delivering with one AI‑native system.

M1Spec takes you from the business conversation to a merged pull request. Domain stories, event models, API contracts, backlog, tests and architecture. All connected, all AI-native, all in one place.

A shopper browses the published products
    Tell it the way your business tells it. M1Spec does the rest.
    The domain story canvas: a shopper's story told as numbered sentences
    The backlog generated from the story, with Given / When / Then acceptance criteria

    M1Spec is not another AI tool to add to the pile. It is one system that runs delivery end to end, from the first conversation with the business to the pull request that ships it, with AI built into every step, not bolted on.

    The problem

    The thread is broken.

    Between what the business means and the code that ships, intent gets translated by hand at every step: requirements, architecture, API, tickets, code. Then we add an AI tool to each step, and each one sees only its own fragment.

    30%
    of engineering leaders saw team productivity drop after adding AI to unchanged workflows.
    25%
    report meaningful acceleration: 2× productivity for more than a quarter of their teams.
    2×
    as likely to gain 20%+ when teams redesign the process before adding agents.

    McKinsey survey of product and engineering leaders, as cited in our research.

    Today: AI on every fragment

    • Every tool starts from zero context.
    • Every hand-off is a copy-paste.
    • Code ships faster than anyone updates the architecture.
    • Nobody can say which tool decided what, or why.

    With M1Spec: one thread

    • One connected model, from business story to merged code.
    • Every artifact is generated from the one before it.
    • AI works with your full context: language, architecture, patterns.
    • Every decision is recorded, and yours to make.

    Don’t make the fragments faster. Connect them.

    How it works

    One thread runs
    through everything.

    Each step is generated from the one before it, so nothing is typed twice and nothing drifts.

    01

    Tell the story.

    Model the business process as numbered sentences on a canvas (who does what, with what), using the icons of your own domain language. Product owners tell it in their words.

    02

    Speak one language.

    Every bounded context gets a shared vocabulary: work objects, actors, commands, events and policies. Work objects carry a TypeSpec schema with a live ER diagram. Rename once, and every story, schema and system follows.

    03

    Generate the event model.

    AI turns the story into an event model on a timeline board: one band per system, with triggers, commands, events and policies in their lanes. Correctness rules run on every save.

    04

    Get the API contract.

    An OpenAPI contract per system, derived from the event model. Browse it, try it, download it. Commands a screen starts are exposed as REST, and a choice you make stays made.

    05

    Slice the backlog.

    Epics and stories for every domain story in one hierarchy, with Given / When / Then acceptance criteria that name the real endpoints and events.

    06

    Plan the tests first.

    Human-readable test suites, plans and cases (steps, preconditions, risks and priority), generated from the event model before a line of code exists.

    One system, three workspaces

    Everything your team does
    to deliver software.

    Discovery

    Understand the business.

    • Domain languages
    • Domain stories
    • Event modeling
    • API contract
    Architecture

    Decide how it is built.

    • Technology catalog
    • Enterprise pattern language
    • C4 systems architecture
    • Architecture versions
    Implementation & Validation

    Build it and prove it.

    • Unified backlog
    • Test suites
    • Plans and readiness
    • Agent executions

    The agent

    Your coding assistant.
    Your machine. Your repository.

    Approve a plan and M1Spec hands it to a desktop agent on your own machine. The agent drives your coding assistant (Claude Code or GitHub Copilot CLI) task by task, with your architecture, technologies, patterns and specs on demand.

    Executing

    1.1 Browse Published Products

    Queued

    0 of 7 tasks done

    1. Initialize the CatalogService Nx workspace
    2. Configure Catalog PostgreSQL access
    3. Align the published-product API contract
    4. Create the published-product projection schema
    5. Project product lifecycle events into published products
    6. Serve the published product listing
    7. Verify published-product listing end to end

    Pull request opened

    5 commits · 56 files · +11,709 lines · checks passed

    A replay of a real execution from our own test project.

    1. Plan. The AI reasons out the goal, what exists, the gap and the tasks, and you approve it.
    2. Build. Your assistant works through the tasks. Every finished task is a commit on a new branch.
    3. Watch. Progress streams to the browser as it happens. Several plans can run at once.
    4. Review. The branch is pushed and a pull request is opened for you.
    An execution in progress: the first task committed with its summary, the second running

    You stay in control

    A plan has to pass the readiness gate.

    Before any code is written, M1Spec asks one question: could a developer build this on the architecture as recorded? If not, it stops and shows you exactly what is missing. Your answers are recorded as decisions, and the AI treats them as settled.

    The readiness gate refusing a plan with three findings that need a decision

    The AI never fights you.

    A choice you made explicitly stays made. It is recorded, enforced by validation and restored if an AI step tries to change it.

    Correctness rules, everywhere.

    A command only reaches events of its own system. A command a screen starts is exposed as REST. The same rules run on save, generation, import and in the open spec validator.

    Behaviour is not structure.

    The event model describes what the business does. Your patterns and your codebase decide how the code is shaped: the agent never invents classes your patterns don't have.

    Merge is the approval.

    The architecture changes only when the code is merged and you complete the plan. Not a moment before.

    Architecture that stays true

    The diagram updates itself.
    After you merge.

    Every execution reports a C4 change set of what was actually built, with evidence for each change. Compare now and after, then complete the plan to make it the active version.

    Completing a plan: the C4 diagram now and after completing, with the new catalog-api and catalog-db containers and the list of confirmed changes
    18
    architecture changes reported by one plan
    12
    of them confirmed by the code itself
    1
    click to make them the active version

    Start from templates

    Open specs.
    In plain TypeSpec.

    Begin with ready-made domain languages and domain stories (Payment, Pay for order, Shop and fill a cart) from the open OpenBusinessSpec repository. Story templates declare their dependencies, and every import is checked against the same correctness rules as a save.

    Browse OpenBusinessSpec
    @rest(Post, "/payments")
    @command("c71e54e6-9bc2-4650-809d-a2ec8774166f")
    @icon("/iconify/mdi/credit-card-plus-outline.svg")
    model CreatePayment {
      input: {
        order: OrderReference;
        amount: Money;
      };
      output: {
        payment: Payment;
      };
    }

    Who it's for

    Built for the whole room.

    Engineering leaders

    One AI platform to adopt, govern and measure, instead of a dozen tools to integrate and secure.

    Architects

    A C4 model that reflects the code, and a pattern language and technology catalog the agent actually uses.

    Product & business

    Domain stories in their own words. Every backlog item and test traces back to a sentence they told.

    Engineering teams

    A sliced backlog, a contract-first API, test cases before code, and pull requests that arrive ready to review.

    For consulting partners

    Your expertise, packaged.

    Turn the domains you know and the patterns you trust into packages M1Spec runs on every engagement. Start each client on day one, and sell what you know, not just your hours.

    Become a design partner
    • Domain packagesDomain languages and stories you reuse across clients
    • Patterns as codeYour blueprints as Nx generators the agent runs
    • A revenue stream beyond hoursPackage once, reuse and offer it again and again

    White paper

    Executable Intent

    Managing trust, verification costs and architectural drift in generative AI engineering: the thinking behind M1Spec.

    Read the white paper

    “The cheaper code generation becomes, the more valuable explicit architectural constraints become.”

    One system. From the first conversation
    to the merged pull request.

    M1Spec is opening to teams in waves. Join the waiting list and we'll let you know when your spot is ready.