Home โ€บ Blog โ€บ The Maestro ยท Part 16
The Maestro ยท Part 16 ยท Phase 4 ยท ๐Ÿ“ฆ Product hat

Agents and Client Products

A model is not a product. Engineers buy something that fits into their day: it reads the issue, works in their repository, runs their tests and proposes a change they can review. This part designs Maestro's agent and the three products built on it, prices a single agent task from first principles (and shows why caching makes long tasks affordable), compares seat and per-task pricing with a script, and covers integrations, onboarding and the data agreement that keeps the flywheel turning.

FL
FrontierAGI Team
๐Ÿ“ฆ Product๐Ÿค– Agent engineer๐Ÿ’ผ Founder๐Ÿ’ป Coder
โš ๏ธ How to read this (as of 30 Oct 2026) SWE-agent, SWE-bench and the Model Context Protocol are cited from their sources. task_cost.py and pricing.py were run (real output below) on our assumptions for token counts, prices and usage. tool_server.py uses an external SDK and was not executed for this article. Customer numbers are the scenario. Disclosure: Claude, made by Anthropic, helps write this site.

1. Mission log: months 4โ€“17

Months 4โ€“12 ยท Learning from partners
  • Maestro-0 runs as an internal agent with three design partners; every session is reviewed weekly.
Months 13โ€“15 ยท Three products
  • Packages the agent as a pull-request bot, a CI-failure fixer and an IDE assistant; writes task_cost.py and pricing.py.
Months 15โ€“17 ยท First paying customers
  • Pilot-to-paid conversions begin; hybrid pricing chosen (section 6).

2. What the agent does

One agent task, step by step

๐Ÿ“ฅIssueFrom the tracker or a failing CI run
๐Ÿ”ŽExploreRead files, search code, retrieve skills (Part 1)
โœ๏ธEditChange code in the sandbox (Part 13)
๐ŸงชTestRun the repository's tests
๐Ÿ”IterateFix failures, up to a step limit
๐Ÿ“คProposePull request with explanation, for human review

The agent never merges by itself.

3. Three products from one agent

ProductTriggerOutputWho uses it
PR botAn issue labelled for the botA pull request with tests and explanationTeams with a backlog of small issues
CI fixerA failing build on the main branchA proposed fix or a diagnosisPlatform and release engineers
IDE assistantA developer's request in the editorEdits and explanations inlineIndividual engineers

4. What one task costs to serve

task_cost.py ยท Python 3, no dependencies
"""task_cost.py โ€” what one agent task costs, and why context caching matters.

An agent loop re-sends its growing context every step: system prompt,
repository files read so far, tool outputs. Without caching, input tokens
grow roughly quadratically with steps. Prices are Maestro's own serving
costs from Part 15 plus our assumptions for input and cached tokens.
"""
OUT_PRICE = 1.17 / 1e6        # $/output token (serving_capacity.py, FP8 on 2 GPUs)
IN_PRICE = OUT_PRICE / 5      # prefill is cheaper per token than decode (assumption)
CACHED = IN_PRICE / 10        # reusing a cached prefix (assumption)
SYSTEM, PER_STEP_IN, PER_STEP_OUT = 6_000, 2_500, 400   # tokens

def task(steps, cache):
    ctx, cost, tin = SYSTEM, 0.0, 0
    for _ in range(steps):
        new = PER_STEP_IN
        if cache:
            cost += ctx * CACHED + new * IN_PRICE
        else:
            cost += (ctx + new) * IN_PRICE
        tin += ctx + new
        cost += PER_STEP_OUT * OUT_PRICE
        ctx += new + PER_STEP_OUT
    return tin, cost

def main():
    print(f"{'steps':>5s} {'input tokens':>13s} {'no cache':>9s} {'cached':>8s}")
    for s in (5, 15, 30, 60):
        tin, c0 = task(s, False); _, c1 = task(s, True)
        print(f"{s:5d} {tin:13,d} ${c0:8.3f} ${c1:7.3f}")
    _, c = task(30, True)
    print(f"a typical 30-step task costs ~${c:.3f} to serve; at 60% success, ${c/0.6:.3f} per solved task")

if __name__ == "__main__":
    main()
$ python3 task_cost.py steps input tokens no cache cached 5 71,500 $ 0.019 $ 0.007 15 432,000 $ 0.108 $ 0.025 30 1,516,500 $ 0.369 $ 0.065 60 5,643,000 $ 1.349 $ 0.192 a typical 30-step task costs ~$0.065 to serve; at 60% success, $0.109 per solved task

Serving cost of one task, with and without prefix caching

15 steps, no cache$0.108
15 steps, cached$0.025
30 steps, no cache$0.369
30 steps, cached$0.065
60 steps, no cache$1.349
60 steps, cached$0.192

Real output of task_cost.py (our token and price assumptions).

5. Connecting to clients' tools

tool_server.py ยท MCP tool-server sketch ยท not executed for this article
# tool_server.py โ€” exposing the client's test runner to the agent as a tool over
# the Model Context Protocol (sketch using the MCP Python SDK's FastMCP helper;
# check names against the SDK version you install).
from mcp.server.fastmcp import FastMCP
from sandbox import run_in_sandbox            # micro-VM runner (Part 13)

mcp = FastMCP("maestro-repo-tools")

@mcp.tool()
def run_tests(path: str = "tests/", timeout_s: int = 300) -> str:
    """Run the repository's test suite inside the task sandbox and return a summary."""
    res = run_in_sandbox(["pytest", "-q", path], timeout=timeout_s, network=False)
    return res.summary(max_chars=4000)

@mcp.tool()
def open_pull_request(title: str, body: str) -> str:
    """Propose the current patch as a pull request. Requires human confirmation (Part 13)."""
    return request_confirmation("open_pull_request", title=title, body=body)

if __name__ == "__main__":
    mcp.run()

6. Pricing: seats or results?

pricing.py ยท Python 3, no dependencies
"""pricing.py โ€” per-seat vs per-solved-task pricing for the agent product.

Gross margin = (revenue - serving cost) / revenue. Usage per engineer
varies a lot, so seat pricing can lose money on heavy users. All prices,
usage levels and success rates are our assumptions for the story.
"""
COST_PER_TASK = 0.065         # task_cost.py: 30-step task with caching
SUCCESS = 0.6
SEAT = 40.0                   # $ per engineer per month
PER_SOLVED = 1.50             # $ per merged/accepted task

def main():
    print(f"{'tasks/eng/month':>15s} {'seat margin':>12s} {'per-task margin':>16s}")
    for tasks in (20, 100, 300, 600):
        cost = tasks * COST_PER_TASK
        seat_m = (SEAT - cost) / SEAT
        rev = tasks * SUCCESS * PER_SOLVED
        task_m = (rev - cost) / rev
        print(f"{tasks:15d} {seat_m:12.0%} {task_m:16.0%}")
    print("hybrid: seat fee with an included allowance, then per solved task above it")

if __name__ == "__main__":
    main()
$ python3 pricing.py # our price and usage assumptions tasks/eng/month seat margin per-task margin 20 97% 93% 100 84% 93% 300 51% 93% 600 2% 93% hybrid: seat fee with an included allowance, then per solved task above it

7. Try your own pricing

Pricing calculator (our model)

8. Onboarding a client

From signed contract to first merged change

๐Ÿ“Day 0Contract and data agreement (Part 14)
๐Ÿ”ŒDays 1โ€“3Connect code host, tracker and CI; create sandboxes
๐ŸงชDays 3โ€“7Run on 50 past issues offline; report success rate
๐ŸคWeek 2Live on labelled issues, every PR reviewed
๐Ÿ“ˆWeek 4Review acceptance and edits with the client

Offline replay on past issues sets expectations before anything touches live work.

9. How products feed the flywheel

10. Where the products stand

Scenario
  • By month 17 the story has nine paying customers (plan: twelve), mostly on the PR bot; the CI fixer is in pilot with three; the IDE assistant is postponed because established tools dominate that market.
  • Accepted-change rates in pilots are reported to clients with intervals, not given here as results.
  • These are story outcomes.

11. Designing for review

What a good agent pull request contains

๐ŸŽฏ ScopeOne issue, minimal diff
๐Ÿงช TestsAdded or updated, run in the sandbox
๐Ÿ“ ExplanationWhat, why, how tested, what is left
โ“ QuestionsAsked in the issue when the task is ambiguous

Our product rules for the story.

12. Knowing when to stop

13. Competing with much larger companies

14. Selling to engineering teams

15. Supporting clients

Where client feedback goes

๐Ÿ’ฌFeedbackSupport channel, reviews, reverts
๐Ÿท๏ธTagWrong fix ยท slow ยท unclear ยท integration
๐Ÿ”RouteTests, preference data, onboarding checks
๐Ÿ“ˆImproveNext loop cycle or release

Every piece of feedback lands somewhere specific.

16. Product metrics that matter

MetricMeaningHealthy direction
Accepted-change rateShare of proposed changes mergedUp
Edits before mergeHow much reviewers had to changeDown
Reverts within 30 daysMerged changes later undoneDown
Tasks per active engineerHow much teams rely on itUp
Cost per solved taskMarginDown
Time to first merged changeOnboarding speedDown

17. Seven product mistakes

18. Delegation box

๐Ÿ™‹ Gopala himself
  • Which products to build and in what order
  • Pricing
  • Data agreements with clients
๐Ÿค– AI agents
  • Offline replays on client histories
  • Writing integration code for review
  • Weekly session-review summaries
๐Ÿค Bought, rented or borrowed
  • Code-host and CI integrations via standard protocols
  • An outside pricing adviser for two sessions
  • Design partners as early reviewers

19. Budget and risk tracker

ItemStatus after Part 16Note
Spend to date~$9.8M (scenario)Serving, product engineering, integrations
Customers9 paying (plan 12) (scenario)PR bot first, CI fixer in pilot
TimeMonth ~17Operations and the scorecard next
Market riskMediumBehind plan on customers
Margin riskLowHybrid pricing, caching
Competition riskHighIDE assistant postponed

20. The series

The Maestro: 18 parts in five phases

Verdict
  • A product turns Maestro-1 into something engineers use without thinking about models: a pull request to review.
    • The cost model showed that caching makes long tasks affordable, and the pricing script showed why heavy users break seat pricing.
    • Next, Part 17: running it all every day, and keeping the flywheel turning.

21. Reading the numbers

Primary / standard
SWE-agent agent-computer interface (Yang et al., 2024). SWE-bench (Jimenez et al., 2023). Model Context Protocol introduced as an open standard by Anthropic, November 2024.
Secondary โš ๏ธ
None in this part.
Our assumptions
Token counts per step, prices, usage levels, success rates, customer numbers and product timing.