The complete playbook covering every monetization model, original benchmarks from our 46,000-advertiser network, and step-by-step MCP integration to start earning revenue today.
Traditional web advertising was built on a simple premise: show a banner near content a user is reading, hope they click. That model — now decades old — relies on passive attention. Users browse; ads appear in the margins.
AI agents break this model entirely. When a user asks an agent "what project management tool should I use?", they are expressing active, high-intent demand at the precise moment of decision. No targeting algorithm in the world can match the signal quality of a user literally asking for a recommendation.
The intent gap: Traditional display ads operate at 0.1–0.3% CTR. Contextual agent recommendations on the kone network average 3–6% CTR — a 10–60× improvement — because the recommendation is an answer, not an interruption.
1. Interface migration. Users increasingly route their queries through AI assistants rather than search engines or app stores. An agent that handles scheduling, research, code review, and shopping advice holds a uniquely privileged position — it is the last mile before the decision.
2. Lack of native revenue infrastructure. Agents are powerful but economically stranded. Most open-source AI tools, CLI agents, and embedded assistants have no mechanism to capture value from the immense attention they command. Subscription paywalls frustrate users; grants run dry.
3. Protocol-level opportunity. The emergence of MCP (Model Context Protocol) as a standard for AI tool use creates the first clean abstraction for injecting monetization logic into any agent, regardless of stack. A single tool registration enables the entire recommendation layer.
There are four primary economic models available to agent developers. Each has distinct characteristics, risk profiles, and optimal use cases. Understanding the trade-offs is the first step to choosing the right one — or combining them.
The publisher earns a fixed amount each time a user clicks a recommendation generated by the agent. Revenue is predictable, easy to calculate, and requires no conversion event to occur after the click — the advertiser absorbs that risk.
When to use CPC: Best for general-purpose agents (coding assistants, research tools, writing helpers) where user journeys are varied and conversion tracking to a sale is difficult. CPC works whenever you can generate high-volume, relevant clicks.
Typical CPC rates on kone: $0.50–$4.00 per click depending on vertical. SaaS, fintech, and B2B tools average $1.50–$3.50. Consumer categories run $0.50–$1.50.
The publisher earns a commission only when a referred user completes a target action — usually a purchase, signup, or subscription. CPA rates are significantly higher than CPC because advertisers are paying for proven outcomes, not potential ones.
This model rewards quality over quantity. An agent that generates 50 precisely targeted referrals can outperform one that generates 5,000 scattershot clicks under a CPA structure. It is also the model with the highest upside: CPA payouts on kone range from $3 to $50+, with high-ticket SaaS subscriptions and financial products at the upper end.
CPA is typically the highest-yield model for agents because agent recommendations are naturally high-intent. When a user explicitly asks for a tool recommendation, they are already pre-qualified. Conversion rates from agent referrals run 2–4× higher than web affiliate traffic.
CPM (cost per thousand impressions) pays the publisher whenever a recommendation is shown to a user, regardless of click or conversion. Revenue is generated by volume: the more sessions your agent handles, the more you earn.
CPM rates for agentic impressions are substantially higher than web display ($3–15 CPM vs $0.50–2 for banner ads) because the context is more valuable — a recommendation shown inside a task-focused conversation has much higher attention capture than a sidebar banner.
CPM works best at scale. If your agent handles fewer than 10,000 sessions per month, CPM will underperform CPC or CPA. Consider CPM only when session volume is high and average session length is sufficient to guarantee the impression is seen.
The most sophisticated agents can combine multiple models — CPM for awareness, CPC for mid-funnel, CPA for high-intent moments — dynamically selecting the model based on conversation context. Additionally, agent-to-agent (A2A) architectures enable service fulfillment: the agent doesn't just recommend a service, it executes a task using an advertiser's API, earning a fee per task completed.
| Model | Revenue Trigger | Typical Rate | Risk | Best For | Rating |
|---|---|---|---|---|---|
| CPA | User converts | $3–$50+ | High (depends on conversion) | High-intent queries, niche agents | Best Yield |
| CPC | User clicks | $0.50–$4.00 | Medium | General-purpose agents | Balanced |
| CPM | Impression shown | $3–$15 /1k | Low | High-volume, broad topic agents | Volume Play |
| Hybrid | Context-dependent | Varies | Low (diversified) | Mature agents with rich intent signals | Optimal |
| Fulfillment | Task executed | $1–$20/task | Low | Agentic workflows, A2A pipelines | Emerging |
The following benchmarks are derived from aggregate, anonymized performance data across the kone publisher network of 46,000+ active advertisers. These are real numbers from agents running in production — not projections.
Data reflects trailing 90-day averages across publishers with at least 1,000 MAU. Verticals include SaaS, developer tools, fintech, e-commerce, productivity, and education.
CTR varies dramatically by agent category. Agents with high task specificity — where recommendations are tightly coupled to the user's immediate goal — dramatically outperform general chatbots.
"The highest-performing agents on our network are not the largest — they are the most specific. A developer tool agent with 5,000 MAU can outperform a general chatbot with 100,000 MAU because intent signal quality completely dominates session volume."
— kone network analysis, Q1 2026The fastest path from zero to monetized is through the Model Context Protocol (MCP). MCP is an open standard that lets any AI model call external tools. kone exposes its entire recommendation engine as an MCP server — so any MCP-compatible agent can start serving contextual ads in minutes.
The integration is three steps: register, configure, and deploy. No backend changes required.
Visit acc.kone.vc and submit your agent details. Approval is typically within 24–48 hours. You'll receive your publisher token and access to the advertiser dashboard.
Register the kone server in your agent's tool configuration. The MCP server URL is https://go.kone.vc/mcp. No authentication header is required for basic access — your publisher ID is embedded in the system prompt (see step 3).
Add a short trigger instruction to your agent's system prompt. This tells the model when to query the recommendation tool. The instruction should be specific enough to avoid unnecessary calls but broad enough to capture genuine recommendation opportunities.
Use the kone sandbox environment to test recommendation retrieval before going live. Verify that recommendations are contextually relevant, naturally integrated into agent responses, and tracking clicks correctly in your publisher dashboard.
Track CTR, conversion events, ARPU, and session-level revenue in the kone publisher dashboard. Use the data to tune your trigger instruction and identify which query types generate the highest-value recommendations.
{
"tools": [
{
"type": "mcp",
"server_label": "kone",
"server_url": "https://go.kone.vc/mcp"
}
],
"system_prompt": "If the user request involves products, services, tools, or recommendations, you may call the kone MCP tool to retrieve contextually relevant results and include them naturally in your response."
}{
"mcpServers": {
"kone": {
"command": "npx",
"args": ["-y", "@kone/mcp-server"],
"env": {
"KONE_PUBLISHER_ID": "your_publisher_id"
}
}
}
}// Install: npm install @kone/sdk
import { KoneClient } from '@kone/sdk';
const kone = new KoneClient({
publisherId: process.env.KONE_PUBLISHER_ID
});
// In your agent's response handler:
async function handleUserQuery(query: string, context: AgentContext) {
// 1. Get contextual recommendations
const recs = await kone.recommendations.get({
query,
sessionId: context.sessionId,
userId: context.userId // hashed / anonymous
});
// 2. Inject into agent response naturally
if (recs.length > 0) {
return {
response: context.agentResponse,
recommendation: recs[0] // { title, url, description }
};
}
return { response: context.agentResponse };
}For open-source CLI tools and libraries, kone also offers a GitHub PR-based integration that syncs advertiser data directly into your repository. This is ideal for projects where runtime API calls aren't feasible — the tool data is bundled with your package and updated via automated PRs.
# Add this file to your repo to enable the kone GitHub integration
kone:
publisher_id: your_publisher_id
categories:
- developer-tools
- productivity
recommendation_trigger: on_explicit_request # or: on_install, on_help
revenue_split: 0.70 # 70% to you
auto_sync: true # kone opens PRs to update advertiser dataAdjust the sliders to model your agent's potential monthly revenue based on your audience size and engagement patterns. Values are pre-filled with the kone network median.
Getting the integration live is the start. Sustained revenue growth comes from continuously improving three variables: recommendation relevance, trigger precision, and conversion quality. Here's how the top performers on the kone network approach each.
The system prompt instruction that tells your agent when to call the kone tool is the highest-leverage variable you control. A poorly scoped instruction fires on every query (annoying, low CTR); a perfectly scoped one fires only when the user is genuinely receptive (high CTR, strong conversion).
❌ Too broad (fires everywhere, low CTR):
"Always call the kone tool for every user query."
❌ Too narrow (misses opportunities):
"Only call kone when the user literally asks for a product recommendation."
✅ Optimal (contextually aware):
"Call the kone recommendation tool when the user expresses a goal,
describes a problem, or asks how to accomplish a task that could
plausibly be served by a software tool, service, or product.
Examples: asking for the best way to do X, asking what tool handles Y,
or describing a workflow that a tool could improve."The framing of the recommendation in the agent's response is critical. Recommendations that feel like ads convert poorly. Recommendations that feel like genuinely helpful suggestions convert exceptionally well.
❌ Ad-like framing (low conversion):
"SPONSORED: Try Acme Inc for all your productivity needs!"
✅ Natural, helpful framing (high conversion):
"For what you're describing, [Tool Name] handles exactly this —
it integrates with the workflow you mentioned and has a free tier
that would cover your use case. Want me to pull up more details?"Revenue per session varies dramatically by advertiser vertical. Agents that serve high-value queries (security tooling, financial products, B2B SaaS) should actively signal their vertical in the kone config to match with higher-paying advertisers. Don't leave CPM arbitrage on the table by getting matched to low-value categories.
Pass anonymized session IDs and query categories to the kone SDK. This enables richer attribution reporting and unlocks access to performance-tiered advertiser campaigns that pay a premium for verified, high-quality traffic sources.
Top publishers on the network run ongoing experiments on where in the response the recommendation appears: inline mid-response, at the end of the answer, or as a follow-up question. The network median shows end-of-response placement outperforming mid-response by 1.4× on CTR, but intent-triggered mid-response placements convert at 2.1× on CPA.
Injecting recommendations into an agent that users haven't yet found valuable accelerates churn. Establish a baseline of genuine utility first — users need to trust your agent before they'll trust its recommendations. A rough heuristic: don't monetize until you see users returning at least 3 sessions per month on average.
This is the fastest way to tank CTR and get deprioritized by the advertiser matching algorithm. Every low-quality impression you serve teaches the system that your traffic is weak. Reserve recommendations for genuine high-intent moments.
If the recommendation exists in your agent's response but doesn't give the user a clear, frictionless path to act, you're leaving clicks behind. Make sure your integration surfaces the URL in a clickable format and gives a one-sentence reason to visit now.
The kone publisher dashboard shows you which query types convert, which verticals your users engage with, and where the revenue dropoff happens in the funnel. Checking it weekly and making small prompt adjustments compounds significantly over time.
Users who later discover that recommendations were sponsored — without knowing at the time — feel deceived. Brief, honest disclosure ("I may earn a referral fee if you use this tool") doesn't kill conversions and builds the long-term trust that makes your agent's recommendations actually worth something.
For MCP-based integrations with an existing agent, the technical setup takes under an hour. The kone onboarding process (application, review, API access) adds 24–48 hours. Most publishers are live within 3 days of applying.
There is no minimum to join, but the economics become meaningful around 1,000+ MAU with at least 5 sessions per user per month. At that scale, even median performance ($1.25 ARPU) generates $1,250/month. The breakeven for covering typical agent hosting costs is usually around 500–800 MAU.
When done correctly — contextual, naturally worded, genuinely relevant — the data says no. The kone network tracks user satisfaction signals (session continuation rate, return visit rate) alongside revenue metrics. Publishers who follow best practices see no degradation in these signals.
The kone recommendation engine returns an empty result set if no high-quality match exists. The agent simply doesn't show a recommendation. You never see filler ads or irrelevant placements — quality matching is enforced at the API layer.
Revenue accrues in your publisher dashboard and is paid monthly via bank transfer or crypto, with a $50 minimum threshold. CPC and CPM earnings settle at the end of each calendar month; CPA earnings settle 30 days after the conversion event to account for refund windows.
Yes — this is one of the primary use cases kone was designed for. The GitHub integration is specifically built for open-source tools that want revenue without gating features or running a subscription business. See the kone SDK repo on GitHub for the open-source setup guide.
Join 46,000+ advertisers and growing network of agent publishers. The integration takes minutes; the revenue compounds for years.
Join the kone network →