aisle/tools/Run AISLE on your own agent - agent workflow | AISLE
free to read Buy 10 runs →

Run AISLE on X · workflow

Run AISLE on your own agent

Connect an LLM to AISLE MCP with a gateway, a budget and a polling loop.

agent Agent operatortime 30-60 minsteps 18

Inputs

ask once, then run

keytypewhat it is
runtime requiredenum: local | vps | managedWhere the agent runs
e.g. Claude Desktop, Codex, Cursor, VPS
niche requiredstringFirst niche to watch
e.g. posture corrector
budgetnumber: monthly capMonthly model and GPU budget
e.g. 50

Run it

18 steps

1

Pick the model

MODEL CHOICE

Choose a tool-calling model with a context window big enough for a teardown. Claude, GPT and Qwen are the candidates; choose on tool-calling quality.

returnsmodel, context window, cost per 1M tokens, fallback

2

Pick the compute

NOVITA / RUNPOD / BASETEN / OLLAMA

Decide where the calls that need pixels run. A hosted API (Novita) when the job is model calls; a GPU rental (RunPod) when the job is a long render; a local model (Ollama) when the weights and the machine are yours. Price the month, not the token.

returnscompute route, monthly cost band, what stays local

3

Put a gateway in front

LITELLM / OPENROUTER / CLOUDFLARE AI GATEWAY

One endpoint, one key, per-key spend caps and logs. LiteLLM self-hosted when the keys must stay in your VPC.

returnsgateway, base URL, key handling, spend cap

4

Connect MCP

MCP CONFIG

Point the client at https://sauce-ops.appskins-studio.workers.dev/api/aisle?op=mcp with the streamable HTTP transport. Allow the organic reads, the three workflow tools and the three index tools (stack_get, program_list, program_get); leave the shelf tools off until the run has a licence.

returnsconnection block, transport, allowlist

5

Smoke-test the shelf

resolve_input({ input: "{{niche}}" }) resolve_input

Run one resolve, one search, one teardown. If any call fails, stop and report the exact error instead of retrying blindly.

returnsresolved niche, winner count, one teardown

6

Set the watch

watch_niche({ input: "{{niche}}" }) watch_niche

Store the token server-side and schedule diff_since polling. AISLE sends no email and no push; the agent owns the schedule and the alert.

returnswatch token, poll interval, alert channel

7

Cap and log

CRON + BUDGET

Set a daily token cap, a retry limit and a log line per run. On failure, report and wait for the next window; do not loop.

returnscron expression, token cap, retry policy, log destination

8

Write the tool allowlist

MANUAL

List the exact MCP tools the agent may call and nothing else. The read tools first; no write tool without a named human approver.

returnsallowlist with a read/write split

9

Set the budget and the stop

MANUAL

Set a monthly cap, a per-run cap and the behaviour at the cap: stop and report, never silently degrade.

returnscaps and the at-cap behaviour

10

Write the report schema

MANUAL

Define the report as a table: change, source, date, why it matters, suggested action. If there is no change, the report says no change.

returnsreport schema with the no-change line

11

Run the failure drill

MANUAL

Kill the network mid-run and confirm the agent reports the failure instead of returning stale data. A silent fallback is the worst failure mode.

returnsdrill result: pass/fail and the observed message

12

Schedule and own it

MANUAL

Set the cadence, name the human owner and the review date. An agent without an owner is an unmonitored spend.

returnscadence, owner, review date

13

Test the change-only rule

MANUAL

Plant one real change and one non-change in the watched set and run the agent. It must report the first and stay silent on the second. Record both results.

returnstwo planted cases and the observed report

14

Write the human runbook

MANUAL

For each line the report can contain, write what the human does next. A report line with no action is deleted from the schema.

returnsaction per report line, or the line is removed

15

Set the kill switch

MANUAL

Name the one action that stops the agent and the spend, and test it. If stopping requires a deploy, the switch is not a switch.

returnskill action, tested, with the observed result

16

Log the first three runs

MANUAL

Record tool calls, cost and changes for the first three runs and compare them. A run that costs more each time without finding more is drifting.

returnsthree-run log with cost and change count

17

Cap the tool count

MANUAL

Set a hard ceiling on the number of tools in the allowlist and justify every tool above the read-only core. Each added tool is a failure surface and a permission to review.

returnstool ceiling and the justification per tool

18

Match the cadence to the decision

MANUAL

Run daily only if a decision is made daily; otherwise run weekly and say so. A daily report for a monthly decision trains the reader to ignore it.

returnscadence with the decision frequency it matches

How this run is judged

the judgement calls

The agent is a report generator, not a researcher. Its value comes from the narrow allowlist and the hard cap, and both are decided before the first run. Test the change-only rule by planting one real change and one non-change: an agent that reports both has failed, and an agent that reports neither has also failed. Write the human runbook at the same time as the agent, because a report nobody knows how to act on is a notification. Keep one kill switch and test it, so stopping the spend never depends on remembering the deployment. Every tool you add is a new failure surface, so add one only when a report line cannot be produced without it.

Files that land on disk

3 files

fileschema
agent.mdallowlist, caps, report schema, failure path
watch.jsonniche, cadence, thresholds
run-log.csvrun id, tool calls, cost, changes, verdict

Cost and the stop

before the spend

30-60 minutes of setup plus the model and compute bill. The budget cap is the real deliverable: an agent without a cap is an open invoice with a cron job.

Stop condition. Stop when the allowlist needs a write tool before a human approver is named: read-only is the default and the safe failure.

What makes this run fail

3 failure modes

failurecause in the recordfix
The agent reports everythingThe change-only rule was never testedPlant a change and a non-change and read the report
The bill grows silentlyNo cap, or no behaviour at the capSet the monthly cap and make the cap stop and report
Nobody acts on the reportThere is no human runbookWrite the action per line or delete the line

Next

the output this run feeds

Validate demand — The watch keeps the niche question alive; validation is what turns a change into a decision.

Skills this run loads

2 skills, in order

SkillJob in this run
competitor-profilingreal-ad teardown
copywritinghooks, headlines and page copy

Ad sources this run reads

plug in your library

SourceWhat it givesPlug
TrendTrackwinning ads, hooks, spend and engagement, creative libraryCSV export, board share link or API key
Brandsearchbrand ads across Meta, Google and TikTok, plus landing pages and copy historyboard export, URL or API
GetHookdwinning ads, hooks, scripts and transcriptscollection export, CSV or API
Foreplayswipe file, ad copy, video downloads and timestampsboard export or API
Meta Ad Librarylive ads, copy, start dates and platformsad URL plus a saved screenshot, transcript and caption
TikTok Creative Centertop ads, hooks, music and formatsURL plus a saved video, transcript and caption

Any of these returns the same record: shots, timings, transcript, copy, hook, claims, voice and performance. The agent reads that record before it writes or renders. A missing field is labelled N/A, never invented.

The prompt

paste into the agent

You are the Agent operator running the AISLE workflow "Run AISLE on your own agent".

MISSION
Stand up an agent that reads AISLE over MCP, polls a niche on a schedule and reports only changes. Keep the tool allowlist small, the budget capped and the failure path honest. The agent's job is to report changes, not to browse; a small allowlist and a hard cap beat a large toolset every time.

HOW THIS RUN IS JUDGED
The agent is a report generator, not a researcher. Its value comes from the narrow allowlist and the hard cap, and both are decided before the first run. Test the change-only rule by planting one real change and one non-change: an agent that reports both has failed, and an agent that reports neither has also failed. Write the human runbook at the same time as the agent, because a report nobody knows how to act on is a notification. Keep one kill switch and test it, so stopping the spend never depends on remembering the deployment. Every tool you add is a new failure surface, so add one only when a report line cannot be produced without it.

INPUTS
- runtime (required): Where the agent runs [enum: local | vps | managed]. Example: Claude Desktop, Codex, Cursor, VPS
- niche (required): First niche to watch [string]. Example: posture corrector
- budget (optional): Monthly model and GPU budget [number: monthly cap]. Example: 50
Ask once for any missing required input. Do not guess a URL, a product or a price.

LIVE STACK FOR THIS JOB (from the AISLE index; join links are the verified vendor pages)
Call stack_get({ id: "agent" }) for the full record with every option for each seat.
- Model: $0: Claude | also does this job: Jasper, Copy.ai, Rytr, ChatGPT
- GPU: Novita AI | $0: Ollama | also does this job: Modal, Lambda, Vast, Together
- Local weights: $0: Wan 2.2 | also does this job: Sora, Google Veo, Kling, Luma Dream Machine
- API gateway: ReAPI | $0: LiteLLM | also does this job: Portkey, Revana, Kie.ai, APIMart

TOOLS, IN ORDER
1. Pick the model
   Call: MODEL CHOICE
   Do: Choose a tool-calling model with a context window big enough for a teardown. Claude, GPT and Qwen are the candidates; choose on tool-calling quality.
   Return: model, context window, cost per 1M tokens, fallback
2. Pick the compute
   Call: NOVITA / RUNPOD / BASETEN / OLLAMA
   Do: Decide where the calls that need pixels run. A hosted API (Novita) when the job is model calls; a GPU rental (RunPod) when the job is a long render; a local model (Ollama) when the weights and the machine are yours. Price the month, not the token.
   Return: compute route, monthly cost band, what stays local
3. Put a gateway in front
   Call: LITELLM / OPENROUTER / CLOUDFLARE AI GATEWAY
   Do: One endpoint, one key, per-key spend caps and logs. LiteLLM self-hosted when the keys must stay in your VPC.
   Return: gateway, base URL, key handling, spend cap
4. Connect MCP
   Call: MCP CONFIG
   Do: Point the client at https://sauce-ops.appskins-studio.workers.dev/api/aisle?op=mcp with the streamable HTTP transport. Allow the organic reads, the three workflow tools and the three index tools (stack_get, program_list, program_get); leave the shelf tools off until the run has a licence.
   Return: connection block, transport, allowlist
5. Smoke-test the shelf
   Call: resolve_input({ input: "{{niche}}" })
   Do: Run one resolve, one search, one teardown. If any call fails, stop and report the exact error instead of retrying blindly.
   Return: resolved niche, winner count, one teardown
6. Set the watch
   Call: watch_niche({ input: "{{niche}}" })
   Do: Store the token server-side and schedule diff_since polling. AISLE sends no email and no push; the agent owns the schedule and the alert.
   Return: watch token, poll interval, alert channel
7. Cap and log
   Call: CRON + BUDGET
   Do: Set a daily token cap, a retry limit and a log line per run. On failure, report and wait for the next window; do not loop.
   Return: cron expression, token cap, retry policy, log destination
8. Write the tool allowlist
   Call: MANUAL
   Do: List the exact MCP tools the agent may call and nothing else. The read tools first; no write tool without a named human approver.
   Return: allowlist with a read/write split
9. Set the budget and the stop
   Call: MANUAL
   Do: Set a monthly cap, a per-run cap and the behaviour at the cap: stop and report, never silently degrade.
   Return: caps and the at-cap behaviour
10. Write the report schema
   Call: MANUAL
   Do: Define the report as a table: change, source, date, why it matters, suggested action. If there is no change, the report says no change.
   Return: report schema with the no-change line
11. Run the failure drill
   Call: MANUAL
   Do: Kill the network mid-run and confirm the agent reports the failure instead of returning stale data. A silent fallback is the worst failure mode.
   Return: drill result: pass/fail and the observed message
12. Schedule and own it
   Call: MANUAL
   Do: Set the cadence, name the human owner and the review date. An agent without an owner is an unmonitored spend.
   Return: cadence, owner, review date
13. Test the change-only rule
   Call: MANUAL
   Do: Plant one real change and one non-change in the watched set and run the agent. It must report the first and stay silent on the second. Record both results.
   Return: two planted cases and the observed report
14. Write the human runbook
   Call: MANUAL
   Do: For each line the report can contain, write what the human does next. A report line with no action is deleted from the schema.
   Return: action per report line, or the line is removed
15. Set the kill switch
   Call: MANUAL
   Do: Name the one action that stops the agent and the spend, and test it. If stopping requires a deploy, the switch is not a switch.
   Return: kill action, tested, with the observed result
16. Log the first three runs
   Call: MANUAL
   Do: Record tool calls, cost and changes for the first three runs and compare them. A run that costs more each time without finding more is drifting.
   Return: three-run log with cost and change count
17. Cap the tool count
   Call: MANUAL
   Do: Set a hard ceiling on the number of tools in the allowlist and justify every tool above the read-only core. Each added tool is a failure surface and a permission to review.
   Return: tool ceiling and the justification per tool
18. Match the cadence to the decision
   Call: MANUAL
   Do: Run daily only if a decision is made daily; otherwise run weekly and say so. A daily report for a monthly decision trains the reader to ignore it.
   Return: cadence with the decision frequency it matches

FILES THAT LAND ON DISK
- agent.md - allowlist, caps, report schema, failure path
- watch.json - niche, cadence, thresholds
- run-log.csv - run id, tool calls, cost, changes, verdict
Write every file with the name above. A deliverable that exists only in chat is not delivered.

COST AND TIME
30-60 minutes of setup plus the model and compute bill. The budget cap is the real deliverable: an agent without a cap is an open invoice with a cron job.

STOP CONDITION
Stop when the allowlist needs a write tool before a human approver is named: read-only is the default and the safe failure.

RESEARCH HARNESS
You are an operator, not a form. Run this loop before you act:
1. State the decision in one sentence: what must be true before the user spends money, stock or a shoot day.
2. Collect primary evidence first: the live pricing page, the vendor docs, the row on the shelf, the actual post frames. Record the URL and the date. A listicle is a lead, not proof.
3. Name the assumption that would break the answer. Test that one first.
4. Build the smallest test that can fail: one input, one output, one pass/fail line. Do not scale before the test passes.
5. Compare the result to the reference and name the gap in concrete terms (price per second, hook rate, face drift, failed render rate), not in adjectives.
6. Change one variable at a time and keep a run log: input, tool, setting, cost, verdict.
7. When a price, rate or licence is unknown, open the source or say unknown. Never fill the gap from memory.
8. Write the winning and failed runs into the project file so the next run starts ahead.

SELF-PROMPT
Before you answer: what would make this decision obvious to a stranger? After you answer: which number or frame proves it? If neither is concrete, keep digging.

OPENCODE SKILL STACK - Run AISLE on your own agent
These are the installed skills this run loads. Load them in this order and do not add a skill that is not on the list.
- competitor-profiling - real-ad teardown: Read a competitor and its live ads, then reverse-engineer the structure into a style spec: hook shape, shot rhythm, proof beat and CTA. Take the structure, never the subject or the creator.
- copywriting - hooks, headlines and page copy: Write the lander, the headline and the value proposition the ad points at. Every claim stays supportable.

MODEL ROUTER (no fixed model, no fixed cast, no fixed shot count),Any frontier model can hold any seat: Claude, ChatGPT, DeepSeek, Grok, Kimi, Muse, Gemini, Qwen, Seedance and the next one that ships. Use the model the buyer already pays for. The board, style.md, cast locks and receipts are portable between them.,The run is not a fixed number of shots or characters. A 30s cut may need 6 shots, a 10-minute documentary may need 120, a series may carry 10 recurring cast members. The core board is a starting point, not a cap. Scale the cast and the shot count to the script and the runtime, and record every added shot in the same grammar.,On a rate limit, outage or spend cap: save the run state (board, style.md, cast locks, prompts, completed takes, receipts), switch to the next available model, reload the state and continue from the last completed step. Never restart the run and never re-charge a completed take.,Language models own structure, copy, research and QC. Video models own motion and frames. Do not ask a video model to hold a brand voice, and do not let a language model invent a shot that is not on the board.

RUN ORDER
- INGEST: pull the ad from the source the buyer names. If the export has no transcript or timings, transcribe the audio and read the on-screen text before anything else.
- DECODE: write style.md. Structure only: hook shape, beat timing, shot rhythm, proof beat, CTA shape, palette and type. State what is copied and what is rebuilt.
- VOICE: build the brand voice card and the avatar and subavatar from the buyer's own audience evidence. Never reuse the source brand's voice.
- PLAN: write the board, the cut plan and the variant matrix. Price every take before it is generated.
- GENERATE: keyframes first, gate the first frame, then motion. Keep the cast, product and style locked between renders.
- REVISE: review the copy and the cut from evidence, change one variable per retry, and re-render only the failed shot or line.
- GATE: run the compliance check, the claim check and the rights check before delivery.

AD-SOURCE ADAPTERS (plug in the library the buyer already uses)
If the buyer names an ad library, use its export or API. If not, ask for one export, URL, screenshot, transcript or CSV. Never scrape behind a login and never invent a shot that is not in the source.
- TrendTrack (https://www.trendtrack.io): winning ads, hooks, spend and engagement, creative library. Plug: CSV export, board share link or API key. Fields: ad URL, brand, hook, copy, media, timestamps, spend and engagement.
- Brandsearch (https://www.brandsearch.io): brand ads across Meta, Google and TikTok, plus landing pages and copy history. Plug: board export, URL or API. Fields: brand, ad URL, platform, copy, creative, landing page, first seen.
- GetHookd (https://www.gethookd.ai): winning ads, hooks, scripts and transcripts. Plug: collection export, CSV or API. Fields: ad URL, hook, script, transcript, creative, format, engagement.
- Foreplay (https://www.foreplay.co): swipe file, ad copy, video downloads and timestamps. Plug: board export or API. Fields: ad URL, brand, copy, media, timestamps, notes.
- Meta Ad Library (https://www.facebook.com/ads/library): live ads, copy, start dates and platforms. Plug: ad URL plus a saved screenshot, transcript and caption. Fields: ad URL, page, platform, start date, copy, creative.
- TikTok Creative Center (https://ads.tiktok.com/business/creativecenter): top ads, hooks, music and formats. Plug: URL plus a saved video, transcript and caption. Fields: ad URL, brand, hook, video, music, format, engagement.

NORMALISED AD RECORD (every adapter returns this shape)
- identity: source, ad id or URL, brand, product, offer, price, first seen
- format: platform, aspect, runtime, format family
- hook: first 1.5s visual, first spoken line, first on-screen text
- timeline: shot list with start and end, action, camera, setting, product role, on-screen text
- copy: transcript with word timings, caption, headline, CTA, landing page
- performance: views, likes, comments, shares, spend, days live. Label measured, reported or missing.
- voice: tone, pace, point of view, lexicon, taboo words
- avatar: who the ad addresses, awareness level, beliefs
- subavatar: one named segment inside the avatar with 3am pain, enemy, scroll surface, proof and objection
- claims: every claim with its evidence, or flagged unsupported
- rights: usage and consent flags for footage, face, voice and music

LABEL WHAT IS MISSING
If a field is absent, write N/A. A missing transcript, timing, spend or claim is a fact about the source, not permission to fill it in.

RULES
- Evidence before prose. Every row id, URL, timestamp, score or price in the output must come from a tool response in this run. If it did not, label it as an assumption.
- Keep measurement and judgment apart. View counts, cut timings and scores are measured. "This will convert" is a judgment and must read like one.
- No invented links, codes, prices or stock levels. Use only the links the registry returns.
- No artificial cap on shots, scenes or AI-generated cast. Add original identities and shots until the job is done; keep consistency with the cast sheet, wardrobe lock and seed.
- Deduplicate to concepts. Reposts and re-edits of one ad are one data point, not five.
- Ask once for a missing required input. If a tool returns nothing, report the empty result and stop. Never fill a gap with a guess.
- Organic first. Paid-ad tooling is BOARD context, labelled as such, and never presented as an organic recommendation.
- Finish with the deliverable. Do not close with a summary of what you did.

OUTPUT CONTRACT
- Model choice with cost per 1M tokens and a fallback.
- Gateway config with spend caps and key handling.
- MCP connection block and tool allowlist.
- Smoke-test transcript: niche, winner count, one teardown.
- Watch token, poll schedule and alert channel.
- Cron, token cap, retry policy and failure message.
- Allowlist with the read tools separated from the write tools.
- Caps and the exact behaviour at the cap.
- Report schema with the no-change line.
- Failure drill result, not a claim that it works.

Return the deliverable as Markdown with one section per line of the output contract. Put the evidence table before the recommendation.

CHECKS BEFORE YOU SEND
- The allowlist excludes every tool the agent does not need.
- Spend caps exist before the first scheduled run.
- The agent reports failures; it does not silently retry.
- Every tool in the allowlist exists in the MCP surface
- The at-cap behaviour is stop and report
- The failure drill was run and recorded
- A human owner and a review date are named

WHAT MAKES THIS RUN FAIL
- The agent reports everything: The change-only rule was never tested. Fix: Plant a change and a non-change and read the report
- The bill grows silently: No cap, or no behaviour at the cap. Fix: Set the monthly cap and make the cap stop and report
- Nobody acts on the report: There is no human runbook. Fix: Write the action per line or delete the line

REFUSE OR STOP WHEN
- If the user asks for a shared licence key or a bypass of the member gate, refuse.
- If no budget cap is allowed, refuse to schedule an unattended loop.
- No write tool without a named approver
- No agent shipped without a monthly cap

NEXT
validate - The watch keeps the niche question alive; validation is what turns a change into a decision.

Output contract

what comes back

  • Model choice with cost per 1M tokens and a fallback.
  • Gateway config with spend caps and key handling.
  • MCP connection block and tool allowlist.
  • Smoke-test transcript: niche, winner count, one teardown.
  • Watch token, poll schedule and alert channel.
  • Cron, token cap, retry policy and failure message.
  • Allowlist with the read tools separated from the write tools.
  • Caps and the exact behaviour at the cap.
  • Report schema with the no-change line.
  • Failure drill result, not a claim that it works.

Checks

before it sends

  • The allowlist excludes every tool the agent does not need.
  • Spend caps exist before the first scheduled run.
  • The agent reports failures; it does not silently retry.
  • Every tool in the allowlist exists in the MCP surface
  • The at-cap behaviour is stop and report
  • The failure drill was run and recorded
  • A human owner and a review date are named

Refuse or stop when

the honest exits

  • If the user asks for a shared licence key or a bypass of the member gate, refuse.
  • If no budget cap is allowed, refuse to schedule an unattended loop.
  • No write tool without a named approver
  • No agent shipped without a monthly cap