Launchpad
Menu
Client deliveryHow it worksExample outputsResourcesPricingSign inBring an engagement

How it works

The system underneath the delivery

Client rooms, AI specialists, structured sessions, governed memory and two kinds of canvas — explained the way an evaluator needs them: how information moves, what persists, where review happens, and what is enforced rather than promised.

1. System overview

Your consultancy defines its AI specialists, delivery teams and methodology once. Each client or engagement then gets its own isolated workspace — the client delivery room — where those specialists work with that client’s context in structured sessions, and the results become deliverables through two canvases: the editable Report Canvas and the polished, client-facing Design Canvas.

Your consultancy — specialists, teams and methodology you define once

Client delivery room A

Isolated workspace — row-level security

  • Client context & firm methodology

    Knowledge library — documents, notes, decisions

  • Delivery team of AI specialists

    Lead · specialists · critic · validator

  • Structured working sessions

    The team works the question together

  • Report Canvas → Design Canvas

    Editable report → polished deliverable

↓ Client-ready deliverable — PDF export or email

Client delivery room B

Isolated workspace — row-level security

  • Client context & firm methodology

    Knowledge library — documents, notes, decisions

  • Delivery team of AI specialists

    Lead · specialists · critic · validator

  • Structured working sessions

    The team works the question together

  • Report Canvas → Design Canvas

    Editable report → polished deliverable

↓ Client-ready deliverable — PDF export or email

Each engagement runs in its own isolated room with the same structure: context in, the specialist team works and reviews, a deliverable comes out. Rooms never read each other.

The four moves you actually perform to build the system:

  1. Create a coworker

    Give your coworker a real identity — who they are, what they know, and what they should never let slide. Defined once, consistent every time.

  2. Assemble a team

    Choose who is in the room, assign roles, and set the ground rules. The team frame keeps each coworker in character.

  3. Run a session

    Submit a prompt and the team takes it from there — exchanging context, handing off to each other, and producing a result together.

  4. Save a canvas

    The result lands in a structured, editable canvas. Refine it, reshape it, and share something real.

The product overview walks the full feature set behind this page.

2. Client context

Everything a specialist knows about a client arrives through paths you control:

Where client information lives
In the engagement’s workspace: the knowledge library holds uploaded documents (with OCR for scans), and sessions hold their own transcripts and attachments. Nothing about a client lives outside its room.
What is loaded into a session
The prompt, the team configuration, each specialist’s definition, and relevant knowledge and memory retrieved for the question at hand — retrieval is query-time and selective, not a bulk dump of the whole library into every call.
What persists after a session
The session record itself, any canvases you created, and governed memory entries within their scope rules. Working chatter that never earned persistence doesn’t silently become permanent.
How information is scoped
Knowledge and memory carry explicit scopes — workspace, team, session, or individual specialist — and a specialist only reads within the scopes it has.
What remains private
Everything in the room, to the room: other workspaces (and their specialists) cannot read it, enforced at the database layer.

3. AI specialists

A specialist — Launchpad calls them coworkers — is a durable role, not a throwaway prompt. Its definition carries a purpose and expertise, working instructions (including what it should always challenge), access to knowledge and tools, its own scoped memory, and a model configuration from the platform’s model catalog.

Because the definition is durable, the same specialist shows up the same way in every engagement — and because client context lives in the room rather than in the specialist, reusing a specialist across clients reuses the craft without carrying one client’s information into another’s room.

4. Delivery teams

Roles and lead behaviour
A team assigns roles: a lead runs the working session and hands off to the right specialist; specialists contribute their own angle rather than talking over each other.
Critic and validator
Two review roles are first-class: the critic challenges assumptions and reasoning; the validator sorts claims into supported, unsupported and unresolved. They are teammates in the session, not an afterthought.
Collaboration rules
How the team interacts — turn-taking, hand-offs, how much challenge is expected — is set on the team, so each specialist stays in character while the team decides how they work together.
Output requirements
A team can be pointed at an output: the session works toward a concrete artifact — a diagnosis, a memo, a roadmap — rather than an open-ended conversation.

5. Sessions

How a session begins
You choose the team and submit a real prompt — the question, the task, the deliverable to work toward.
How context is assembled
The runtime assembles each specialist’s working context from its definition, the team frame, and the knowledge and memory relevant to the prompt (section 2).
How specialists contribute
The conversation is structured: the lead directs, specialists contribute in role, the critic and validator review as the work develops — visibly, in the transcript.
How tools are used
Specialists invoke capabilities mid-session — long-document analysis, contract review, web research, design and image generation, even building a new teammate — with the results landing in the session.
When your input is requested
The session can pause for you: a specialist can ask for a decision, a clarification, or missing material, and continue once you answer.
How the working output develops and the session ends
Useful material accumulates as the session runs; when the work is done you carry the result into a canvas (section 6) — the session stays as the record of how the result was reached.

6. Working material, Report Canvas, Design Canvas

Launchpad separates three kinds of material, and the separation is the quality model:

Raw findings and working material
The session transcript, tool results and drafts — the workshop floor. Useful, inspectable, and deliberately not the deliverable.
Report Canvas — the curated working report
A block-based, editable document with version history. You restructure, rewrite and cut; this is where human judgment is applied to the work.
Design Canvas — the recipient-facing deliverable
Generated from the Report Canvas you shaped: a polished, styled document ready for the client — exported as a PDF from the browser or sent by email.

AI working material never automatically becomes a client deliverable — the path runs through a report you edited and approved.

7. Validation and approval

The critic and validator give every engagement structured challenge: assumptions are questioned in the open, and claims are sorted by whether the evidence supports them. That is review support — it is not a truth guarantee, and Launchpad does not claim one. What requires human review is, deliberately, everything that reaches a client: the consultancy edits the report, approves the deliverable, and remains responsible for the final output.

Formal pre-delivery review gates — an enforced sign-off step with an approval record — are in development and not yet part of the live product; today the review discipline is the workflow above.

8. Memory and reusable knowledge

Short-term session context
What the team is holding right now, inside the running session. It ends with the session unless something is deliberately kept.
Durable memory
Scoped, governed entries a specialist carries forward — bounded by scope and authority rules, human-gated for durable shared scopes, superseded rather than silently overwritten.
Client-scoped knowledge
The engagement’s documents and context, living in its workspace and only there.
Team-scoped knowledge and firm methodology
Method material attached where it belongs — to a team, or to the workspace as the firm’s way of working.
Approved promotion of reusable learning
Moving learning between teams is a deliberate act: approved team knowledge can be copied to another team, and specialist/team definitions are reusable assets. What is live today is exactly that — human-controlled copy and reuse. A one-click “promote to firm IP” pipeline is a direction, not a shipped feature.

The separation this preserves: client data and reusable firm methodology never blur — reuse moves the method, never the client.

9. Tools and integrations

Specialists work with real capabilities inside a session: web research, long-document analysis, contract review, multi-format document design, image generation, and in-session builders that create a new specialist or team. Integrations connect outside systems: Fortnox is live today — reads during a session, writes only after your explicit approval. We name integrations only once they are live.

10. Security architecture

Workspace isolation & row-level security
Every table carries row-level security enforced by the database — workspace boundaries are not an application-layer filter.
Role-based permissions
Workspace roles decide what each member can see and do.
Credential handling
Upstream credentials are held in a managed vault by reference — never stored in plaintext rows, never returned to a client.
Governed memory & approval-gated writes
Memory follows the scope/authority rules in section 8; integration writes wait for explicit human approval.
Data export and deletion
Your GDPR rights are built into the product — export what is yours, delete what should go.

The complete technical and policy explanation — including the sub-processor register — is on the Security & trust page.

11. Technical FAQ

Straight answers, kept in step with the implemented product — where something isn’t live yet, the answer says so. Pricing details live on the pricing page.

  • Which AI models does Launchpad use?

    Launchpad works with models from multiple leading AI providers, managed through a platform model catalog. Every AI call — conversation, document analysis, embeddings, design generation — runs through one managed gateway, which applies the same credential handling, metering and security posture regardless of provider. The catalog evolves as providers do, so we don’t pin model names here.

  • Can different specialists use different models?

    Yes. Each AI specialist (coworker) carries its own model configuration from the catalog, so a research-heavy specialist and a drafting specialist on the same delivery team can run on different models.

  • How is context selected for a session?

    A session assembles context from the pieces you control: your prompt, the team’s configuration, each specialist’s durable definition, knowledge from the workspace’s library, and the specialist’s scoped memory. Knowledge and memory are retrieved as relevant at query time — pulled in when the work needs them — rather than bulk-injecting everything into every call.

  • Is client data mixed between workspaces?

    No. Workspaces are isolated with row-level security enforced by the database itself, on every table — not a filter the application applies. A session in one workspace cannot read another workspace’s documents, sessions, memory or outputs.

  • What becomes long-term memory?

    Memory is deliberate, not a transcript dump. Durable memories are scoped — to a workspace, team, session or individual specialist — and governed: what a specialist may store is bounded by scope and authority rules, and newer memories supersede older ones rather than silently overwriting history.

  • Can users approve or reject memory?

    Yes. Memory is human-governed: saving into durable, shared scopes is gated on approval rather than automatic, and you can review and manage what a specialist holds.

  • Can outputs be edited manually?

    Yes — that is the point of the Report Canvas. It is a block-based, editable document with version history: restructure sections, rewrite passages, delete what you disagree with. The polished Design Canvas is generated from the report you shaped, not from the raw session.

  • How are PDFs and designed outputs produced?

    The Report Canvas can be turned into a Design Canvas — a polished, styled, client-facing document produced by a dedicated design worker. You can export a PDF directly from your browser, or send the deliverable by email from the workspace.

  • Can clients view an output without entering the workspace?

    Today, delivery happens on your terms: export a PDF or send the deliverable by email — your client never needs a Launchpad account. Self-serve recipient view links are in development and will be announced when they work end to end, not before.

  • What integrations are currently supported?

    Fortnox is the live integration today: specialists can read from it during a session, and any write waits for your explicit approval. More connectors are planned — we only name integrations that are live.

  • What is stored by Launchpad?

    Your workspace content: specialist and team definitions, sessions and their transcripts, uploaded knowledge documents, governed memories, and your Report and Design Canvases. Data export and deletion are built in; the full security posture — including the sub-processor register — is on the Security & trust page.

  • How are AI and tool costs metered?

    Every AI call runs through one gateway that meters real usage against the workspace’s balance. Subscription plans include capacity, and Launchpad is a paid product — a workspace needs an active plan to run AI work. Current plans are on the pricing page.

  • Can a consultancy create several client workspaces?

    Workspaces are the isolation unit, and an account can belong to several. Today each workspace carries its own subscription — consultancy-level portfolio billing across a set of client rooms is not yet live. If you run multiple concurrent client engagements, bring one to us and we’ll help you structure the setup.

  • Can methodology be reused between clients?

    Yes, deliberately. Specialist and team definitions are reusable assets that carry your methods into the next engagement, and approved team knowledge can be copied into another team when you choose to. Client documents, session history and client-scoped memory stay in their own workspace — what travels is the method, never the client.

  • Which capabilities are live, and which are planned?

    Live today: isolated workspaces with row-level security, durable AI specialists and delivery teams with critic and validator roles, structured working sessions, scoped knowledge and governed memory, the editable Report Canvas with versions, Design Canvas generation, email delivery, browser PDF export, the Fortnox integration, and a security audit log. In development (not yet claimable end to end): client-facing share links, engagement-led onboarding, consultancy portfolio billing, and pre-delivery review gates. This answer is reviewed as the product evolves.

See it on your own engagement

Walk the read-only demo, or bring a live engagement and we’ll set the room up with you.

Explore the demoBring a live engagement