Assist is a platform where teams can build, host, and deploy internal AI software and agents in one place — giving companies a safe, controlled environment to standardize workflows and improve operations.

What are sandcastles?

Sandcastles are purpose-built internal apps created by non-technical teams on the Assist platform. They allow employees to build custom tools and workflows without engineering resources.

How much does Assist cost?

Assist uses pay-as-you-go pricing: provider costs + 5%, $0.17 per 1k tool calls, with no seat fees. Enterprise custom pricing is also available.

Do we need engineers to use Assist?

No. Assist is designed for non-technical teams to build and deploy AI tools. Engineers can use it too, but it doesn't require engineering resources to get started.

Playbook: Build a Campaign Launcher for Your Internal Ad Platform

Your company runs an internal demand-side platform for buying and managing ad campaigns. The ad ops team lives in it every day, but account managers -- the people who actually need to launch campaigns for clients -- cannot use it without hand-holding. Every campaign launch involves a back-and-forth: the account manager describes what they want, ad ops configures it, the account manager reviews, ad ops adjusts, and eventually it goes live. This playbook walks you through building a self-service campaign launcher that account managers can use directly, all from inside Claude Desktop or ChatGPT.

What you will build

By the end of this playbook, you will have:

Custom tools that connect to your DSP's API for creating campaigns, setting targeting, checking budgets, and pulling performance data
A sandcastle app where account managers can configure campaigns, preview reach estimates, and submit for launch
Built-in guardrails so account managers cannot exceed budget caps, skip required fields, or misconfigure targeting
An approval workflow where ad ops reviews submissions before they go live
Persistent state that tracks campaign history, approval status, and performance snapshots

What you need before you start

An Assist workspace with an MCP server set up. If you have not created one yet, follow Creating an MCP server.
Your AI client connected to the MCP server. See Connect your client.
Access credentials for your DSP's API. You will need the base URL, authentication method, and any API keys or tokens.
An understanding of the campaign creation workflow: what fields are required, what targeting options exist, what budget rules your company enforces. If you are not sure about all of them, that is fine -- you will discover the details as you build.

Step 1: Map out the campaign workflow

Before building anything, talk through the workflow with your AI client:

"I want to build a campaign launcher for our internal ad platform. Here's how campaigns work today: account managers fill out a brief with client name, campaign objective, target audience, budget, flight dates, and creative assets. Ad ops takes that brief and configures the campaign in our DSP. There's a review step before launch. The DSP API is at https://dsp.internal.company.com/api and uses OAuth2 client credentials."

"The main API resources are campaigns, audiences, creatives, and reports. A campaign has a name, objective (awareness/traffic/conversions), audience_id, budget_daily, budget_total, start_date, end_date, and status. Audiences have targeting rules like geography, age range, interests, and device type."

The AI will help you identify which tools to build and in what order. Let it ask questions -- it will surface things you might not have thought of, like error handling for invalid date ranges or what happens when a budget exceeds the client's contract.

Step 2: Build the DSP tools

Start with the read operations so you can explore your data:

"Create a tool called 'list_audiences' that returns all available audience segments from our DSP. Include the audience name, size estimate, and targeting summary."

"Create a tool called 'estimate_reach' that takes an audience_id, daily_budget, and date range, and returns the estimated impressions and reach from our DSP's forecasting endpoint."

Test each tool as you build it. Look at an audience list. Run a reach estimate. Verify the numbers make sense.

Then build the write operations:

"Create a tool called 'create_campaign' that takes campaign_name, objective, audience_id, budget_daily, budget_total, start_date, end_date, and creative_ids. It should create the campaign in draft status -- not live. Return the campaign_id and a summary."

"Create a tool called 'submit_campaign' that takes a campaign_id and changes its status from draft to pending_review."

"Create a tool called 'get_campaign_status' that returns the current status, budget spent, impressions delivered, and any warnings for a given campaign_id."

Build the guardrail logic into the tools themselves. For example, the create_campaign tool should reject requests where daily budget exceeds your company's cap, where the end date is before the start date, or where required fields are missing. This way the guardrails are enforced regardless of whether someone uses the app or calls the tool directly.

"Update the create_campaign tool to enforce these rules: daily budget cannot exceed $5,000, total budget cannot exceed $100,000, campaign duration must be at least 3 days, and objective must be one of awareness, traffic, or conversions. If any rule is violated, return a clear error message explaining what's wrong."

Step 3: Build the campaign launcher app

Now build the sandcastle app that account managers will use:

"Build me a sandcastle app for launching ad campaigns. It should have these views:

Campaign builder: A step-by-step form with these steps:

Step 1: Client name, campaign name, objective (dropdown: awareness/traffic/conversions)

Step 2: Audience selection -- show available audiences as cards with name and size. Let the user select one.

Step 3: Budget and schedule -- daily budget, total budget, start date, end date. Show a warning if daily budget is high relative to total.

Step 4: Review -- show a summary of everything. Display the estimated reach (call the estimate_reach tool). Show a 'Submit for Review' button.

Campaign list: A table of all campaigns this user has created, with status (draft/pending_review/approved/live/paused/completed), budget, dates, and performance metrics if live.

Campaign detail: Click a campaign to see full details, status history, and performance data."

The AI will scaffold this as a multi-view React application. Review the preview and iterate:

"On the audience selection step, add a search/filter bar so account managers can find audiences by name. Also show the targeting summary for each audience -- geography, age range, interests."

"On the review step, add a cost projection section that shows estimated total cost based on the daily budget and duration. Highlight it in yellow if total cost is within 10% of the total budget cap."

"Add form validation to the budget step. Daily budget must be a number greater than 0. Total budget must be greater than daily budget times the number of days. Show inline error messages, not alerts."

Step 4: Add the approval workflow

Account managers should not be able to launch campaigns directly. Build an approval layer:

"Add a collection called 'campaign_submissions' that tracks each submission with campaign_id, submitted_by, submitted_at, status (pending/approved/rejected), reviewer, reviewed_at, and reviewer_notes."

"When an account manager clicks 'Submit for Review', create a record in campaign_submissions with status 'pending' and call the submit_campaign tool to move the campaign to pending_review in the DSP."

"Add an 'Approvals' view that shows all pending submissions. This view should have approve and reject buttons with a notes field. When approved, call a new tool called 'approve_campaign' that changes the campaign status to live in the DSP."

Now ad ops has a single place to review pending campaigns. Account managers see the status of their submissions update in real time.

Step 5: Add performance tracking

Once campaigns are live, account managers want to see how they are doing:

"Create a tool called 'get_campaign_performance' that returns impressions, clicks, conversions, spend, and CPM/CPC/CPA for a given campaign_id and date range."

"In the campaign detail view, add a performance section that shows a chart of daily spend and impressions over the campaign flight. Below the chart, show a metrics summary with total spend, total impressions, average CPM, and pacing (on track / underspending / overspending compared to the daily budget)."

"Add a 'Performance' tab to the main navigation that shows a table of all live campaigns with their key metrics, sorted by spend. Add sparkline charts for each row showing the daily trend."

Step 6: Wire up notifications

Build a tool that posts to Slack when key events happen:

"Create a tool called 'notify_slack' that posts a message to our #ad-ops Slack channel. Use it to notify when: a new campaign is submitted for review, a campaign is approved or rejected, or a live campaign is pacing more than 20% over or under budget."

"Add a scheduled check using a subagent that runs every morning. It should pull all live campaigns, check pacing against budgets, and post a summary to Slack with any campaigns that need attention."

This is where agents come in. The pacing monitor runs in Assist on a schedule -- it does not depend on anyone having their AI client open. It checks every live campaign, compares actual spend to expected spend, and flags problems before they become expensive.

Step 7: Share with the team

Share the sandcastle app URL with your account managers. They open it in a browser and start building campaigns immediately. They do not need an MCP connection to use the app -- the app talks to the tools through Assist.

For account managers who prefer conversational access, they can connect their AI client to the MCP server and create campaigns through conversation:

"Create a new campaign for Acme Corp. Awareness objective, target the 'US Adults 25-54' audience, $2,000 daily budget, $30,000 total, running June 1 through June 15."

The tools enforce the same guardrails whether used through the app or through conversation.

Step 8: Iterate based on usage

As account managers use the system, they will request changes. Handle them conversationally:

"Add a 'duplicate campaign' button that copies all settings from an existing campaign into a new draft with a new name."

"Add a field for 'campaign notes' that account managers can use to explain the campaign strategy. Store it in the submissions collection."

"The budget step should show remaining budget from the client's quarterly contract. Create a tool that pulls contract budget data and subtract spend from existing campaigns."

Each request is a conversation. Each change is versioned. The app evolves without anyone writing a deployment pipeline.

What you built

You now have a complete campaign management system:

Tools that wrap your DSP's API with built-in guardrails and validation
An app where account managers configure, submit, and track campaigns without touching the DSP
An approval workflow where ad ops reviews and approves campaigns before they go live
Performance tracking with charts, pacing alerts, and a scheduled monitoring agent
Slack notifications for key events and budget warnings

Ad ops went from manually configuring every campaign to reviewing and approving them. Account managers went from filing briefs and waiting to launching campaigns themselves within the rules your company set. The whole thing runs in Assist -- managed, versioned, and auditable.