Your AI suggests. You approve. The map grows.

A chat ends and its work stays in that chat: the next session starts from nothing. In Archimatrix every session opens the map as the last one left it, and what its AI does lands there as a suggestion until a person approves it.

Example sessions on the SaaS Starter map. The people are invented.

Not every idea is ready to be a card. Drop it on the whiteboard first. Ask your AI what you are missing; its answers land as stickies marked AI and never touch the map. Promote the one worth keeping, give it a name, and it lands on the map with your words still on it.

The stickies and your AI's answers are drawn from the SaaS Starter example.

One worksheet becomes one kind of card, each row a card, each column a detail you choose. Bring it in again and nothing doubles. Words work differently: they go to the whiteboard first (A-03).

An example spreadsheet with two of the SaaS Starter team's decisions in it.

Arrange the map as columns and the columns are a detail of its cards. Here they are the Status of a Decision: Proposed, Agreed, Declined. Drag Fix invitation emails first into Agreed and its Status becomes Agreed, as one step; one Undo puts both back. Set the Status in the panel and the card moves to match. Switch to Canvas and the cards sit where they always were: a layout holds no data of its own.

The two decisions match the SaaS Starter example's own: there too, Fix invitation emails first is Agreed and Check roles on the server is Proposed. Arrange as… offers Columns by Status because Status is a dropdown detail. The struck-through “Proposed” is this drawing's mark for where the card was.

Your workspace type gives you its kinds of card; you can add your own beside them. Here a new kind, Risk, gets one detail, Likelihood, and one rule: a Risk may link to an Integration. Risk now shows in the palette, and every Risk card carries Likelihood. The rules can be made to refuse a link they forbid, for everyone: a person on the canvas, an accepted suggestion, your AI team, your own agent.

Risk and Likelihood are an example a team might add. The Risk card is drawn beside the map, not on it.

A layout does not have to start from a detail. Start a blank board, type two column names, and drag cards in: they sit where you put them and keep every detail; nothing is edited. Later, Bind to a field… asks which dropdown detail the columns mean, matches each name to one of its choices and shows every card that will change before it writes. Save it as a layout and Arrange as… offers it by name across your organisation.

“Must have”, “Can wait” and “Launch priorities” are names a team might type. The cards are the map's own; the board adds none.

Publish a brief and it never changes. Hand out a slice of it, and check the code against exactly that slice. Then accept it in two acts, a beat apart: someone approves the check, and the slice's owner marks it done. Only the second moves the slice to Done. What you accept is where the next round starts.

The brief, the slice and its three cards are the SaaS Starter example's own. Hana is page narration; the product records the person who approves a check.

A published brief is a plan; slices turn it into work. Pick cards, name the slice, give it to someone. Here Send the invitation email has gone to Hana: outlined on the map, in her row on the board and in My slices on her home page.

Before the round on B-01: the slice is handed out, not started yet.

The slice and the three cards it covers are the SaaS Starter example's own. Drag the slice, or press a square on the board. A teammate's change shows live on the map, the board and My slices.

A playbook is your way of working: tasks, grouped into phases if you like. Start a project from it and the tasks arrive in its order, each opening the right tool. The SaaS Starter starts First paying customers from the Software product's playbook: its first task opens the map that analysing the repository fills, and the pack's maps and briefs come attached.

The playbook, its tasks and the pack's maps and briefs are the Software product type and the SaaS Starter pack as they ship. Where the product's words say model, this page says map.

Stay in your editor. Ask for your slices and take one: it arrives at the version it was handed out at, never a newer one. Work, mark it done, send a suggestion back. Archimatrix keeps the receipt: who took which version, from which tool, and when. Nothing joins the map until a person approves it.

Claude Code, Codex, VS Code and Qwen Code are among the editors that connect. Hana and her conversation are page narration; the receipt line is the product's own wording. In the product, you approve a suggestion with its Accept button.

Point the desktop helper at your code. It reads the code on your computer and sends Archimatrix what it found; Archimatrix never reads the repository. Your own AI writes a plain sentence about each thing, with its receipts: mark each As intended, Not intended or On hold. Then the map is checked against the code, and each finding waits until you accept or dismiss it.

The first read of the SaaS Starter's code: the first task of First paying customers (B-03), before Hana built her slice (B-01).

The sentences are true of the SaaS Starter's code; the decisions are page narration. Press a receipt number, or accept or dismiss a finding that waits.

Your AI marked the slice done, and an approved code check confirmed its cards present. Whether it works is a third fact: your own AI uses your running app step by step, and the report starts with what did not pass. Approving the check says the report is fair, not that the slice works.

Hana's slice Send the invitation email, at version 1: marked done in her editor (B-04), its code check approved (B-01).

The run is imagined: the SaaS Starter's own cards say only what exists, so its check has no steps, and its pages sit behind a sign-in.

On an agreed card, open Ask AI and choose Build it. The build order goes to your own computer, where your own tools build it on a new branch and run the proof. What comes back is measured from the branch, not taken from the AI's word, and no pull request opens until a person accepts it.

The decision Fix invitation emails first, Agreed on the board (A-05). This is the other route to the work of Hana's slice (B-01): no slice is handed out, and your own tools build it from the decision.

Build it shows once the map is bound to a repository registered on your computer. The two bullet lines are Invitations v1's own acceptance criteria; the agent's notes and the changed lines are page narration.

Connect your own AI and Archimatrix uses it first. Archimatrix AI steps in only when none of yours is connected.

Your own AI is the agent you already use on your computer, such as Claude Code or Codex. It works on the map through a small helper. Fill in a card with AI and the same suggestion lands either way; the status line inside the card names which AI made it.

The lines in the card, before a run and on the Billing panel are the product's own; the refusal at 100% is shortened where it is quoted. The AI is asked only for a card's empty fields; Invite team member already holds its File (A-02), so it suggests the Order. Hana, Kofi and Ines's shares are this page's narration.

Say what you want done, not who should do it. Archie picks a team member and says why; you can change his pick. What comes back is suggestions you decide one by one, and Archie writes down why you kept what you kept.

The decision Fix invitation emails first, Agreed on the board (A-05).

Casey Morgan, the Analyst, and Priya Shah, the Product Manager, are team members the Software product type hires. The request, Archie's sentence and the memory line are this page's narration; the route and file are the starter's own. Casey's work runs like any other AI work here: your own AI first.

Kofi has the map open too. His changes reach your screen a moment later, and a small line names him while they arrive. Press Resolve on a comment and it stays on the card, struck through, on both screens.

Hana owns the map and Kofi is an editor; the comments and their times are this page's narration. The panel's words are the product's: it says model where this page says map. Someone who may only read the map cannot write a comment, resolve one or copy the map.

Set your way of working up once. The same setup serves your own map, a teammate's workspace and a client's.

Set a workspace up from a workspace type and it has the type's shape: its kinds of card, its playbooks and its AI team. Add a starter pack and it fills that shape with cards, each one of the type's kinds, and a worked project. A pack never makes a kind of its own.

Outline: from the type, Software product Filled: from the pack, SaaS Starter

The kinds, playbooks and AI team are Software product's as it ships. The six cards are the pack's path through the starter as this page names it, each with the kind of the pack's own card: Choose a plan is its Start checkout, Pay through Stripe its Stripe; Team created, which sign-up makes, is drawn as a State. Only a Decision has a Status, so these cards carry none.

What you sell is a workspace type of your own; Software product is Archimatrix's. Offer a published version to a client's email: they pay you on Stripe's page in your name, and are set up with your whole method in one step. Here you are Fieldstone, and your client is the SaaS Starter team.

Fieldstone, Product launch method and its parts are this page's example; the offer line and the Customers list's statuses are the product's. The SaaS Starter team's workspace is their own, not the “First paying customers” map.

Your client gets your whole method in one step: the kinds of card, the rules, playbooks, layouts and an AI team. The cards they put on the canvas are their own. When you publish 1.1, their admin reviews what is new, what will be updated, what they changed and may keep, and what is no longer in the method, then applies it all or nothing, with undo for 14 days. Their own cards are never touched.

Hatched: from the method Filled: their own work

Fieldstone, the method and its parts are this page's example. The notice, the review's sections and rows and the undo line are the product's, in this page's words; the product asks once more before it undoes. Only the client's admins see the notice, and tasks they have started keep their wording.

Share a starter pack you wrote with other organisations. In the Community Library, open Share, pick your pack, choose Submit to community and press Save package. Once it is reviewed and published, it is in Discover under your creator profile. Another organisation exports it, imports it and installs it into a workspace set up from the same workspace type. Its card counts each adoption, and Rate and Report sit beside it.

Fieldstone, Team invitations and the rating are this page's example. The SaaS Starter is Archimatrix's own, so it cannot be shared; a pack your organisation wrote can. A package carries the pack's example content and says which workspace type it is for; it never carries the type itself. The tabs, fields, statuses and buttons are the product's. Archimatrix reviews a package before it is published; you cannot rate your own, and a report goes to Archimatrix, not onto the card.

Every session opens the map as the last one left it. Its AI is handed the cards and links a person approved, and a count of the suggestions still waiting, never the suggestions themselves. You read the record: how the map got here and, dashed, the suggestions on this map nobody has decided yet. Press Start another session: it starts from the same map.

Ines, Kofi and Hana are invented, and the names on the record are this page's narration: the product records who decided each change and shows a badge. Casey Morgan is the Analyst the Software product type hires. A session is any person with any AI.