You're staring at your campaign manager. ACOS is climbing on three campaigns. You need to adjust bids on 47 keywords. This used to take all afternoon.
For every keyword, the same mental math: compare spend against conversions, check the target ACOS, decide whether to raise or lower the bid, repeat. Forty-seven times. Then do it again next week when the data shifts.
The bottleneck is not the decision logic. A seller knows the rules: if ACOS exceeds 30 percent on a keyword with more than 20 dollars in spend and zero orders, pause it. If a keyword converts at half the target ACOS with consistent impression share, raise the bid. The bottleneck is executing those rules across dozens or hundreds of keywords, every time the numbers change.
This article covers a practical approach: wiring those decision rules into an AI agent through the Model Context Protocol, so bid adjustments happen programmatically instead of manually.
The Bid Management Trap
Amazon PPC is a game of thresholds. Every keyword sits somewhere on a spectrum between "winning" and "bleeding." The seller's job is to push the performing ones and cut the losing ones. The problem is that the number of decisions compounds with every campaign, ad group, and keyword added.
A seller running three campaigns with 15 target keywords each faces roughly 45 individual bid decisions per review cycle. A mid-size seller managing eight campaigns with broad, phrase, and exact match groups can easily hit 200 keywords. At 60 seconds per keyword -- open the console, check the metrics, adjust the bid, confirm -- that is over three hours of clicking.
Most sellers respond by cutting corners: adjust only the keywords that look obviously broken, skip the search term report because exporting and cross-referencing takes another hour. The campaigns drift. Spend accumulates on terms that stopped converting weeks ago.
The data changes faster than the review cycle. A keyword profitable on Tuesday can bleed by Thursday if a competitor raises a bid or seasonal demand shifts the conversion rate. Weekly manual reviews are always a few days behind reality.
Where AI Agents Add Leverage
An AI agent connected to live PPC data through MCP does not get tired after scanning 50 keywords. It does not skip the search term report because it is tedious. It applies the same decision rules to keyword 1 and keyword 200 with identical consistency.
The workflow shifts from manual execution to rule definition. The seller defines the thresholds: target ACOS, maximum spend with zero conversions before pausing, bid adjustment percentages by performance tier. The agent reads the data, applies the rules, and produces a decision table. The seller reviews and approves.
This is not about replacing seller judgment. It is about moving the seller's role from data operator to decision reviewer. The seller still sets the thresholds and decides what qualifies as a winning keyword. The agent handles the reading, the math, and the typing.
A Working Example
With the sorftime-seller-agent MCP server connected to an AI agent, the workflow becomes a prompt. Here is what the setup and interaction look like:
# Clone and install the MCP server
git clone https://github.com/DannylydST/sorftime-seller-agent
cd sorftime-seller-agent
python3 scripts/install.py
# Add to your AI agent's MCP configuration. For Claude Code, add to
# ~/.claude/mcp.json or your project's .mcp.json:
# {
# "mcpServers": {
# "sorftime-seller-agent": {
# "command": "python3",
# "args": ["-m", "sorftime_seller_agent"],
# "env": {
# "SORFTIME_API_KEY": "your-key-here"
# }
# }
# }
# }
# Example prompt once MCP is connected:
# "Pull keyword performance for campaign 'Main-US-SB' for the last 14 days.
# Apply these decision rules:
# 1. Pause any keyword with >$15 spend and zero attributed orders.
# 2. Reduce bid by 25% for keywords with ACOS above 35%.
# 3. Increase bid by 15% for keywords with ACOS below 15% and impression share under 40%.
# 4. Flag keywords where competitor B0XYZ123 outranks us.
# Output a decision table with current bid, recommended bid, and reason."
The agent retrieves the keyword performance data, applies each rule in sequence, and returns a structured decision table. A typical output looks like this:
Keyword Spend Orders ACOS Cur Bid Rec Bid Action
-------------------------- ------ ------- ----- ------- ------- ----------------------
stainless steel bottle 32oz $38.20 0 100% $1.20 $0.00 Pause — no conversions
insulated water bottle gym $22.50 1 72% $0.95 $0.71 Reduce 25% — ACOS > 35%
metal bottle leak proof $14.80 3 19% $0.85 $0.98 Increase 15% — low ACOS
BPA free steel bottle $31.40 1 88% $1.10 $0.83 Reduce 25% — ACOS > 35%
water bottle hiking $8.90 2 11% $0.65 $0.75 Increase 15% — low ACOS
Competitor (B0XYZ123) outranks on:
- stainless steel bottle 32oz: our pos 8, competitor pos 3
- BPA free steel bottle: our pos 11, competitor pos 4
The entire cycle -- from asking the question to having a ranked list of decisions -- takes under two minutes. The same manual process across 47 keywords would take 45 to 60 minutes.
Decision Rules That Scale
The real power comes from saving these rules as reusable templates. Instead of retyping the thresholds every time, the seller maintains a decision playbook: a set of rules the agent applies to any campaign, any keyword set, any date range.
A practical starting playbook might include:
- Pause threshold: spend above 15 dollars, zero attributed orders, 14-day window.
- Reduce threshold: ACOS above 30 percent with at least 10 dollars in spend.
- Increase threshold: ACOS below 15 percent, impression share below 40 percent, at least 3 attributed orders.
- New keyword discovery: identify search terms from the search term report that convert above 5 percent but have no active bid -- add to campaign with a starting bid at the low end of the suggested range.
These rules can be passed to the agent as part of a recurring prompt. The agent is scheduled to run every morning or every Monday. The seller opens the output, skims the decision table, approves the changes, and moves on. The campaigns stay within guardrails without requiring hours of manual monitoring.
The rules also accumulate. A seller who notices a pattern -- keywords with high spend and exactly one order are usually accidents, not trends -- can add that as a new rule. Over time, the playbook reflects actual campaign experience rather than generic best practices.
Beyond Bid Adjustments
The same MCP connection supports decision workflows beyond keyword bid management. A few examples that follow the same pattern of rules-based automation:
- Budget allocation across campaigns: the agent compares campaign-level ACOS and conversion data, then recommends rebalancing daily budgets from underperforming campaigns to overperforming ones.
- Negative keyword harvesting: the agent scans the search term report for terms that generate clicks but never convert, flags them as negative keyword candidates, and drafts the list for review.
- Placement bid modifiers: the agent analyzes performance by placement (top of search, product pages, rest of search) and suggests bid modifier adjustments based on where conversions actually happen.
- Seasonal bid scaling: a rule bookmarked for Q4 that raises all bid ceilings by 20 percent during the holiday window, then reverts them in January.
Each of these follows the same architecture: the seller defines the rules, the MCP server provides the data, the AI agent applies the logic, and the output is a reviewable decision table.
What the AI Does Not Do
A line worth drawing. The AI agent does not decide what a good ACOS target is. It does not know whether raising bids during a competitor's stockout is strategic or wasteful. It cannot judge whether a keyword converts poorly because the listing needs work or because the keyword intent is wrong.
The agent is a rule executor, not a strategist. The seller's role is to set the thresholds, define the logic, and make the final call on every recommendation. The automation handles the part that does not require judgment: reading thousands of data points, doing the same arithmetic 200 times, and formatting the results. The seller handles the part that does.
Getting Started
The sorftime-seller-agent MCP server is open source and free to use. It runs locally, so campaign data and API keys stay on the seller's machine. It works with any MCP-compatible AI agent -- Claude Code, Cursor, Continue, and others.
git clone https://github.com/DannylydST/sorftime-seller-agent && cd sorftime-seller-agent && python3 scripts/install.py
A free account at open-intl.sorftime.com provides API access for marketplace intelligence. The MCP server ships with documentation for every available endpoint, plus example prompts for PPC management, keyword research, and competitor tracking.
Forty-seven keywords do not need to take all afternoon. Define the rules once. Let the agent do the reading and the math. Keep the decisions where they belong -- with the seller who understands the business.
Top comments (0)