Everything we shipped, dated.

Google confirmed the listing on 8 September 2026. It is the same platform, the same Veda and the same people behind it; what changes is the paperwork. Procurement runs through Google, the charge appears on your Google Cloud invoice, and the spend can count toward a commitment you already have with Google Cloud.

That matters for two kinds of buyers. Enterprises that have already cleared Google Cloud through vendor review get Intuist without opening a new vendor. Resellers and distributors can transact it the way they transact everything else in the Marketplace.

What is on the listing

Public plans.

Four sizes of the same engineer: one AI assistant on one task, one workflow end to end, one business process automated, or multiple collaborating agents orchestrating several. Subscribe from the listing, then finish sign-up with us in one step.

Private offers.

Custom terms, wholesale pricing for partners and multi-year agreements are written as private offers, accepted inside your Google Cloud console.

The same platform.

Veda Studio, the integrations, the models and the trust score on every build. Nothing is held back for Marketplace customers, and nothing is added that we would not sell direct.

How to find it

Use the direct link below. Marketplace search also finds it under Intuist, but the link is the surest way in, and it is the one to forward to whoever holds your Google Cloud billing account.

Every CRM ever built asks you to feed it. You have the conversation, and then you go and re-type it: pick the contact, pick the company, set the stage, set the amount, add a task, write the note. The work happens in the conversation; the CRM only ever gets a summary of it, entered late and badly, usually on a Friday afternoon.

Signal CRM inverts that. There is one box. Paste raw material into it — a forwarded email thread, notes typed during a call, a two-line LinkedIn reply — and it reads the thing the way a colleague would. It works out who was involved and which company they belong to, whether there is a deal and what it is worth, what stage it has reached, whether it is healthy or going quiet, and what specifically you now owe them. Then it files all of it, merging into records that already exist rather than making duplicates.

What ships in the box

One box, any input.

Emails, call transcripts, meeting notes, chat replies. No format to follow, no fields to fill, no schema to design before you start.

Records that build themselves.

People, companies and deals are created and merged automatically — the same person under a new email address lands on the existing record, not a second one.

Stage and health, inferred.

It reads intent and tone: a deal with an unresolved blocker is flagged to watch, a headcount freeze reads as at risk — so quiet deals surface themselves instead of waiting for a pipeline review.

Ask your CRM in plain English.

"Which deals are blocked, and what exactly is blocking each one?" — answered strictly from your own records, naming the accounts and quoting the evidence it relied on.

A briefing before every call.

One click on any deal builds a prep note from the whole history: where it stands, what they care about, the risks, and the line to open with.

Relationship memory.

Every interaction is kept as continuous context rather than a disconnected activity log, so the full story of an account is one click away.

Why it matters

A CRM is only as good as what people bother to put into it, which is why most of them quietly rot. Signal removes the step where discipline is required. The record is a by-product of doing the work, not a chore that follows it — and because the whole history stays as context, the CRM can answer questions about your pipeline instead of just storing rows for you to read.

It is in the template gallery as a one-click remix. Clone it and you get your own private pipeline: your accounts, your conversations, your data.

Every business runs on agreements, and most of them still crawl through a maze of email attachments, blocked file-share links, and third-party signature tools that charge per envelope. Agreement Studio makes signing a first-class capability of the Intuist platform — built, like everything here, as an app you can open, use, and clone.

Point it at a Google Doc template or paste your contract, then click the spots where signatures, dates, and fill-in fields belong — no markup to learn. Your counterparty gets a private signing link, proves they're the right person with a one-time email code, and signs right on the document, guided tab to tab. Choose the order: they sign first and you countersign to complete (the flow everyone knows), or pre-sign so they receive an already-executed copy. No account. No app. No login wall.

What ships in the box

Google Doc intake.

Your existing agreement template imports directly — formatting intact — or paste any contract text.

Click-to-place fields.

Drop signature, date, and fill-in anchors exactly where they belong on the document — the guided wizard shows you the real contract at every step.

Your choice of signing order.

The familiar flow — counterparty signs first, you countersign to complete — or pre-sign so partners only ever receive an executed copy.

Verified signers, zero accounts.

An unguessable expiring link plus a one-time code to the bound email address. The code can't be redirected — the request carries no address at all.

Signing like DocuSign.

Yellow tabs guide the signer field to field; their typed or drawn signature lands right on the signature line, with explicit ESIGN consent.

Tamper-evident execution.

The final PDF carries both signatures at their anchors, a full signature-evidence table (who, when, from where), and a SHA-256 integrity hash — emailed to both parties the moment signing completes.

Envelope tracking.

Created, sent, viewed, signed, completed — every agreement on one rail with a clear next action, resend, and PDF download one click away.

Why it matters

Signature tools became a tax on doing business. Agreement Studio folds that whole product category into an app: your agreements live where your CRM, your workflows, and your AI already do — and the audit trail is yours, not a vendor's. It ships as part of the platform: open Agreements from your workspace, sign in, and you get your own private agreement space: your contracts, your countersignature, your business.

The most common failure in AI app builders isn't broken code — it's a build that looks finished but quietly dropped something you asked for, or padded itself with things you didn't. As of this week, the Intuist builder closes both doors.

When you describe what you want, the platform now reads that request like a contract: every feature, integration, and capability you name becomes an explicit checklist item. Before the finished build reaches you, it's audited against that checklist — item by item. Ask for a client portal with a PDF download of every invoice, and a build that silently skipped the PDF export is caught and completed by the platform, not discovered by you three days later.

What's new

Contract extraction.

Every feature, integration, and capability you name in your request is pulled into an explicit checklist the moment you hit build — your words become the spec, automatically.

Fidelity audit on every build.

The finished build is checked against the checklist before it's presented as done. A named feature that got dropped is caught and completed before you ever see the app.

Refinements covered too.

The audit runs on every refine, not just the first build — so iteration can't quietly erode features you already had.

Scope-creep capped at the source.

The inverse guarantee: unrequested extras — a surprise export button, an outbound email action you never asked for — are blocked where they're born.

The receipts are kept.

Your original words and the audit result are persisted on every build, so request fidelity is a tracked, queryable metric the platform is accountable to.

Why it matters

Trust Score already grades every build on quality — does it work, is it fast, is it secure. Request Fidelity answers the question that comes before all of those: is it what you asked for? Together they mean a finished build isn't a plausible interpretation of your request. It's your request.

Security at Intuist isn't a page in the docs — it's a weekly engineering discipline. This sprint focused on the front door and the plumbing of every private app.

What shipped

True two-step MFA.

Private apps now enforce a genuine two-step verification flow — identity first, then a second factor — with the email-only shortcut closed.

No anonymous data path.

Every app runtime API now requires a credential. There is no raw-anonymous route to an app's data — period.

Brute-force protection.

Access-code verification is rate-limited with a sliding window per visitor, so codes can't be guessed at machine speed.

A front door worth locking.

The verification screen was redesigned — a split-canvas, brand-adaptive gate that feels like part of your app, not a hurdle in front of it.

Connections that never lapse.

OAuth integrations are now proactively swept and refreshed before tokens expire — a connected system stays connected, without anyone re-authorizing.

When we introduced self-healing, Veda watched over the logic behind your apps. Today she does two things she couldn't before, and both are things your customers feel directly.

First, healing is now full-stack. A broken button in the interface and a broken query in the back-end are both Veda's job — she diagnoses and repairs the front-end and the back-end, and she refuses to call anything "healed" until she has re-run the exact broken path in a real headless browser, clicking through the live UI the way a person would. No render check quietly passing off a data bug as fixed.

Second, Veda now practices Recursive Self-Improvement: she measures her own effectiveness every cycle, learns a reusable playbook from every confirmed fix, and gates every change to her own logic against a test set that only grows — so she can get sharper, but never dumber.

What's new

Full-stack self-healing.

Veda now repairs the front-end interface and the back-end logic, opening a reviewed pull request for each — not just server-side fixes.

Verified in a real browser.

Before any fix is marked healed, Veda re-runs the exact failing path headlessly and drives the live UI with computer-use. "Verified" always means proof, never a guess.

Veda IQ.

Every cycle she scores her own autonomous-resolution rate, false-heal rate, re-open rate, and time-to-fix, and snapshots the trend — so her effectiveness is measured, not assumed, and visible run to run.

She can never make herself dumber.

Any change to Veda's own brain must clear an immutable gold set of tests that only grows. Capability ratchets up; a regression is blocked before it can ship.

Learns from every fix.

Confirmed heals and human corrections become reusable playbooks injected into future diagnoses — the platform compounds its own hard-won experience.

Why it matters

The benefit isn't abstract. It's instant, reliable support: because Veda covers the whole stack, proves her work, and gets better every week, most issues are found and fixed before anyone opens a ticket — and the fixes that land are the fixes that actually hold.

This is the difference between a code generator and a platform. Veda is the only AI teammate that maintains the software she built, across the full stack — and steadily sharpens herself while she does.

Software breaks. An integration changes a field, a report stops aggregating, an edge case slips through. On every other platform, that's the moment you file a ticket and wait. On Intuist, it's the moment Veda goes to work — usually before you've even noticed.

Veda watches over every published app around the clock. When something misbehaves, she diagnoses the failure against your live integration data — not a guess from a log line — writes the fix, opens a pull request, runs a fail-closed smoke test, re-runs the exact path that was broken to prove the fix actually works, and ships it. For the everyday, reversible fixes, no human ever touches the code.

What makes it different

Always on.

Veda monitors every published app, 24/7. Most issues are resolved before a ticket is ever filed — you often find out from the resolution email, not the complaint.

Diagnoses against ground truth.

Veda probes the app's live, connected system for the real schema, values, and counts before she changes a line — so she fixes the actual bug, not a plausible-looking guess.

Honest by design.

She re-runs the exact failing path before she claims success. A render check can never pass off a data-correctness bug as "healed" — if she can't prove the fix, she escalates to a human instead of declaring victory.

She improves herself.

When Veda learns a better way to build, she rewrites her own planner and coder — gated by a fail-closed test suite — then pulls the new code and restarts. The platform that maintains the platform.

Human on every irreversible gate.

Reversible fixes ship autonomously. Anything touching taste, access, or security routes to a one-tap human approval. Autonomy where it's safe, judgment where it counts.

Speaks plain English.

When a fix lands, the customer gets a clear, jargon-free note — bottom line first. No SHAs, no file paths, no PR numbers. The technical detail lives on the ticket, where it belongs.

Why it matters

An app you build here isn't a document you generate once and forget — it's a working application that lives in the real world, against real integrations that change underneath it. Veda is what makes shipping one feel safe: the software she built has its builder keeping it healthy, and she gets sharper every week.

This is the difference between a code generator and a platform. Veda is the only AI teammate that maintains the software she built — and the platform she runs on.

For facilities teams and the contractors who serve them, ServiceChannel is where the work lives — every work order, proposal, and job update flows through it. Today it connects to Intuist with a single click, the same way you connect Google or Microsoft, and your apps can work the jobs alongside you.

We built it the right way: Intuist is a registered ServiceChannel application, so your team signs in and authorizes us directly — no API keys to paste, no credentials changing hands. Connect once, and every visitor to your app works against your live ServiceChannel data.

What's in the box

One-click connect.

OAuth sign-in with your ServiceChannel account — secure, standards-based, no keys to copy around. The same click-to-connect you already know from Google and Microsoft.

Your work orders, in plain English.

Pull the work orders assigned to you straight from ServiceChannel and triage, prioritize, and act on them inside your app — instead of living in email and the portal.

Owned by Intuist, not bolted on.

We run our own registered ServiceChannel app, so this is a first-class platform integration every customer can switch on — not a one-off script.

Where this is heading

We're launching with Statewide Construction and CMIT Solutions, and the full job round-trip is right behind it: submitting proposals back to ServiceChannel, accepting and declining work, and keeping job status in sync — so a single app runs the whole lifecycle, conversationally. The Work Order Kanban moves onto this pipe next, pulling jobs directly from ServiceChannel instead of email.

When a partner brings a system their business runs on, we make it a platform capability for every customer — often within days. ServiceChannel is the latest, and there's a lot more coming.

Some apps hold the confidential stuff — contracts, financials, case notes, member data. For those, an emailed code isn't always enough. Today any private app can require multi-factor sign-in: a rolling 6-digit code from Microsoft Authenticator, Google Authenticator, 1Password, or any standards-based app.

It's deliberately not SMS — which can be intercepted — and there's no proprietary scheme to learn: it's standard TOTP, so it works with whatever authenticator your team already trusts. Builders turn it on with one toggle, and the platform enforces it on the server before the app is ever delivered. It is not a screen a determined visitor can skip.

What's in the box

One toggle.

Go Live → Restricted → "Require authenticator app (MFA)." No code, no configuration — the platform runs the whole flow.

Any authenticator.

Verify email once, scan a QR into Microsoft / Google Authenticator, 1Password, or Authy, and you're enrolled. Standard TOTP, no lock-in.

Rolling codes, replay-proof.

Sign-in needs the live code from the phone; a used code can't be reused, and repeated failures lock the attempt.

Enrollment alerting.

The moment an authenticator is set up, the user and the app owner both get an email — a surreptitious setup is caught in seconds.

A secure template.

"The Vault" ships authenticator-gated out of the box — a confidential client workspace with a live security activity timeline.

Where this is heading

Authenticator codes are the right step today, and we're honest about the next one: for credentials that genuinely cannot be copied or shared — bound to a device, immune to phishing — the answer is passkeys and hardware keys (FIDO2 / WebAuthn). That's on the roadmap, alongside sealed credentials with zero standing access to your integration keys, and least-privilege Microsoft 365 consent.

Security is a founding principle here, not a feature tier. When a partner raises a security need, it becomes platform capability for every customer — often within days.

If you're an MSP, Pax8 is your supply chain: it's where Microsoft 365 seats get bought, security stacks get provisioned, and the month's margin quietly lives or dies in subscription line items. Today it becomes part of your apps.

Connect your Pax8 partner account to any app and it works against the live Partner API: look up client companies, browse the catalog with your real partner pricing, check what every client is licensed for, adjust seat counts, place orders, and read invoices down to the line item — in plain English.

What's in the box

Clients & subscriptions.

Every client company and everything they're licensed for — quantities, terms, status — straight from the live marketplace.

Catalog with YOUR pricing.

Products and partner rates per billing term, so quoting and margin questions get real numbers, not list prices.

Seat changes & orders.

Adjusting license counts is the everyday move — it's a first-class action, and anything that moves money is confirmed with you before it moves.

Invoice intelligence.

Invoices and line items are readable by your apps — pair with your PSA to reconcile billing automatically and catch margin leaks.

Validated on connect.

We probe the live API the moment you save your API client — you see a real ✅ or the actual upstream error.

The MSP trifecta

Pax8 sits alongside ConnectWise Manage and Kaseya BMS as a first-class integration. That means one app can see the ticket, the agreement, and the license behind a request — your service desk, your billing, and your supply chain finally speaking the same language. "Acme added five people this month — are their M365 seats, their agreement, and their invoice all in step?" is now one question, not three consoles.

And you don't have to start from scratch: the Pax8 Marketplace Copilot template ships today — connect your partner account and you have a conversational dashboard over clients, licenses, partner pricing, and invoices in minutes.

If you run a managed-services practice, your tickets rarely live in just one place. Maybe your techs work in one PSA while a partner, a master MSP, or an acquired team runs another — and keeping the two in sync is somebody's least favorite job. Today that somebody can be an app Veda builds for you.

Kaseya BMS is now a first-class integration on the Intuist platform, sitting alongside ConnectWise Manage. Connect a BMS tenant to any app and it can search tickets, pull full ticket detail, post updates, and resolve tickets with a closing note — all against the live BMS v2 REST API.

What's in the box

Full ticket access.

Search, read, create, and update tickets in your live BMS tenant — no exports, no stale mirrors.

One-step resolve.

Close a ticket with its resolution note in a single action, so status and context land together.

Validated on connect.

Enter your tenant and a dedicated API service account, and we probe the live API the moment you save — you see a real ✅ or the actual error, never a silent misconfiguration.

Plays well with ConnectWise.

Pair both PSAs in one app to keep tickets in step across systems — close it in one, and the matching ticket resolves in the other, note included.

Why it matters

Cross-PSA drift is more than an annoyance — it's missed SLAs, noisy KPI alerts, and partners chasing tickets that were finished a week ago. An app watching both sides turns that standing chore into something that just happens, with every action logged and reviewable.

Connecting Salesforce to a tool has always been a project. A connected app. A client secret. Scopes, a security review, a callback URL, and — inevitably — a Slack to your Salesforce admin that sits unanswered for three days. By the time you're connected, the momentum that made you want to build something is gone.

We just deleted that entire detour. Salesforce is now a one-click integration in every app. Open any app's integrations panel, click Connect Salesforce, approve on the standard Salesforce screen, and you're live on your real org — opportunities, accounts, leads, custom objects, all of it. No app to register. No keys to paste. No admin in the loop.

How it works

Click Connect.

Pick Salesforce in any app. Nothing to register, nothing to configure.

Approve in Salesforce.

The standard OAuth screen — sign in, approve, done. Scoped to read and write your data through the API.

Build on live data.

Query opportunities with SOQL, update deals, create leads. Grounded in your real CRM — not a stale CSV you re-export every Monday.

It works across orgs, too

The same one-click flow connects your org and your customer's — with zero setup on our side. Under the hood it's a packaged, org-dependent connector with PKCE, so agencies, MSPs, and anyone building for clients get the same frictionless connect across every org. No per-customer engineering, no copies of a connected app floating around.

Meet the first app built on it: Pipeline Pulse 📈

To show what "live CRM in twenty seconds" actually unlocks, we built Pipeline Pulse — this week's Template of the Week and the newest member of our Pulse family (sibling to AI Pulse). Connect Salesforce and it turns your pipeline into a daily heartbeat:

A morning briefing

— what closed, what slipped, which deals went quiet, and the three calls to make today.

An at-risk radar

— overdue close dates, deals pushed twice, accounts gone silent — ranked by what it'll cost you.

Ask anything

— "Q3 pipeline by stage," "stuck deals over $20k," "Acme's open opps" — answered from your live data, no saved searches.

One-tap action

— draft the follow-up, log the next step. You stay in control; nothing sends without you.

Publish your app, flip one toggle, and end-users can install it on macOS, Windows, iOS, or Android. One click. The app lands on the dock or home screen with its own icon and launches in its own window — no browser tabs, no address bar, no chrome. Same app you built, but now it has a permanent home alongside Slack, Notion, and Linear.

How it works

Flip the toggle.

In Go Live → App Icon, enable "Make this app installable." Off by default — install is opt-in per app.

Pick (or generate) an icon.

Open the App Icon Studio: use the auto-generated default, upload your logo, or let AI render three on-brand variants.

End-users install in one click.

A floating Install pill appears on your published app. Click → native OS install dialog. Done.

Launches like a real app.

Standalone window, dock icon, your branding throughout. No browser chrome — just your app.