Build an AI agent that markets your app

You shipped the app. Now you need people to care.

Your coding agent already knows the product. It can read the onboarding, find the useful features, take screenshots and generate assets. Give it publishing tools and a record of what happened, and it can help run your acquisition experiments too.

The useful version is a small loop: find an angle, make a post, publish it, measure it, choose the next test. Here is how to build that loop around TikTok slideshows, with TokPortal handling accounts and publishing.

Before connecting anything, look at these two real carousels.

This relationship carousel recorded 1,720,338 views in its July 28, 2026 analytics snapshot. Ordinary photos. Short white captions. An idea you can understand while half paying attention.

This fitness carousel recorded 2,307,221 views in its July 27, 2026 snapshot. The exercise illustrations carry the explanation. Each slide gives you another reason to swipe.

These are original creatives paired with stored TokPortal analytics, with account identities removed. They are historical examples, not outputs of the agent we are about to build.

Give your agent references like these and ask it to identify the mechanics: the opening tension, what each swipe adds, the visual rhythm, and where an app could naturally enter the story. Then create an original version for your product.

For this tutorial, imagine a study app that turns notes into quizzes. Its useful promise is specific: find out what you cannot recall before the exam. That gives us better material than “the future of AI-powered education.”

Open the project in your coding agent. Start with the README, onboarding screens and the feature you want to sell. Add a few screenshots from a demo account.

Ask it to distinguish features that work today from roadmap ideas. A convincing caption about something your app cannot do is an expensive bug.

Read the README and relevant onboarding and quiz-generation screens. Create a product brief for marketing this app to US college students.

List the user's frustrating moment, the working feature that helps, three concrete demonstrations, and claims we can support. Flag anything that exists only in the roadmap. Use demo data for screenshots. Do not read secrets or customer exports.

Write five slideshow angles using the user's language. For each, explain why someone would swipe and what action we want them to take.

A useful result might look like this:

• Frustration: “I reread the chapter three times and still blanked.”
• Demonstration: turn one page of notes into five questions, then show the missed answers.
• Hook: “Your notes look finished. Can you answer from memory?”
• Next action: try a quiz with your own notes.

Keep the brief short enough to read before every creative batch. Update it when the product changes.

Four small files are enough to start:

• product.md: audience, working features, proof and product screenshots.
• creative-rules.md: voice, visual references, banned clichés and examples worth studying.
• experiments.csv: experiment ID, account, hook, format, asset paths, post link and dated results.
• run-log.md: what the agent attempted, what succeeded and what needs checking.

These are your files, not a TokPortal requirement. Their job is to let tomorrow's session continue today's work. When the agent “learns,” it updates this record and its next brief. It is not retraining the model.

Use an agent host that supports a remote MCP server. Add TokPortal's endpoint:

https://app.tokportal.com/api/ext/mcp

Complete the OAuth sign-in in your host, then ask the agent to inspect the available tools and read your account list. The connection guide includes setup instructions for supported clients, including Claude Code.

Keep that first request read-only: “List my TikTok accounts, their country and status, and tell me which are available for this experiment.” You should see your real workspace before asking it to create anything.

Connect image generation separately. TokPortal handles the account and publishing workflow; your agent's image tool creates the artwork. The local filesystem holds the finished assets and experiment history.

You do not need to memorize API calls. These are useful names to recognize when inspecting an agent's work:

• tokportal_generate_warming_terms: prepare niche search terms.
• tokportal_upload_image_direct: upload a finished slide.
• tokportal_configure_bundle_video: configure a post slot, including a carousel.
• tokportal_get_bundle_publish_readiness: check what still blocks submission.
• tokportal_get_analytics_contract: discover which metrics and sources are available.
• tokportal_get_analytics_dashboard: read the available performance data.

Ask the agent to simulate the account and post setup with dry_run: true. TokPortal's sandbox validates the request and returns the estimated charge without creating the work.

Have it show you credits_would_charge, the account country, the post quantity and any warming options. Bundle creation is the charging step, so check the plan before the live creation call.

Dry-run a US TikTok account setup with five initial slideshow slots and Advanced Niche Warming. Show the price returned by the server and explain any validation errors. Do not execute the paid setup until I approve the plan.

Use the remote MCP endpoint for this tutorial. If you use a local installation, dry-run forwarding requires tokportal-mcp 1.15.1 or later.

One subtle detail: simulated IDs are not real resources. The sandbox also does not remember a simulated object's earlier configuration. It is useful for checking requests, prices and errors; your live run still needs to read back the resources it creates. Sandbox reference.

For the study app, start with searches such as “active recall for college,” “how to study for finals” and “practice questions from notes.” Ask TokPortal's term generator to refine the set before configuring Advanced Niche Warming.

The example above comes from a real recorded warming session in the expense-tracking niche. Use the recordings to inspect whether the chosen searches lead to the kind of content you intended. Adjust vague terms before repeating the setup across more accounts. Warming reference.

Start with a five-slide draft. For our study app:

1. Hook: “Your notes look finished. Can you answer from memory?”
2. Problem: a page covered in highlights, with one short observation about rereading.
3. Small test: close the notes and answer three questions.
4. Product demonstration: a real screenshot showing notes turned into a quiz.
5. Payoff: show the missed topics and invite the reader to try their own notes.

Let the image model produce a desk scene or supporting visual. Capture the app itself from a demo account. Then assemble and inspect every slide at phone size.

Use real type for the final text layer. TikTok Sans is available through Google Fonts. A saved template makes wrapping, outlines and placement repeatable. Image generation is useful for creative exploration; a renderer gives you exact words every time.

Keep it native: ordinary imagery, short captions, readable contrast. Skip glossy pitch-deck layouts, fake testimonials, sexualized bait and AI people with broken anatomy. Leave room for the platform controls.

Create this five-slide study-app carousel. Use original everyday imagery and real demo screenshots. Keep one idea per slide. Make the opening readable at phone size and let slide four demonstrate the working feature.

Export the numbered slides and a contact sheet. Check spelling, text wrapping, safe areas and whether every swipe adds something. Show me the preview before uploading.

Save an experiment ID such as study-recall-001 beside the assets. Record the hook and format before publication. Otherwise you will have views next week and no reliable memory of what you tested.

The agent uploads the slides, configures a post slot, checks readiness and submits the bundle. The real TokPortal editor shows the same content choices visually:

There is one useful upload detail to put in your agent instructions: carousel slides use the returned storage_path. Do not substitute the public image URL. Video configuration uses a public URL instead. The upload guide documents that distinction.

Ask the agent to keep each experiment linked to its bundle, post slot and final delivery link. Save the confirmed configuration after submission, not just the schedule it originally requested.

The bundle publish endpoint submits configured work for processing. It does not mean the post has appeared on TikTok.

The scheduling field target_publish_date starts a two-day publication window. It is not an exact posting time. Currently, the earliest date is today plus three days for a new account still being created, or today plus one day for a delivered account, using UTC date comparisons.

Old target dates can be moved forward during submission. Have the agent read the returned adjustments and write the final window into the experiment record. See the publication reference.

The labels above are a suggested ledger for your agent, not TokPortal's API status names. Move an experiment to “Live verified” only when the delivery evidence supports it.

• Invalid date: read the earliest allowed date in the response, adjust the plan, then validate again.
• Capacity cooldown: respect the returned limit and retry guidance. Do not keep creating replacement bundles.
• Timeout after a write: inspect the existing resource before repeating the operation. A lost response does not mean nothing happened.
• Missing asset: repair that upload or configuration and preserve the experiment ID.

Tell the agent to stop and report unresolved states. Ten copies of a post are not a successful retry strategy.

First ask for the analytics contract. Availability depends on the account, plan and data source. Store the capture date and source with every observation, and leave unavailable metrics blank instead of converting them to zero. Analytics reference.

Then compare posts at similar ages. A post from yesterday and one from six weeks ago are different observations.

Review the experiments with available analytics. Group them by hook and format, comparing similar time since publication where snapshots allow it. Show the sample size, median views and standout posts separately.

Explain what the creative and comments suggest. Propose three new tests, each changing one main variable. Do not label missing metrics as zero or treat views as app installs. Update the experiment file with dated observations.

For the study app, useful next moves might be:

• People respond to the opening but ask what the app does: make the product demonstration clearer in the next version.
• Several posts about exam panic outperform generic study tips: test another concrete exam situation with a new visual treatment.
• Posts get reach but little measurable app activity: inspect the offer, landing page and path from profile to product.

Those are decision examples, not reported results. Track app visits, signups and activation in your own product analytics wherever attribution is available. A million views is useful information; it does not tell you how many people completed their first quiz.

Complete one full cycle first: approved creative, submitted work, verified delivery, recorded result.

Then try five accounts with distinct editorial angles. For our study app: exam panic, active-recall demos, common study mistakes, before-and-after workflows and course-specific examples. Start with five posts per account, 25 initial posts in total. On a smaller budget, start with two accounts.

Keep making original posts. Reuse a promising structure while changing the situation, imagery and demonstration. Uploading the same slideshow everywhere teaches you very little.

Plan around one or two posts per account per day over at least 40 days, subject to the actual delivery windows and capacity. Five accounts at one post per day means 200 posts over that period. The initial 25 are the first batch, not the whole experiment.

Once the loop works, use your agent host's scheduler to run the recurring review. Connecting MCP alone does not create an always-running agent. Specify when the host should wake up, what it may spend, which accounts it may use and when it must stop for review.

You can extend the same workflow to genuine comment questions through TokPortal's commenting tools. Answer as your own account and keep affiliation clear. For a post you want to promote, request a Spark code as a separate step before setting up the ad campaign.

Build a small marketing workflow for this app using the product repository, local creative files, my image-generation tool and TokPortal MCP.

Start by writing the product brief and experiment ledger. Read my available accounts. Propose three original slideshow concepts, then render one for review. Dry-run paid setup and show the returned cost before requesting approval.

After approval, preserve the experiment ID through upload, configuration and submission. Read back the publication window and track delivery separately from submission. Never repeat an uncertain write without checking its state.

When analytics are available, record their dates and sources, compare similar-age posts and propose the next three tests. Keep app activation separate from social reach. End each run with what happened, what is blocked and the next action.

Start with one post you would be happy to publish yourself. Get it through the whole loop. The useful automation grows from there.

Documentation checked September 9, 2026. The study app and proposed workflow are illustrative; the two anonymized carousel examples use original media and dated stored analytics.