Planned Feature — Coming Soon

🚧 This feature is not yet released. The documentation below describes planned behavior and may change before launch.

Publishing to Marketplace

Turn your agents into products. Publish them on app.flymy.ai, set a price, and earn from every execution. Buyers run your agents through an auto-generated UI or API — you handle zero infrastructure.

How the Marketplace Works

┌──────────────┐     ┌────────────────────┐     ┌───────────────┐
│   You (Creator)    │     FlyMy.AI Marketplace  │   Buyers       │
│                    │                           │                │
│  Build agent  ────▶│  Host & serve        ────▶│  Discover      │
│  Define inputs     │  Generate forms           │  Fill inputs   │
│  Set pricing       │  Handle billing           │  Run agent     │
│  Publish      ────▶│  Execute runs         ────▶│  Get results   │
│  Get paid     ◀────│  Revenue split             │  Pay per run   │
└──────────────┘     └────────────────────┘     └───────────────┘

Step 1: Design for Buyers

When building a marketplace agent, think from the buyer's perspective:

Clear Input Schema

Every schema property becomes a form field. Write clear descriptions — they become labels and help text.

Python

from flymyai import AgentClient

client = AgentClient(api_key="fly-***")

agent = client.agents.create(
    name="Landing Page Copy Generator",

    goal="""Write high-converting landing page copy for {{ product_name }}.
    Target audience: {{ target_audience }}.
    Value proposition: {{ value_prop }}.
    {{#if tone}}Tone: {{ tone }}.{{/if}}
    {{#if competitors}}
    Differentiate from these competitors:
    {{#each competitors}}
    - {{ this }}
    {{/each}}
    {{/if}}
    {{#if existing_url}}Reference the current page at {{ existing_url }} for context.{{/if}}

    Generate: hero headline, subheadline, 3 feature blocks, CTA text, and meta description.""",

    tools=["web_search", "browse_website"],

    input_schema={
        "type": "object",
        "properties": {
            "product_name": {
                "type": "string",
                "description": "Your product or service name"
            },
            "target_audience": {
                "type": "string",
                "description": "Who is this landing page for? (e.g., 'SaaS founders', 'e-commerce managers')"
            },
            "value_prop": {
                "type": "string",
                "format": "textarea",
                "description": "Core value proposition — what problem do you solve?"
            },
            "tone": {
                "type": "string",
                "enum": ["professional", "casual", "bold", "technical", "friendly"],
                "default": "professional",
                "description": "Writing tone"
            },
            "competitors": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Competitor names or URLs to differentiate from"
            },
            "existing_url": {
                "type": "string",
                "format": "uri",
                "description": "Current landing page URL (optional, for context)"
            }
        },
        "required": ["product_name", "target_audience", "value_prop"]
    },

    output_schema={
        "type": "object",
        "properties": {
            "hero_headline": {"type": "string"},
            "hero_subheadline": {"type": "string"},
            "features": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "title": {"type": "string"},
                        "description": {"type": "string"}
                    }
                }
            },
            "cta_text": {"type": "string"},
            "meta_description": {"type": "string"}
        }
    }
)

JavaScript

import { AgentClient } from "flymyai-js-client";

const client = new AgentClient({ apiKey: "fly-***" });

const agent = await client.agents.create({
    name: "Landing Page Copy Generator",
    goal: `Write high-converting landing page copy for {{ product_name }}.
    Target audience: {{ target_audience }}.
    Value proposition: {{ value_prop }}.
    {{#if tone}}Tone: {{ tone }}.{{/if}}
    {{#if competitors}}
    Differentiate from: {{#each competitors}}{{ this }}, {{/each}}
    {{/if}}
    {{#if existing_url}}Reference current page: {{ existing_url }}.{{/if}}
    Generate: hero headline, subheadline, 3 features, CTA, meta description.`,
    tools: ["web_search", "browse_website"],
    inputSchema: { /* same as above */ },
    outputSchema: { /* same as above */ },
});

Step 2: Test Thoroughly

Before publishing, test with various input combinations:

# Test with minimal input
run1 = client.runs.create(
    agent_id=agent.id,
    input={
        "product_name": "TaskFlow",
        "target_audience": "project managers",
        "value_prop": "AI-powered task prioritization that saves 5 hours/week"
    }
)
result1 = client.runs.wait(run1.id)
print("Minimal input result:", result1.output["hero_headline"])

# Test with all fields
run2 = client.runs.create(
    agent_id=agent.id,
    input={
        "product_name": "TaskFlow",
        "target_audience": "project managers at series A-B startups",
        "value_prop": "AI-powered task prioritization that saves 5 hours/week",
        "tone": "bold",
        "competitors": ["Asana", "Monday.com", "Linear"],
        "existing_url": "https://taskflow.example.com"
    }
)
result2 = client.runs.wait(run2.id)
print("Full input result:", result2.output)

Test Checklist

• Works with only required fields
• Works with all fields filled
• Output matches schema consistently
• Reasonable execution time (< 2 minutes for most agents)
• No hallucinated data in output
• Sources are real and accessible

Step 3: Set Pricing

client.agents.update(
    agent_id=agent.id,
    visibility="public",
    pricing={"per_run": 0.75}
)

Pricing Guidelines

Agent Complexity	Suggested Price	Example
Simple (1-2 tool calls)	$0.10 - $0.25	Quick lookup, simple summary
Standard (3-5 tool calls)	$0.25 - $1.00	Research report, content generation
Complex (5+ tool calls, reasoning model)	$1.00 - $5.00	Deep analysis, multi-source audit
Premium (multi-agent, drives)	$5.00+	Full pipeline, comprehensive report

Step 4: Publish

client.agents.publish(agent_id=agent.id)

Your agent is now live at: app.flymy.ai/agents/your-username/landing-page-copy-generator

What Buyers See

On the Agent Page (app.flymy.ai)

The platform generates a complete page from your agent config:

• Agent name and description (from goal summary)
• Input form auto-generated from input_schema
  • Required fields marked with asterisks
  • Enum fields → dropdowns
  • Arrays → tag inputs
  • Booleans → toggles
  • Descriptions → labels and tooltips
• "Run Agent" button with price displayed
• Output preview showing the structure from output_schema
• Run history for returning users

Via API

Buyers can also integrate your agent programmatically:

# Buyer's code
curl -X POST https://backend.flymy.ai/v1/agents/your-username/landing-page-copy-generator/runs \
  -H "x-api-key: fly-BUYER_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "product_name": "TaskFlow",
      "target_audience": "project managers",
      "value_prop": "AI task prioritization saving 5 hours/week"
    }
  }'

# Buyer's Python code
from flymyai import AgentClient

buyer_client = AgentClient(api_key="fly-BUYER_KEY")

run = buyer_client.runs.create(
    agent_id="your-username/landing-page-copy-generator",
    input={
        "product_name": "TaskFlow",
        "target_audience": "project managers",
        "value_prop": "AI task prioritization saving 5 hours/week"
    }
)

result = buyer_client.runs.wait(run.id)
print(result.output)

Managing Published Agents

Update Without Downtime

Edits create a draft revision. The published version continues serving until you publish the new one:

# Edit the agent (creates draft revision)
client.agents.update(
    agent_id=agent.id,
    goal="Updated, improved goal prompt..."
)

# Test the draft
test = client.runs.create(
    agent_id=agent.id,
    revision_id="latest_draft",
    input={...}
)

# Publish when ready
client.agents.publish(agent_id=agent.id)

Monitor Performance

# Check recent runs
runs = client.runs.list(agent_id=agent.id, limit=50)

success_rate = sum(1 for r in runs if r.status == "done") / len(runs)
avg_duration = sum(r.duration_ms for r in runs if r.status == "done") / len([r for r in runs if r.status == "done"])

print(f"Success rate: {success_rate:.0%}")
print(f"Average duration: {avg_duration/1000:.1f}s")

Revenue

Track your earnings in the FlyMy.AI dashboard.

Best Practices

1. Name clearly — the agent name is the first thing buyers see
2. Write great descriptions — use input description fields generously
3. Default values — set sensible defaults so the form is pre-filled
4. Structured output — always define output_schema for marketplace agents
5. Test edge cases — empty optional fields, long inputs, unusual requests
6. Fast execution — buyers don't want to wait; optimize tool usage
7. Version carefully — always test new revisions before publishing

Next Steps

• Inputs & Variables — advanced input patterns
• Multi-Agent Handoffs — build more powerful agents
• Webhooks — notify buyers when runs complete