The marketing around AI agents often suggests they replace traditional automation entirely. That is false. Traditional workflow automation and AI agents solve fundamentally different problems.

Using an AI agent where a Zapier recipe belongs wastes money and introduces random failures. Using Zapier where an AI agent belongs leads to brittle, unmaintainable webs of filters, regexes, and edge-case exceptions.

Here is the exact framework for choosing the right tool for each job.

The core distinction: Deterministic vs. Probabilistic

The decision comes down to one technical reality:

• Traditional automation (Zapier, Make): Deterministic. Step A produces field X. If field X equals "Approved", trigger Step B. It runs the exact same code every time. Cost is predictable, execution is instant, and error states are binary.
• AI agents: Probabilistic. Step A is unstructured text, messy HTML, or an ambiguous request. The agent reasons about intent, decides which tools to invoke, handles unexpected inputs, and generates context-aware output.

If your process can be represented as a clean flowchart with strict boolean logic, do not use an AI agent. Use Zapier.

If your process requires reading comprehension, subjective judgment, adapting to changing formats, or synthesizing multiple ambiguous sources, Zapier will fail. Use an AI agent.

Head-to-head comparison

Where Zapier wins hands down

Do not overcomplicate these with AI agents:

1. Simple database record synchronization

Syncing a new Stripe customer into HubSpot, or moving a signed DocuSign envelope into a Google Drive folder. There is no judgment required. The data is structured, the endpoints are stable, and the execution must be 100% deterministic.

2. High-volume, low-latency event alerts

Firing an instant SMS or Slack notification whenever a server health check fails, or when a payment exceeds $1,000. Zapier fires in milliseconds. An LLM call adds seconds of latency and unnecessary expense.

3. Fixed file backups and archives

Copying daily CSV exports from an SFTP server to Amazon S3. Deterministic code is faster, cheaper, and cannot misread an instruction.

Where AI agents outperform traditional workflows

These tasks crumble inside traditional workflow builders:

1. Inbound customer email triage and synthesis

A customer sends a three-paragraph email complaining about onboarding friction, mentioning an error message, and asking for a feature. - Zapier approach: Try to keyword-match "error" or "cancel", routing to blunt buckets. Fails on nuance, tone, and multi-part questions. - AI agent approach: Reads the full context, extracts the root issue, checks system logs for that user's account, and drafts a precise, empathetic response for a support rep to approve.

2. Semi-structured web research and competitive audits

Tracking five industry news sites and summarizing shifts in regulatory policy. - Zapier approach: RSS feeds dump 50 raw links into a channel. Nobody reads them. - AI agent approach: Scrapes the articles, filters out noise, cross-references with existing company initiatives, and delivers a three-bullet brief with citations.

3. Dynamic multi-step problem solving

Tasks where the next step depends on what was discovered in the previous step. For example: "Research this prospect, check if their tech stack includes Shopify, and if so, find their VP of E-commerce and draft a tailored pitch referencing their latest product release." Attempting to build this branching logic in Zapier requires dozens of nested zaps and constant maintenance. For an agent, it is a single unified directive.

The hybrid architecture: How leading teams combine both

The most effective setup is not an either/or choice. High-performing teams use Zapier and AI agents together as a cohesive system:

[Inbound Event] 
       │
       ▼
[Zapier / Webhook] ─── (Collects payload, handles auth, checks rate limits)
       │
       ▼
[AI Agent Runtime] ─── (Performs semantic extraction, reasoning, tool execution)
       │
       ▼
[Zapier / Destination] ── (Routes output back to CRM, ERP, or notification pipes)

In this pattern: 1. Zapier acts as the plumbing: It listens for webhooks, authenticates against corporate SaaS tools, and normalizes payloads. 2. The Agent acts as the brain: It receives the normalized context, performs the non-linear reasoning, calls specialist tools if needed, and returns a verified deliverable. 3. Zapier commits the result: It takes the agent's clean output and pushes it to Salesforce, Airtable, or Slack.

Decision rubric

Before building your next automation, ask three questions:

1. Can I write the decision tree on a napkin in five minutes?
   If yes: build it in Zapier or Make.
2. Does the input come in unpredictable formats (natural language, unstructured PDFs, raw HTML)?
   If yes: route it to an AI agent.
3. What is the cost of a subtle error?
   If an error creates legal or financial liability with no human review, stick to strict deterministic scripts. If human review is part of the loop, an agent will save dozens of hours of manual drafting.

That is the gap between an AI agent that helps and one that collects dust. This guide covers how to evaluate AI agents for business use, what they really cost to run, and the checks that separate tools that ship from tools that stall.

What an AI agent actually does

An AI agent is software that completes a multi-step task on its own: it reads the input, decides the steps, calls the tools it needs, and returns finished work. A chatbot answers questions. An agent does the task.

Concrete examples that map to real business work:

• Research and summarization. Collect sources, extract the points that matter, produce a brief.
• Content production. Draft posts, adapt them per channel, keep the voice consistent.
• Coding and data work. Write scripts, clean spreadsheets, build small internal tools.
• Customer operations. Triage inbound requests, draft replies, escalate what needs a human.

The pattern across all of these: the agent replaces a chain of small decisions, not a single click.

The five checks before you buy

1. Does it finish tasks, or just start them?

Ask for a full task, not a demo step. "Summarize this 40-page report and give me the three decisions it implies" is a real test. "Show me what it can do" is not. Tools that stall usually stop at the first tool call or hand the messy middle back to you.

2. Can it use the tools your business already runs?

An agent that cannot touch your calendar, your inbox, your documents, or your database is a text generator with extra steps. Check the integrations list before the marketing page. Native connections to the tools you already pay for beat everything else.

3. What does it cost per task, not per month?

Subscription pricing hides the real variable: how much compute each task burns. Two tools at the same monthly price can differ by 10x in cost per finished task, depending on which models they route to and how many retries they need. Ask for or estimate the cost per task on a representative workload. For a worked example of the math, see what it costs to run an AI agent in 2026.

4. Who checks the output?

Agents fail quietly. A wrong number in a report looks as confident as a right one. Good tools make review cheap: diffs, citations, source links, and a clear record of what the agent did. If reviewing the work takes longer than doing it, the tool is not ready for your workflow.

5. What happens when it is wrong?

Every agent will eventually take a bad action: send the wrong email, overwrite a file, publish the wrong draft. Look for permission controls you actually control, an undo path, and limits on what the agent can touch without asking.

The pricing reality

Most AI agent tools price in one of three ways:

Usage-based pricing is the most honest, because the cost tracks the work. It also demands the most attention: a busy week can cost five quiet weeks. Whatever the model, convert it to cost per finished task and compare tools on that number.

The underlying driver is model choice. Routing routine steps to efficient models and reserving expensive ones for hard steps can cut the bill for the same output dramatically. Tools that let you control routing give you a lever; tools that hide it give you a bill.

Why most agent projects stall

The failure mode is rarely the model. It is the plumbing:

• No connection to real tools. The agent writes a great plan and cannot execute any of it.
• No memory between sessions. Every task starts from zero, so recurring work never gets faster.
• No review loop. Output lands somewhere nobody checks, trust never builds, usage dies.
• One-off setup. The agent works for the person who configured it and nobody else.

When you evaluate a tool, ask how it handles each of these. The answers predict whether it will still be in use in three months.

A quick evaluation checklist

Run any candidate through this before committing:

1. Give it one real task from your business, end to end.
2. Time the full run, including your review time.
3. Calculate the cost of that run, including retries.
4. Check it connects to the three tools you use most.
5. Break it on purpose: give it an ambiguous input and see how it fails.
6. Confirm you can undo or restrict its actions.

A tool that passes six of six is worth paying for. A tool that passes two is a demo.

Where this series goes

This is the first in a four-part series on AI agents for business. Next: five real agent workflows with the actual steps and costs, then a comparison of agent platforms against established automation tools, then a full breakdown of what running agents really costs at scale.

The short version for now: pick the tool that finishes tasks inside your existing stack, price it per task, and keep a human in the review loop. Everything else is marketing.

This article is about what is running right now.

Here are five concrete workflows deployed in production environments today. For each one: the business problem it solves, the step-by-step trigger and execution logic, the specific tools it touches, how it routes between models, and what it costs per run.

1. Automated competitor and market intelligence

The problem

A small B2B team needed daily visibility into five key competitors: product launches, pricing page changes, key executive tweets, and customer complaints on Reddit and Twitter. A human analyst spent 90 minutes every morning manually opening tabs and copy-pasting notes into Slack.

Execution steps

1. Trigger: Daily cron at 06:00 UTC.
2. Fetch: Run headless scrapes and search queries against competitor domains, GitHub releases, and relevant X lists.
3. Diff & Filter: Compare fetched snapshots against yesterday's stored markdown cache. If no material change is detected, exit immediately (zero analysis tokens burned).
4. Synthesize: Pass verified changes to a mid-tier reasoning model to extract key shifts, categorize severity (1 to 5), and draft a two-paragraph executive brief.
5. Deliver: Push formatted summary to a designated Telegram channel with direct source citations.

Tools touched

Web scraper, diff cache, Telegram Bot API.

Cost breakdown

• No changes detected (60% of runs): ~$0.002 (scrape and diff only)
• Changes detected and synthesized: ~$0.038 per run
• Monthly total: ~$1.10/month vs $1,500/mo human analyst time

2. Inbound lead qualification and CRM enrichment

The problem

A service company received 20 to 40 contact form submissions daily. Half were unqualified solicitations, while high-value inbound leads often waited hours for manual research before an account rep followed up.

Execution steps

1. Trigger: Webhook from form submission (or email parser).
2. Domain verification: Query WHOIS and company databases to verify corporate existence, head count, and sector.
3. Intent scoring: Evaluate the submission text against an ideal customer profile rubric.
4. Enrichment: Append discovered tech stack and LinkedIn profile URLs to the lead record in Google Sheets.
5. Route:
6. Unqualified: Auto-archive with a polite template.
7. Qualified: Draft personalized outreach notes and ping the sales rep on Slack.

Tools touched

Google Sheets, HTTP proxy, Slack webhook, email parser.

Cost breakdown

• Average cost per lead evaluated: $0.015
• Daily cost (30 leads): $0.45/day
• Speed advantage: High-intent leads receive a personalized follow-up in under 3 minutes.

3. SEO content audit and internal linking sync

The problem

A content site with 400+ articles struggled to keep internal links updated as new pillar content was published. Dead links went unnoticed and fresh pieces lacked authority links from older, high-traffic pages.

Execution steps

1. Trigger: Weekly scheduled run or on-demand post-publish hook.
2. Catalog audit: Read site sitemap and build an in-memory graph of all article headings, target keywords, and outbound links.
3. Opportunity detection: Identify published articles with high semantic relevance to new posts that lack internal backlinks.
4. Edit proposal: Generate unified unified diffs showing exact anchor text and target URLs for 3 to 5 candidate articles.
5. Verification & Commit: Validate links return HTTP 200, commit the markdown edits to the repository, and rebuild the static site.

Tools touched

Git repository, markdown parser, HTTP verification tool.

Cost breakdown

• Full audit run (400 articles): ~$0.24 (token-efficient embeddings + targeted LLM diff generation)
• Manual equivalent: 4 to 6 hours of editorial coordination.

4. Multi-channel social copy adaptation and asset prep

The problem

A media team published detailed technical blog posts weekly. Adapting one 2,500-word deep dive into an X thread, a LinkedIn carousel brief, an email newsletter teaser, and clean visual banners required hours of repetitive context-switching.

Execution steps

1. Trigger: New published post detected in git or CMS.
2. Key idea extraction: Parse the markdown file, extract the thesis, the 3 strongest arguments, and all concrete data tables.
3. Format-specific generation:
4. X thread: 5 to 7 concise tweets with no corporate fluff or em dashes.
5. LinkedIn: Professional case-study angle focused on business ROI.
6. Newsletter: 150-word teaser linking directly to the canonical post with tracking UTMs.
7. Header banner generation: Build matching 2000x800 social cards using brand vector templates and Google Sans typography.
8. Draft review: Deliver all copy and image assets to an approval inbox for one-click human sign-off.

Tools touched

Markdown reader, Pillow / graphics engine, Telegram review channel.

Cost breakdown

• Full multi-channel package: ~$0.08 per post
• Turnaround time: 45 seconds from blog publish to draft review pack ready.

5. Daily financial reconciliation and anomaly alerting

The problem

An e-commerce brand operating across Shopify, Stripe, and two merchant gateways needed daily reconciliation. Mismatches between gateway deposits and order records frequently went unnoticed until month-end accounting.

Execution steps

1. Trigger: Nightly cron at 02:00 local time.
2. Data extraction: Pull previous day settlement reports from Stripe API, merchant processor exports, and Shopify order logs.
3. Reconciliation math: Deterministic Python script balances gross sales, processor fees, refunds, and net payouts.
4. Anomaly triage: If discrepancies exceed $5.00, pass the raw transaction logs to an agent to isolate the specific transaction ID, customer email, and error code.
5. Report: Deliver a clean ledger summary table to the finance lead via email and log the audit entry.

Tools touched

Payment APIs, local Python sandbox, email delivery.

Cost breakdown

• Clean reconciliation (no anomalies): $0.00 (deterministic script only)
• Anomaly investigation run: ~$0.04
• Benefit: Zero month-end surprise discrepancies and instant fraud detection.

The common pattern across all five

None of these workflows rely on a single massive prompt or an all-powerful autonomous agent wandering the web.

They all share the same structural pattern: 1. Strict boundaries: Narrow scope, explicit trigger, defined deliverable. 2. Hybrid execution: Deterministic code handles data collection, diffing, and math. The LLM handles synthesis, judgment, and formatting. 3. Model routing: Fast, inexpensive models do 80% of the volume. High-tier models are invoked only when genuine reasoning is required. 4. Human in the loop: Deliverables land in review queues or notification channels with clear diffs and source citations.

When you design agent workflows around these principles, reliability approaches 99% and costs stay in the pennies.

Vendor pricing tables advertise seats, bundles, and flat tiers. But inside the machine, every agent operation is fundamentally a chain of LLM calls, vector lookups, and API invocations. If you run agents efficiently, you can accomplish thousands of complex tasks for the price of a modest dinner. If you configure them carelessly, a single looping script can burn hundreds of dollars before lunch.

Here is the exact unit economic breakdown of running autonomous AI agents at production scale in 2026.

The four cost components of an agent task

To understand agent expenses, you have to break down what happens during a single execution loop:

[Task Initiated]
       │
       ▼
1. Context loading ── (System prompts, conversation history, retrieved memories)
       │
       ▼
2. Decision & Reasoning ── (LLM inference: plan next step, select tool)
       │
       ▼
3. Tool Execution ── (Search APIs, web scraping, data transforms, storage)
       │
       ▼
4. Output Synthesis ── (Final formatting, verification, review notification)

The total cost per task is: $$\text{Cost} = \text{Input Tokens} + \text{Output Tokens} + \text{Tool / Infrastructure Fees}$$

1. Input tokens (the silent multiplier)

Every time an agent takes a turn in a multi-step task, it sends the conversation history plus loaded context back to the model. An agent that takes 8 turns to finish a task might consume 4,000 tokens on turn 1, but 25,000 tokens on turn 8. Prompt caching helps mitigate this, but context bloat remains the primary driver of runaway costs.

2. Output tokens (the expensive ones)

Models typically bill output generation at 3x to 5x the price of input processing. Forcing an agent to be concise and keeping verbose working notes out of the final reply directly lowers your unit costs.

3. Tool and external API calls

Scraping proxies, real-time market data feeds, and specialized vector databases carry per-request costs that sit outside your LLM billing.

4. Verification and retries

An autonomous task that hits an error and retries three times burns triple the compute. Reliable guardrails and clean error handling are cost-control features, not just engineering hygiene.

Production scale tiers: From 1,000 to 100,000 tasks

Here is what realistic agent operations cost per month across three volume tiers, assuming smart model routing (using budget models for mechanical steps and high-reasoning models only for complex synthesis):

Notice how the blended cost per task drops as volume grows. This efficiency comes from prompt caching, consolidated retrieval patterns, and refining task-specific system prompts.

The three levers that slash your bill by 75%

If your agent costs are trending higher than these benchmarks, three operational changes produce immediate savings:

1. Dynamic model routing (Conductor pattern)

Never use a flagship frontier model for mechanical work. - Classification, regex extraction, and simple JSON parsing should always route to sub-cent fast models. - Mid-tier reasoning handles 80% of multi-step workflow logic. - Reserve tier-one reasoning models strictly for complex code generation, strategic document synthesis, or ambiguity resolution.

Deploying intelligent model routing routinely drops total token spend by 60% to 75% with zero degradation in task quality.

2. Aggressive context compaction

Agents should not carry their entire raw scratchpad indefinitely. After an agent reads a 50-page document and extracts four relevant numbers, the full document should be dropped from active conversation context. Persist the extracted facts in persistent memory or a structured file, not the active prompt window.

3. Deterministic code before LLM calls

If a task can be calculated, parsed, or formatted with ten lines of Python, do not ask an LLM to do it. Use deterministic scripts for data filtering, schema validation, and file manipulation. Let the LLM handle semantic judgment and language generation.

ROI comparison: Agent compute vs. human labor

To put these numbers into commercial perspective:

• 10,000 customer triage operations: ~$180 in agent compute versus 160 hours of tier-1 support time (~$3,200).
• 1,000 competitor intelligence audits: ~$25 in compute versus 40 hours of junior analyst time (~$1,000).
• 50,000 automated SEO and link sync checks: ~$550 in compute versus an outsourced agency retainer ($3,000 to $5,000).

The economic advantage of autonomous agents is not marginal; it is an order-of-magnitude reduction in the marginal cost of cognitive work.

Conclusion: How to budget for your agent stack

When planning your agent infrastructure: 1. Budget per task, never per seat. 2. Demand visibility into token consumption and model routing. 3. Optimize the plumbing: implement prompt caching, compact context aggressively, and pair LLM judgment with deterministic code.

The teams that master these unit economics will scale their operations 10x without scaling their headcount or their software bill.

When you chat with your agent, you want quick answers without having to think about which AI model to pick.

Conductor Mode 4.1 makes that experience simpler and noticeably faster. Here is what is new.

1. Faster Everyday Chats with GPT-6 Luna

Routine questions, formatting, and quick lookups do not need heavy computing power. They need quick answers.

We added OpenAI's GPT-6 Luna to handle these lighter requests:

• Quicker replies: Luna starts answering almost instantly, cutting wait times for everyday questions.
• Better efficiency: Simple tasks use fewer credits, leaving more room for heavier work.
• Smoother background tasks: Automated daily checks and recurring tasks run faster and lighter.

2. Claude Sonnet 5.5 for Tougher Problems

Sometimes a simple question turns into a complicated problem, like debugging messy code or untangling conflicting instructions.

When a task needs deeper thinking, Conductor Mode brings in Anthropic's Claude Sonnet 5.5:

• Handles complex steps: Sonnet takes over when a task requires precise tool use or multi-step reasoning.
• Keeps things moving: Instead of getting stuck, your agent uses a stronger model to work through tricky roadblocks.

3. Faster Responses with Locked-In Steps

Previously, an agent might switch models halfway through answering a message. That extra switching slowed things down.

Conductor Mode 4.1 now sticks to one model and setting for each turn:

• Faster turnaround: Staying on one model lets our systems reuse recent context, speeding up follow-up steps.
• Consistent tone: Your agent keeps the same voice and style from the start of an answer to the end.

4. Automatic Memory Cleanup

Your agent remembers your preferences, project details, and setup notes. But over time, old notes pile up and clutter things.

We added an automatic daily cleanup pass to keep things organized:

• Cleans up duplicates: If you have multiple notes saying almost the same thing, they are combined into one.
• Retires outdated notes: Temporary reminders and old project notes that are no longer useful get cleared out.
• Keeps context fresh: Your agent only loads what is actually helpful, so it stays focused on your current work.

5. Smoother Claude 5.5 Reasoning Controls

For users who want to turn deeper reasoning on or off when using Claude Sonnet 5.5 and Opus 5.5, those controls now switch cleanly without errors.

Ready to Use

Conductor Mode 4.1 is active right now.

If you already use Conductor Mode, you get the speed boost and updates automatically. If not, just choose Conductor Mode from your model selector and start chatting.

Frontier model releases usually come with long waiting periods. This week, Anthropic and OpenAI broke that cadence by dropping major updates right on the heels of their previous launches.

Anthropic rolled out Claude Opus 5.5 just sixty days after releasing Opus 5 in July. Initial developer reaction across technical communities has focused on its efficiency gains: Opus 5.5 beats the much pricier Claude Fable 5.1 across agentic coding and knowledge benchmarks, while cutting token pricing by 20% and reducing typical workload costs by roughly 40%. The biggest unlock for builders is step reduction, with the model completing multi-turn agent loops in noticeably fewer tool calls.

At the same time, OpenAI moved quickly to flesh out its GPT-6 family. Just three weeks after introducing its top-tier flagship GPT-6 Astra, OpenAI launched GPT-6 Sol and GPT-6 Luna. The public response has been immediate relief on pricing: while Astra pushed frontier intelligence, developers wanted practical workhorses for real production pipelines. Sol delivers near-flagship software engineering capabilities at half the cost, while Luna provides fast, low-cost execution with tunable reasoning depth.

Both providers are shifting the frontier from pure raw scale to operational efficiency. Here is how each new model fits into your Starchild workspace.

1. Claude Opus 5.5: Flagship Agentic Coding and Fewer Steps

Claude Opus 5.5 is Anthropic's new flagship for complex codebases and long-running autonomous agents.

• What it delivers: Higher accuracy on agentic coding benchmarks than Fable 5.1, paired with lower API rates and aggressive prompt caching discounts. Because it plans more concisely, it resolves tasks in fewer steps, lowering both turnaround time and total token consumption.
• Best workflow fit: Multi-file architectural refactoring, end-to-end debugging sessions, deep analytical research, and autonomous agents executing chained tool calls.
• How to use it: Choose Claude Opus 5.5 in chat when tackling intricate software problems, or assign it to dedicated agents that manage long-horizon coding projects.

2. GPT-6 Sol: High-End Software Engineering at Half the Cost

GPT-6 Sol serves as OpenAI's mainstream flagship alternative for serious engineering work.

• What it delivers: Near-flagship reasoning and code generation without the premium cost of GPT-6 Astra. It cuts token prices by roughly 50% compared to earlier top-tier tiers, making deep reasoning viable for daily engineering.
• Best workflow fit: Day-to-day full-stack development, code reviews, technical documentation, and professional workflows where lightweight models lack depth but full flagships are cost-prohibitive.
• How to use it: Use Sol as your daily driver for technical tasks in chat, or configure it as the core reasoning engine for development agents.

3. GPT-6 Luna: Fast, Budget Execution with Tunable Reasoning

GPT-6 Luna is OpenAI's high-speed, budget-conscious model built for high-throughput pipelines.

• What it delivers: Minimal latency, high throughput, and rock-bottom token pricing, alongside adjustable reasoning levels so you can dial in extra depth when a task requires it.
• Best workflow fit: Bulk classification, scheduled ingestion scripts, rapid triage routines, conversational bots, and large-scale data transformation runs.
• How to use it: Point background monitor jobs, scheduled scrapers, and high-frequency sub-agents at Luna to keep operational spend predictable.

Summary: Matching Models to Tasks

You can start using Claude Opus 5.5, GPT-6 Sol, and GPT-6 Luna immediately from the model picker in chat or configure them directly inside your agent settings.

Every AI workload has different trade-offs. Complex refactoring demands deep frontier reasoning, interactive agents need instant response loops, and large data ingestion runs require rock-bottom token pricing.

To cover these distinct profiles, we have expanded our catalog with options from xAI, Z.AI, and Xiaomi.

Here is what each model brings and where it fits in your setup.

1. Grok 4.7: Flagship Agentic Execution

Grok 4.7 is xAI's latest flagship model designed for complex coding, structured data extraction, and multi-step agent actions.

• What it delivers: Higher benchmark performance than Grok 4.6 across coding and logical problem solving, delivered at a 20% lower price point per token.
• Best workflow fit: Heavy refactoring, writing complex task scripts, parsing unstructured payloads, and deep analytical research.
• How to use it: Switch to Grok 4.7 in your main chat session for technical tasks, or set it as the primary brain for sub-agents managing code generation and technical research.

2. GLM 5.3 FlashX: Snappy Interactive Loops

GLM 5.3 FlashX from Z.AI is an ultra-fast variant engineered specifically for low-latency response cycles.

• What it delivers: Instantaneous time-to-first-token and high output velocity. It cuts down execution delay during chained tool calls.
• Best workflow fit: Fast conversational back-and-forth, status pings, triage routines, and interactive task coordination where waiting for a heavy frontier model slows you down.
• How to use it: Ideal for background monitor jobs, Telegram bots, or lightweight conversational interfaces where speed matters more than complex multi-page reasoning.

3. MiMo-V2.6-Pro: Open-Weights Multimodal Flagship

MiMo-V2.6-Pro is Xiaomi's new 1T+ parameter open-weights flagship.

• What it delivers: Native omnimodal capabilities paired with controllable reasoning effort. It processes visual inputs, documents, and code side by side while giving you direct control over how deeply the model plans before answering.
• Best workflow fit: Visual QA on design layouts, document parsing, multimodal charts, and tasks that require verified multi-step reasoning before taking action.
• How to use it: Deploy it for visual review gates, slide analysis, or complex workflows that combine vision with tool execution.

4. MiMo-V2.6-Flash: High-Throughput Multimodal Processing

MiMo-V2.6-Flash is Xiaomi's budget Mixture-of-Experts (MoE) model built for volume.

• What it delivers: Full multimodal input handling at rock-bottom pricing and high throughput.
• Best workflow fit: Processing hundreds of images or documents in bulk, continuous web scraping audits, data classification pipelines, and scheduled ingestion jobs where frontier token costs would add up quickly.
• How to use it: Perfect for background jobs running on intervals, scheduled data crawlers, or high-volume scraping tasks that need multimodal intelligence on a tight budget.

Summary: Matching Models to Tasks

Conductor Mode Evaluation

All four models are available immediately for direct use in chat and dedicated agents. At the same time, we are evaluating them for inclusion in Conductor Mode.

Conductor Mode combines classification algorithms, task heuristics, and TypeSafe's Jev engine to match each prompt to the most efficient model based on speed, cost, and capability. Once these models pass our latency and accuracy benchmarks across agent tool-calling loops, we will roll them into Conductor's automated routing pool.

You can select any of the new models today from the model picker in chat or configure them directly in your agent settings.

Most work still happens locally: spreadsheets sitting in your Downloads folder, code repositories on your drive, and PDFs waiting on your Desktop. If you have been looking for an autonomous AI agent for Mac that can safely interact with those local files while keeping the power of an always-on cloud engine, running local-only tools usually meant compromises.

Today, we are bridging that gap. The Starchild desktop app for macOS connects your physical Mac directly to your 24/7 cloud AI agent.

The Best of Both Worlds: Always-On Cloud, Hands-On Local

Before this release, running an AI desktop assistant locally meant that closing your laptop lid stopped your agent cold. If your Mac went to sleep, your automated schedules, monitoring routines, and long-running workflows stopped with it.

With Starchild, your agent runs 24/7 in the cloud. It keeps monitoring feeds, executing scheduled jobs, and helping you across sessions without relying on your laptop staying awake or draining your battery.

The desktop app simply opens a secure, private bridge between your cloud agent and your machine whenever you want to collaborate on local files.

When connected, your agent can:

• Read project files, spreadsheets, or raw datasets directly from designated local directories.
• Write generated assets, code drafts, and research deliverables directly to your machine.
• Run allowlisted terminal commands such as node, npm, or ls locally to inspect build output.

Your Files, Your Rules: Permission-Scoped Security

Granting an AI agent access to your personal computer should never require handing over unrestricted control. The desktop bridge is built with strict boundary enforcement from day one:

• Explicit folder allowlists: You choose exactly which directories your agent can access, such as ~/Downloads, ~/Documents, or ~/Desktop.
• Revocable anytime: You can modify folder permissions or sever the pairing instantly from the desktop menu.
• Sensitive data remains off-limits: The bridge strictly blocks access to SSH keys (~/.ssh), shell configurations (~/.zshrc, ~/.bashrc), browser profiles, and hidden system credentials.
• Safe execution policies: Destructive shell commands (such as recursive deletes or privilege escalation) are rejected by default.

Getting Started in Four Steps

Setting up takes less than two minutes:

1. Download the build: Grab the macOS installer directly from iamstarchild.com/download.
2. Install the application: Open the DMG file and drag Starchild into your Applications folder.
3. Pair your agent: Launch the app, ask your cloud agent for a pairing key, and paste it into the prompt.
4. Grant local folders: Pick the directories your agent is permitted to read and write.

If you prefer package managers, install via Homebrew:

brew tap starchild/tap https://github.com/Starchild-ai-agent/homebrew-tap
brew trust starchild/tap
brew install --cask starchild-app-release

A companion CLI binary is also available for lightweight terminal pairing:

curl -fsSL https://workroom.iamstarchild.com/install/cli | bash
starchild login <pairing-key>

The First Step in the Starchild Device Ecosystem

The macOS release is just the beginning of our multi-surface vision. Work happens across all devices, and agents should be available wherever you operate.

Dedicated native applications for iOS and Android are already in development, bringing your autonomous agents, notifications, and approvals into your pocket.

Help Shape the Future: Try It and Tell Us What You Think

We built this desktop application for people who build, research, and execute real work every day. Because this is a fresh release, real-world feedback is essential.

We invite you to take the desktop app for a spin:

• Download the macOS release at iamstarchild.com/download.
• Connect it to your agent and test your real-world workflows: code audits, local document analysis, or report exports.
• Tell us what works smoothly, what feels clunky, and where you encounter interesting edge cases.

Share your thoughts in the Starchild community or reach out directly to the team. Your feedback guides the next set of updates.

Today that routing layer got a major upgrade. Conductor Mode 4.0 features Jev, the decision engine released yesterday, September 17, by TypeSafe, the startup founded by a former OpenAI co-founder. With Jev on the routing hop, classifying each message is now 20x cheaper and about 6x faster than before. And because Jev is so inexpensive to run, we are not passing the cost on to you: we absorb it entirely. Conductor Mode costs exactly what it did before, and every message gets classified and dispatched almost the instant you hit enter.

Most users do not know which AI model is right for the job.

They try a cheaper model, hit its limits on a complex task, get frustrated, and switch to a premium model. Then they leave the premium model selected for everything, including the routine work that a much less expensive model could handle just as well.

That choice used to be simpler. When only a small number of models were genuinely capable, using the best available model for every request was reasonable. The quality gap was obvious, and there were fewer serious options to compare.

The market now looks completely different. Capable models span a widening range from low-cost reasoning models to ultra-high-cost frontier systems. They vary across reasoning, coding, tool use, speed, context, multimodal input, and structured output. More models arrive constantly, and small language models will make the landscape even more fragmented.

This creates a growing allocation problem for every AI product and agent: which model should handle this specific piece of work?

Expecting users to answer that question on every turn does not scale. Most will either overpay for routine tasks or accept unreliable results when the workflow becomes more demanding.

Conductor Mode solves the allocation problem automatically. It evaluates the structure of each task and routes it to the least expensive model equipped to complete it reliably.

The decision does not depend on topic, prompt length, or how technical the request sounds. A dense math problem may need one clean reasoning pass. A two-word reply such as “do it” may continue a workflow involving external data, tool calls, and irreversible actions. The structure of the work is what matters.

How Conductor Mode works

Every time you ask your agent to do something, Conductor Mode asks two simple questions.

1. Does the agent need to complete multiple steps in a specific order?

Some tasks can be answered immediately. Others require the agent to complete one step before it can begin the next.

For example, if you ask, “What is Bitcoin’s price right now, and how has it changed this week?”, the agent must first fetch the current price and historical data. Only then can it calculate the change and answer you.

Research works the same way. The agent may need to search, read several sources, compare what it finds, and then reach a conclusion. Each step depends on the result before it.

This also applies when the agent must read a file, check an account balance, query an API, run code, or verify that an action succeeded.

If the answer depends on information or work the agent must complete first, Conductor Mode sends the task to the strong model.

2. Does the answer need to follow exact instructions so another system can use it?

Sometimes an answer can be useful even if the wording or layout varies. At other times, “almost right” means the task fails.

A tool call must contain the correct fields. Data sent to another application must follow the expected format. Code may need to pass a test. A report may need specific sections that another workflow relies on.

If the result must follow an exact structure or set of instructions, Conductor Mode sends the task to the strong model.

If the answer to both questions is no, the task goes to the low-cost reasoning model. This covers self-contained work such as explanations, brainstorming, rewriting, and many math or coding questions.

What happens when the strong model still needs help?

There are three levels, not two:

1. Low-cost reasoning: handles self-contained everyday work.
2. Strong: handles multi-step work, live data, tools, and exact output requirements.
3. Escalation: a stronger model takes over when a task needs more capability or the strong route cannot complete it reliably.

Conductor Mode chooses between the first two levels at the start. The third is a safety net for the difficult cases. The specific model assigned to each level is reviewed and updated as the available models change, so the routing policy stays current without changing how the workflow decision works.

Images and other multimodal requests use a separate media route with a model designed for visual input.

Topic, prompt length, and how technical a request sounds do not make this decision. The structure of the work does.

Why single-pass math and code can stay cheap

The economy leg is assigned to a cost-efficient reasoning model. The exact model can change as new options are evaluated.

Its role matters because “cheap” no longer means “incapable of reasoning.” A capable reasoning model allows single-pass math, code, analysis, explanations, and other self-contained tasks to remain cost-efficient.

Consider two requests:

• “Explain why this sorting function is O(n log n).”
• “Inspect this repository, find the performance regression, modify the implementation, run the tests, and return the patch in the required format.”

Both concern code. Their workflow structures are completely different.

The first request can be answered directly. The second requires several steps in order, plus an exact deliverable at the end. Conductor Mode routes them accordingly instead of sending both to the same model because they share a topic.

This is the central idea behind cost-aware model routing: spend more intelligence when the workflow needs it, while keeping capable everyday reasoning inexpensive.

The benchmark: four suites, objective scoring

The latest Conductor Mode report compares multi-model routing against single models and frontier baselines on a mixed-150 public set. The equal-weight composite covers four suites: AIME 2025, GPQA Diamond, LiveCodeBench 100, and Everyday tasks. Cost is the mean dollars per task across those four suites, and only models that completed all four are included in the composite ranking.

The benchmark report records one model assignment at a particular point in time: DeepSeek V4 Flash for economy work, GPT-5.6 Luna at xhigh for strong work, and Qwen 3.8 Max for escalation. Images routed to Luna, video routed to Qwen 3.8 Max, and the fallback path was Luna → Qwen 3.8 Max → DeepSeek V4 Flash. These assignments are examples from that benchmark snapshot, not permanent product dependencies. Conductor Mode reviews them regularly and can replace them as model quality, pricing, and availability change.

The report also notes that older Conductor versions are excluded from the four-suite composite because it never ran the GPQA or LiveCodeBench pools. This keeps the comparison aligned to measured runs rather than mixing incomplete result sets.

Conductor is not trying to beat Kimi on raw accuracy. In the full benchmark, it trails by 3.9 percentage points at roughly one-seventh the cost. On everyday tasks, where most real traffic lands, the gap narrows to about 2.6 points at roughly 1/8.5 the cost. When a task is genuinely difficult, Conductor Mode can route up to a stronger model instead of paying that premium for every request.

Read the full Conductor Mode benchmark report.

What changed from Conductor Mode V2

Earlier versions used a simpler system for deciding which model should handle a request. Conductor Mode V2 improved this by testing models on real agent tasks and choosing them based on the results. This update keeps that testing process, while making the routing itself smarter and more reliable.

• Better task matching: requests involving several connected steps or an exact required format are sent to a stronger model.
• Lower-cost reasoning: the current economy model handles self-contained work, including many math and coding questions, without automatically using a more expensive model.
• Extra help for difficult tasks: if the first model cannot complete the job reliably, the current escalation model can take over.
• Fewer failed requests: if the first routing decision fails, Conductor Mode tries again and has backup models ready.
• Smarter follow-up handling: short replies such as “do it” are understood as part of the task already in progress.
• Better handling for images: requests involving visual content are sent to a model designed for that type of input.
• Easier to improve over time: the routing rules can be updated as models improve, without rebuilding the entire agent system.

Explore the technical overview, or create a Starchild agent and let Conductor Mode choose the right model for the work.

Frequently asked questions

How does Conductor Mode choose a model?

Conductor Mode checks whether the request requires multiple steps in a specific order or an answer that must follow exact instructions. Either condition sends the task to the strong model. If neither applies, the task uses the low-cost reasoning model. A third escalation level handles the most difficult cases. The models assigned to these levels are updated regularly, so the names in any benchmark report should be read as a dated snapshot.

Does technical content always use the strong leg?

No. Topic, prompt length, and technical tone are ignored. A self-contained coding or math request can remain on the low-cost reasoning model if it does not require several connected steps, fetched data, tools, or an exact output format.

Why does fetched data use stronger handling?

The agent must retrieve the information before it can form the answer. Sending these tasks to the strong model reduces the risk of inventing missing facts and improves how the agent handles the retrieved data.

How does Conductor Mode reduce AI agent costs?

It uses a cost-efficient reasoning model for self-contained work and reserves stronger models for tasks involving multiple connected steps or exact output requirements. The escalation model is used only when needed.

How was Conductor Mode benchmarked?

Each model ran the full agent loop with real tools. Results were scored through objective exact-match, with code evaluated on the same grading harness. The benchmark used no LLM judge.

What result did Conductor Mode achieve?

The latest report measures an equal-weight composite across AIME 2025, GPQA Diamond, LiveCodeBench 100, and Everyday tasks. Its headline LiveCodeBench result for the routing ladder is 90%+ on the 99-problem same-set pool at about $0.02 per problem. These figures describe that benchmark run, while the live model assignments may change as the system is updated.

The honest framing: assistant vs agent

ChatGPT is an exceptional chat assistant. You open it, you ask, it answers brilliantly. That is its core loop, and it is the best in the world at that loop.

Starchild is built around a different loop. An agent here has persistent memory, runs on a schedule, holds its own tools and connected apps, and carries a task forward even when you are not in the conversation. You express an outcome, the agent works toward it, and you review the results later.

That second loop is what makes a one-person company possible. One person with an agent can run the morning brief, monitor positions, draft the week's content, and chase the inbox, the workload that used to require hiring. The comparison is less "which is smarter" and more "which loop does your work need."

Where ChatGPT fits

ChatGPT shines when the work is conversational and human-paced:

• Writing, editing, brainstorming, and quick research
• Analyzing a document you upload right now
• Agent mode for occasional multi-step tasks, run inside a sandboxed browser session

That last one matters. ChatGPT agent mode can browse, fill forms, and edit files, but it runs inside your chat session, with message caps (40 agent messages a month on Plus, 400 on Pro, per OpenAI's help center as of September 2026), and it stops when the session ends. Nothing persists between conversations: no memory of your workflows, no cron job, no wallet.

Where Starchild fits

Starchild is agent infrastructure. The differences that matter:

Memory that compounds. Your agent remembers your preferences, projects, and corrections across sessions. You stop re-explaining yourself.

Scheduling. Agents run on cron. A daily market brief at 8am, a weekly content batch, a monitoring job that pings you when something breaks. This is the single biggest structural difference: ChatGPT waits for you to open it, an agent works while you sleep.

Tools and connected apps. Gmail, Calendar, GitHub, Sheets, plus market data, trading, and on-chain wallets, 40+ integrations your agent can act through.

A wallet and payments. Agents can hold funds, sign transactions, and get paid via x402. A chat assistant cannot do any of that.

Hosted, so it's always on. Your agent runs on our infrastructure, not your laptop. It stays reachable from any device, web, Telegram, or WeChat, whether your home computer is on or not. Close your laptop and your scheduled jobs, monitors, and in-flight tasks keep running.

Access to all the models, routed intelligently. Instead of being locked to one provider's models, your agent draws on 40+ models, and Conductor Mode routes every task to the cheapest model expected to solve it well. Quick lookups run on fast, cheap models; hard reasoning quietly upgrades. You get frontier-quality answers without paying frontier prices on every step.

Cost comparison, September 2026

The fair caveat: if your work is 90% chatting, ChatGPT Plus at $20 is the better buy. Chat quality on OpenAI's frontier models is excellent and you should keep it for that.

The decision, plainly

Keep ChatGPT for thinking out loud with a model. Add Starchild when work needs to happen without you: recurring reports, monitoring, trading rules, multi-step research, anything with a schedule or a wallet attached. They solve different problems, and a lot of people will run both.

If the "it runs while I'm away" loop is the one you are missing, that is the gap Starchild fills. Start with one repetitive task, hand it to an agent this week, and see what your mornings look like when the agent already did the first pass. See how agents work at iamstarchild.com.

Related reading: What It Costs to Run an AI Agent in 2026 · You're Already Paying for AI. Make It Work Harder. · Starchild Conductor Mode V3: AI Model Routing

What an agent costs per task, September 2026

Text and research are nearly free. A daily research agent on a budget model costs about six cents per run, roughly $2 a month including search fees. DeepSeek's flash tier serves cached input at $0.003 per million tokens. If your agent reads and writes text for a living, compute is no longer the cost.

Coding is cheap when you route. The expensive way to code with AI is brute force: pointing one big frontier model at the whole job and letting it grind for hours at full price. The cheap way is routing: split the work into small steps, and send each step to the smallest model that can handle it. Most steps are easy, so most steps cost pennies; only the genuinely hard ones touch an expensive model. Starchild's Conductor Mode does this automatically. On LiveCodeBench 100 — a standard benchmark of 100 real coding tasks — it solves 97% of them for about 2.3 cents each. A full session becomes cents per task instead of dollars per hour. The price history explains why: Claude Opus was $15/$75 per million tokens at the 4.x generation, then dropped to $5/$25 with the Opus 4.5 price cut, and Anthropic even cancelled the price increase it had scheduled for Sonnet in their pricing schedule. Frontier capability keeps moving down the price ladder, and routing pushes real costs far lower.

Voice and video are still the exceptions. Text and coding got cheap; real-time speech and high-fidelity video have not. Voice is the bigger bill: OpenAI's GPT-Live-1 charges five cents a minute, so an agent handling 40 calls a day costs about $245 a month. Video is cheaper per generation but still priced like rendering rather than text: a 10-second clip on a flagship model like Seedance 2.5 runs around $2.30 at 720p, about 23 cents per second (MindStudio's pricing review). Drop to 480p and it halves to roughly a dollar. If your agent produces a full content package including video, that single generation will dominate the bill.

The pattern across text and code is the same: the floor keeps dropping. Sonnet-class intelligence went from $3/$15 to $2/$10 per million tokens. Opus-class went from $15/$75 to $5/$25. Conductor routing undercuts both by spending pennies per solved task. Whatever your text and coding agents cost today, expect them to cost less next quarter. Voice and video have not dropped yet; that is where the next price break has to happen.

The real constraint is no longer the model bill for thinking. It is you: setting the agent up, checking its work, re-running failed steps, and personally managing every decision in between. That is what Starchild removes. Instead of operating the tools yourself, you express what you want, and your agent carries the work forward with its own memory, tools, and workflows. When agents become infrastructure, the hours you spent managing software go back to judgment, creativity, and the parts of the business only you can do.

If you have been waiting for the right moment to start, this is it. Thinking is nearly free, coding costs cents per task, and the only thing standing between you and your first agent is the decision to build one. Start small: hand one repetitive task to an agent this week, learn how it reasons, then give it more. Every person who learns to direct agents now is buying leverage that compounds. Jump in and start learning with AI, because the cheapest time to begin was six months ago and the second cheapest time is today.

Starchild bundles 40+ models with memory, tools, scheduling, and connected apps from $19 a month with a $2 daily cap, or $0 to start on pay-as-you-go. See what intent-based agents look like at iamstarchild.com.

Pear also supports basket trades, where you go long or short across a group of tokens in a single trade. This lets you take a view on a sector, a category, or a market thesis, rather than picking one asset against another. For example, if you were bearish on the economy, you could go long a single safe-haven asset like gold and short a basket of tech stocks, diversifying your exposure across a broader theme.

On top of that, Pear gives you TP/SL on the spread ratio itself (not on individual legs), limit and TWAP orders for better entry execution, and a unified dashboard showing PnL, net funding, and position metrics for both legs together. The cross-margin structure means gains on your short leg can offset drawdowns on the long — Pear calls this scam-wick protection.

This article explains the concept, how to connect, and a simple first trade.

What is a Pear Protocol pair trade?

A Pear Protocol pair trade combines two positions: a long leg on one asset and a short leg on another. For example, you could research a BTC/ETH pair to understand whether one asset may outperform the other over a chosen time horizon. Because both legs move together, you are less exposed to the direction of the overall crypto market and more focused on the relative performance of BTC versus ETH.

Pair trading still involves leverage, funding costs, liquidity constraints, slippage, and loss risk. Hedging one leg does not remove those risks. Use the agent to research and plan before committing to a position.

Connect Pear Protocol's MCP to Starchild

Pear Protocol's MCP gives a Starchild agent a standard way to discover and use Pear's available tools. To get started:

• Deploy a Starchild agent. Go to Starchild and deploy an agent. You can be up and running in a few minutes with no code required.
• Install the Pear Protocol skill. Open the Skills area and install the Pear Protocol skill. The skill helps the agent work with Pear's pair-trading tools and MCP connection.
• Connect or authorise Pear. Follow Pear's current MCP connection and account-authorisation instructions from Pear Protocol's documentation.
• Start with exploration. Begin with a research or planning request before taking any live action.

Starchild agents include a native wallet for on-chain actions including deposits, withdrawals, and transaction signing. Pear account access, API credentials, and any required permissions follow Pear's own setup and authorisation requirements.

Try these starter prompts

Start with a plain-language explanation so the agent can orient you before any numbers are involved:

What is a Pear Protocol pair trade? Explain the long leg, short leg, relative-performance idea, and the main risks. Do not execute anything.

Then ask for research on a specific pair:

Research a BTC/ETH pair on Pear Protocol. Show the relative-performance context, funding, liquidity, risks, and what could invalidate the idea.

If you want to explore baskets:

What basket trades are currently available on Pear? Summarise what market view or narrative each one expresses and what assets it includes. Do not execute anything.

Once the research is useful, ask for a plan before any execution:

Prepare a pair-trade plan for my review. Show both legs, direction, notional, leverage, margin mode, estimated costs, and invalidation conditions. Do not execute it yet.

Review the plan, ask follow-up questions, and only approve it when you are satisfied with every detail.

Review before you approve

Before confirming any trade, ask the agent to walk through:

• Both legs — asset, direction, size, and leverage
• Net funding rate across the pair
• Liquidity and slippage estimates for each leg
• The conditions under which the trade idea would be invalidated
• Any margin or liquidation thresholds

Pair trades are two simultaneous positions. Reviewing each leg independently and the spread as a whole gives you a clearer picture than looking at one side at a time.

There is no limit to what you can build once the connection is in place. As you get comfortable with the workflow, you can develop strategies that balance different asset classes, account for macroeconomic conditions or geopolitical events, and move between individual pairs, basket trades, and blue-chip stocks in the same session. As Pear Protocol expands its supported assets, the range of pairs your agent can research, plan, and act on will grow with it.

Start trading on Pear Protocol

Sources

• Pear Protocol
• Pear Protocol documentation
• Starchild

This article is educational content about agent workflows. It is not investment, financial, or trading advice. Pair trading involves leverage and carries significant risk of loss.

Buying a tokenized stock usually involves several disconnected tasks: finding an available asset, checking eligibility, moving USDC to the right chain, getting a quote, signing a transaction, and confirming the result. A Starchild agent brings those steps into one workflow while keeping the wallet and approval rules visible.

This guide focuses on the practical path to a first trade through Treasures Finance. Product availability depends on the issuer, chain, wallet, jurisdiction, KYC status, and transfer rules. Check eligibility before you fund or trade.

What can you buy through Treasures Finance?

Treasures Finance provides access to tokenized equities from issuers such as xStocks and Ondo, with supported products traded against USDC on Solana or Ethereum. The exact catalogue changes, so the agent should query the live list before making a recommendation.

The main asset categories are:

• Tokenized shares of individual companies, where the issuer and route make the product available to you.
• Tokenized equity products with broader market exposure, when an eligible issuer lists that product on the supported route.
• Other tokenized real-world assets offered through the Treasures catalogue, subject to the product's own eligibility and transfer rules.

The token is an onchain representation governed by the issuer's structure. It does not make every conventional stock market feature available automatically. Trading hours, redemption, corporate actions, liquidity, fees, and legal rights depend on the specific product.

Treasures uses USDC as the settlement asset for the supported stock routes. That makes your starting balance and destination chain important. Having USDC in a wallet is not enough if it sits on a chain the selected trade cannot use.

Step 1: Create an agent on Starchild

Create an agent on Starchild, give it a useful name, and connect the wallet you want to use for the workflow. Starchild's Privy-powered Agent Wallet lets the user retain control of the wallet while the agent coordinates approved onchain actions.

Read the Starchild Agent Wallet guide for the wallet model.

Step 2: Install the Treasures Finance skill

Open the Skills area in Starchild and install the Treasures Finance skill. The skill gives the agent the workflow for:

• Discovering available tokenized stocks
• Reading portfolios and trade history
• Requesting buy and sell quotes
• Executing supported trades
• Bridging USDC between supported Solana and Ethereum routes
• Checking the result after settlement

The skill supports two integration patterns. With the default B2B API flow, your Privy or EOA wallet remains the signing authority. A separate delegated-wallet flow uses a Treasures-provisioned wallet with a narrowly scoped API key. Use the model that matches where your assets live and the permissions you have explicitly approved.

The agent should begin with discovery. Ask it to list the eligible products, issuer, chain, current quote availability, and the USDC balance it can use. That gives you a current asset list instead of relying on an old example or ticker.

Step 3: Fund the wallet on the right chain

Ask the agent which chain supports the asset you want before moving funds. Treasures supports tokenized-equity routes on Solana and Ethereum, but each product and wallet route can have its own requirements.

Fund the destination wallet with:

• Enough USDC for the intended purchase and fees
• The chain's native gas asset, where the route requires it
• A little extra room for quote changes or bridge costs, if you approve that risk

You have two options:

Fund the destination chain directly

Send or deposit USDC to the wallet on the chain selected for the trade. This is the simplest route when you already hold funds there. Confirm the destination address, chain, token, and amount before sending.

Bridge USDC first

If your USDC is on another supported chain, ask the agent to prepare a separate bridge quote. Review the expected output, fees, destination chain, and wallet address. Approve the bridge, then verify the destination balance before requesting the stock quote.

Keep bridging separate from the stock purchase. It gives you a clean checkpoint and prevents an unexpected funding action from being bundled into a trade.

Step 4: Tell the agent what to buy, or use it for research

If you already know what you want, tell the agent the exact asset and amount. For example:

Buy 1 SPCX stock using the Treasures skill.

The agent can then help check whether that asset is available to your wallet, whether you are eligible to buy it, and whether the wallet has enough USDC on the required chain. You can make the instruction more specific by adding a maximum budget, a slippage limit, or a requirement to ask for approval before submitting the trade.

If you do not know what to buy yet, use the agent as a research tool first. It can help identify:

• Tokenized assets currently available through Treasures
• Recent asset performance and price history
• 13F holdings reported by major funds
• Technical-analysis indicators and chart trends
• Differences between issuers, products, chains, fees, and eligibility requirements

Start with a research question, compare the results, and decide what fits your own goals and risk limits. The agent can organize the information and check live availability, while the final investment decision remains yours.

Treasures' read endpoints can return stock, portfolio, and trade information. The catalogue is the source of truth for what is available now.

What the agent can do after the first trade

Once the first purchase is verified, the same agent can provide a read-only portfolio view, monitor balances, compare exposure with your allocation rules, and alert you when a product or wallet state needs attention.

You can later add scheduled reconciliation or a repeatable allocation strategy. Add one permission at a time. Read, quote, sign, submit, and verify should remain separate stages that you can inspect and pause.

Build your first tokenized-stock workflow

Treasures Finance supplies the asset and execution layer. Starchild supplies the agent context, wallet controls, skills, and verification loop around it.

Start here:

1. Create your Starchild agent.
2. Install the Treasures Finance skill.
3. Decide what you want to buy, or ask the agent to research eligible assets.
4. Fund the wallet with USDC on the selected chain, then tell the agent the asset and amount.

Create your agent on Starchild and build a tokenized-asset workflow around the products, policies, and approval boundaries you actually want to run.

Sources

• Treasures Finance
• Treasures Finance agent skills
• Starchild's Privy-powered Agent Wallet guide
• Treasures Finance tokenized stock coverage

This article is educational content about agent workflows and tokenized assets. It is not investment, legal, tax, or eligibility advice. Product availability, issuer requirements, and supported routes can change.

Hyperliquid has become one of the most interesting onchain venues for crypto perpetuals, real-world assets through HIP-3, and outcome markets through HIP-4.

Why use Starchild to trade on Hyperliquid?

Starchild has several advantages that make it better than other agents for trading onchain:

1. Native Hyperliquid skill. Research markets, manage leverage, place orders, set take-profit and stop-loss levels, and verify fills through a venue-specific workflow.
2. Built-in Agent Wallet. Sign onchain transactions and handle deposits, withdrawals, swaps, and bridges within approved permissions.
3. Premium data APIs. Analyze options, open interest, funding, liquidations, crypto markets, US stocks, Chinese stocks, forex, and commodities.
4. Scheduled Jobs. Automate position checks, risk alerts, reconciliations, and daily trading reports.
5. Custom dashboard hosting. Build live interfaces for positions, PnL, margin, orders, funding, and strategy health.

The Skills Hub packages trading execution, premium market data, analytics, monitoring, and development tools into installable collections.

Connect Starchild to Hyperliquid

There are three ways to connect, depending on how you want to trade.

Option 1: Use the built-in Agent Wallet

Every Starchild account includes a Privy-powered Agent Wallet. It is non-custodial: Starchild does not hold the complete private key or take custody of the funds, and the user can export the key and move the wallet elsewhere. Fund it with USDC, ask Starchild to deposit into Hyperliquid, and trade natively within approved permissions and limits.

Find your Agent Wallet: open Account Balance, scroll to Agent Wallet, then select View.

Option 2: Connect a Hyperliquid API wallet

Existing Hyperliquid traders can open the Hyperliquid API page, connect the master account, create a dedicated API wallet, and authorize it to trade. This option offers greater security separation: the master account can remain protected by a hardware wallet, while the dedicated API wallet can trade but cannot withdraw. Add the API wallet key to Starchild through the secure credentials flow, never in chat, then provide the master account address for account queries. This setup requires more manual configuration and approval than the built-in Agent Wallet, but gives security-conscious traders tighter separation between custody and execution.

Create and authorize an agent wallet from the Hyperliquid API page. It can trade for the account without withdrawal permissions.

Option 3: Use a third-party Hyperliquid builder with extra features

Pear Protocol adds market-neutral pair and basket trading through its MCP tools, including pair analytics, ratios, funding, basket construction, rebalancing, and position management. Pear routes the legs to Hyperliquid through a separately authorized trading account, while collateral stays on Hyperliquid.

Degen Claw adds a competitive layer for Virtuals ACP agents. Agents trade Hyperliquid perpetuals with real USDC, publish reasoning to public signal forums, and compete on a seasonal leaderboard. Its registration and leaderboard infrastructure is separate, while trades are signed by the agent wallet and executed on Hyperliquid.

For another embedded-agent trading model, see how Starchild AI agents work inside Orderly-powered exchanges.

Fund the account and start trading

The simplest flow is to fund the Starchild Agent Wallet with USDC and ask the agent to handle the Hyperliquid deposit. If the wallet does not already have USDC on Arbitrum, the Starchild Swap and Bridge skill can find an executable route to swap or bridge supported assets first. With an external Hyperliquid account or specialized platform, Starchild can handle the funding steps permitted by the connected wallet and guide any step that still requires the user's signature.

Please note: the first time you trade, you will be asked to approve two transactions. The first enables trading through the Agent Wallet. The second approves the Starchild builder code, which lets agent-submitted orders interact with Hyperliquid under the approved fee limit. Both approvals can be reviewed before signing.

Once the account is funded, users can trade in natural language:

Great, now let's slam our $1,000 into SPACEX

The agent can find the market, check the available margin, leverage limits, order-book liquidity, and existing exposure, then presents or executes the order according to the user's approval policy. The same workflow covers native crypto perps and HIP-3 markets for stocks, commodities, and indices.

A more deliberate prompt can ask for research before execution:

Analyze the Hyperliquid gold perp. Check the current trend, recent volatility, order-book liquidity, and funding. Propose an entry, invalidation level, maximum loss, and two exit scenarios. Do not trade yet.

Build a strategy instead of placing one trade

Different strategies suit different market conditions, time horizons, and risk tolerances:

• Trend trading: Follow sustained upward or downward momentum until evidence suggests the trend is reversing.
• Range trading: Trade between established support and resistance while the market remains within a defined range.
• Breakout and reversal trading: Enter when price escapes an established range, or position for an existing trend to change direction.
• Momentum and gap trading: Act on accelerating price moves or sharp repricing caused by news and market events.
• Pairs trading and arbitrage: Trade relative-value opportunities between related assets, potentially reducing exposure to the market's overall direction.

Chat with your Starchild agent about what you want to achieve, whether that means building a position gradually, trading a range, following momentum, hedging an existing portfolio, pursuing a market-neutral opportunity, or executing a large order efficiently. The agent can explain suitable strategies, compare their risks, and help define entry, sizing, exit, and invalidation rules before any trade is placed.

Once the strategy has evidence behind it, Starchild can keep each strategy and asset universe separate, including its rules, allocated capital, positions, orders, performance, and logs. A shared execution layer checks balances and permissions, submits orders, and reconciles expected results against the live account. An independent risk layer can block execution when exposure, leverage, drawdown, or margin crosses its approved limits.

A better starting prompt is:

Hey, I want to build a quant strategy. You are the CIO.

Observe every layer, find issues, compare performance, and escalate exceptions.

1. Give each strategy its own independent system: one asset, one strategy, one system. Keep rules, capital, positions, orders, performance, and logs separate.

2. Build an independent execution engine that understands routing rules, checks balances and permissions, selects the correct venue, submits orders, and verifies results. Use the relevant Starchild skills.

3. Build an independent risk layer that monitors total margin, balances, exposure, leverage, drawdown, and stop-loss rules. It must be able to block execution.

4. Add a self-learning loop that observes results, identifies problems, compares what worked, and proposes improvements and new ideas.

Ask me for the asset, strategy, capital allocation, and maximum risk. Show me the system before taking live action.

Monitor the strategy with scheduled Jobs

Once the strategy is running, ask Starchild to create scheduled Jobs that track positions, margin, open orders, fills, funding, liquidation distance, and strategy health. The strategy maintains its own operating log, but the Job reconciles that log against the live Hyperliquid account and onchain position state. This catches missing fills, stale orders, unexpected exposure, margin drift, and processes that stopped without reporting an error.

A practical setup combines exception-based monitoring with one daily report. Frequent checks should ping the user only when they find a red flag; healthy checks stay silent. At 8:00 a.m. in the user's timezone, a separate Job sends a daily reconciliation of positions, realized and unrealized PnL, funding and fees, margin, overnight exceptions, and recommended actions for the next trading day.

Set up a scheduled monitoring Job for this strategy. Reconcile its logs, expected orders, and expected positions against the live Hyperliquid account and onchain state. Check positions, margin, leverage, liquidation distance, open orders, fills, funding, PnL, and whether every strategy process is healthy. If you find a red flag, ping me with a concise summary, severity, evidence, and recommended action. If everything is healthy, stay silent. Also send me a daily report at 8:00 a.m. in my timezone with reconciled positions and PnL, funding and fees, exceptions from the previous day, and recommended actions for the next day. Show me the schedule, alert rules, and estimated running cost before activating the Jobs.

Create a custom trading dashboard

Traders who want a hands-on view can ask Starchild to build a custom dashboard around the same reconciled data. It can show live positions, margin, leverage, liquidation distance, open orders, recent fills, funding, realized and unrealized PnL, strategy status, risk alerts, and the difference between the strategy log and actual account state. The dashboard becomes the operating interface, while scheduled Jobs continue monitoring in the background.

For a quick read-only view without building anything, paste the wallet address into HyperTracker to inspect positions and performance, or use HypurrScan and the official Hyperliquid Explorer to inspect onchain account activity.

Build me a read-only dashboard for this Hyperliquid strategy. Show positions, margin, leverage, liquidation distance, open orders, fills, funding, realized and unrealized PnL, strategy health, recent alerts, and reconciliation differences between the strategy log and live account state. Add clear red-flag indicators and a daily performance view. Do not add trade controls until I approve the read-only version.

Start trading with Starchild

This should give you everything you need to get started. Join the Starchild Telegram community to share strategy ideas and feedback, or reach out if you need help connecting your account, choosing a strategy, or placing your first trade.

Sources

• Hyperliquid: HIP-3 builder-deployed perpetuals
• Hyperliquid: How to start trading
• Hyperliquid: Perpetual assets
• Hyperliquid: Order types
• Hyperliquid: Funding
• Hyperliquid: Robust price indices
• Hyperliquid API: USDC deposits

The short answer has three parts:

1. Use an efficient model for routine work: rewrites, explanations, summaries, and single-pass problems.
2. Use a stronger model for complex workflows: multi-step research, repository debugging, tool-heavy tasks, and exact-format outputs.
3. Switch between the two automatically, delegating routine work down and escalating when the efficient route is not enough.

That is the whole idea. The hard part is who does the switching. Today, most teams do it one of three ways: manually, with one premium model for everything, or with a simple router. Each one leaks money in a different place.

Option 1: switch models manually

The most common starting point is a human picking the model.

You try a cheaper model, hit its limits on a hard task, switch to a premium model, and then leave the premium model selected for everything. Or you keep switching per request, judging each task by hand.

Manual switching works for one person with a light workload. It breaks down for agents and products:

• Every request needs a judgment call, and judgment does not scale.
• The model landscape keeps moving, so yesterday's rule about which model is good enough goes stale.
• Under pressure, people default to the strongest model they have access to, which is the most expensive way to run routine work.

Option 2: one premium model for everything

This is where manual selection usually ends up.

A short rewrite, a supplied-text summary, and a multi-step repository investigation all consume the same expensive capacity. The premium model earns its price on the investigation. On the rewrite and the summary, you are paying for capability the task never uses.

It is the simplest policy, but the budget follows the model instead of the work.

Option 3: a simple router

The next step up is a rule-based router: send anything tagged "code" to the strong model, anything tagged "summary" to the cheap one, and so on.

Simple routers fail because topic is a weak signal for difficulty. What matters is execution structure.

"Explain why this sorting function is O(n log n)" and "inspect this repository, find the regression, fix it, run the tests, and return a patch" both contain the word code. The first is a self-contained explanation an efficient model can handle. The second needs file inspection, ordered tool calls, verification, and a precise deliverable.

A static rule cannot see that difference. It also cannot notice when a task changes shape mid-run, like a simple lookup that turns into a multi-step investigation after the agent finds conflicting data.

The result is the hidden cost of cheap failures. A weak route that fails creates retries, malformed outputs, failed tool calls, human cleanup, or a wrong action that must be repaired. The per-call price looked low. The completed task was not.

The best option: routing that reads the task

The switching job should not belong to a human or a keyword rule. It belongs to a router that looks at what the agent must actually do to finish the work.

That is what Conductor Mode does. It assigns each task by execution structure:

• Self-contained work (explain, rewrite, summarize supplied material, single-pass problems) goes to an efficient reasoning route.
• Connected workflows (research across sources, file inspection, debugging, several tools in sequence) go to stronger handling.
• Exact-output work (valid JSON, schema-compliant reports, patches another system will consume) gets stronger handling plus verification.
• Live data and external actions (current prices, account checks, transactions, publishing) get stronger handling and a verified result.

Two controls make the difference versus a simple router:

Verification. Conductor Mode checks outputs and tool results instead of assuming the cheap route succeeded. A confident-sounding answer is not proof the work completed. Catching a failure early means escalating one task instead of paying for several retries or passing a broken result downstream.

Escalation. The efficient route gets the first attempt when the task suits it. If the task is ambiguous, tool-heavy, exact-format, or the first attempt fails, the work escalates to stronger handling. Capability stays available exactly when it is needed, and the budget follows the difficulty of the work.

What the benchmark shows

This is not just architecture talk. Starchild's Conductor Mode V3 benchmark measured a mixed task set across AIME 2025, GPQA Diamond, LiveCodeBench 100, and Everyday tasks, using objective exact-match scoring, the same code grading harness, and no LLM judge.

Across the full four-suite comparison, Conductor Mode trailed the highest-accuracy single-model baseline by 3.9 percentage points while costing roughly one-seventh as much per task. On everyday tasks, the gap narrowed to about 2.6 points while cost was roughly 1/8.5 as high. On the 99-problem LiveCodeBench same-set pool, the V3 ladder reached more than 90% at about $0.02 per problem.

These are results from a dated benchmark snapshot, and model prices and assignments change. The durable finding is the tradeoff: task-aware switching preserves most of the measured quality while avoiding premium pricing on every request. The full Conductor Mode V3 article covers the technical methodology, while the earlier smart-routing value benchmark provides a separate cost-and-quality comparison.

How to apply this to your own agent

Even without Conductor Mode, the same logic works:

1. Classify by execution structure, not topic. Self-contained, multi-step, exact-format, live-data, or externally consequential.
2. Measure cost per completed task. Include retries, escalations, tool calls, and verification. A cheap call that fails is not a saving.
3. Define escalation triggers. Missing evidence, invalid output, failed tool execution, unresolved ambiguity. Escalate instead of repeating the same weak route.
4. Verify high-consequence work separately. Code changes, account operations, transactions, and external publishing need stronger handling and an independent check.
5. Re-test as the market moves. Track quality, completed-task cost, latency, and failure rate by workflow category, and update assignments when prices or capabilities change.

The point

Reducing AI agent costs does not mean sending every task to the weakest model. It means pairing an efficient model for routine work with a stronger model for complex workflows, and letting something competent do the switching.

Manual switching does not scale. One premium model overpays. Simple routers misread the task and hide the cost in failures. Task-aware routing with verification and escalation is the version that holds up, and that is what Conductor Mode is built to do.

Read the AI model routing benchmark report for the complete measured results. To test cost-aware routing on real workflows, create a Starchild agent with Conductor Mode.

FAQ

What is the best way to reduce AI agent costs?

Pair an efficient model for routine, self-contained work with a stronger model for multi-step, tool-heavy, exact-format, or high-consequence workflows, and switch between them based on the task. Measure cost per completed task, not cost per model call.

Can I just switch models manually?

You can, and it works for light personal use. It stops scaling once requests are frequent, because every task needs a judgment call and the model landscape keeps changing. Under pressure, manual selection tends to default to the most expensive model.

Why do simple routers underperform?

Keyword and topic rules cannot see execution structure. Two coding requests can need very different handling, and a task can grow more complex mid-run. Misrouted tasks fail, and retries, cleanup, and wrong actions cost more than the per-call savings.

Does routing reduce answer quality?

Routing creates a measured tradeoff. In the latest full Conductor Mode benchmark, the quality gap was 3.9 percentage points against the highest-accuracy baseline at roughly one-seventh the cost. Everyday tasks showed a gap of about 2.6 points at roughly 1/8.5 the cost.

When should an agent use the stronger model?

When the task requires several connected steps, live or retrieved information, exact output formats, tool execution, or a consequential external action. Escalate whenever the efficient route fails or the task is ambiguous.

Benchmark source: Conductor Mode V3 report, measured on AIME 2025, GPQA Diamond, LiveCodeBench 100, and Everyday tasks. Results are a dated benchmark snapshot and should not be read as a guarantee of future model performance or pricing.

x402 provides the payment layer for that market. A service can return 402 Payment Required, an agent can authorize the exact payment, and the request can continue without a subscription form, procurement process, or manually issued API key.

The payment flow already works at meaningful scale. The next challenge is building a marketplace with services agents will pay to use repeatedly, while making it much easier for developers to launch and monetize those services.

Our review shows an early market with real transaction activity, concentrated demand, and a visible supply led by data and search APIs. Those conditions create room for better products, stronger distribution, and a simpler buyer and seller experience.

Tracked settlement activity shows that x402 works as a payment mechanism. Continued adoption depends on stronger recurring use cases.

x402 adoption has moved beyond the experiment stage

The protocol has processed a meaningful number of small payments. That matters because agent commerce will often consist of low-value, high-frequency requests rather than large one-off transactions.

An agent may pay fractions of a cent for a market quote, a search result, an indicator, a wallet check, or a single transformation inside a larger workflow. Traditional subscriptions and account-based billing are poorly suited to that pattern. x402 lets payment happen at the point of use.

The current activity also shows an important limitation. Payment volume alone does not tell us how many independent buyers exist, how often they return, or whether vendors are building durable businesses. Those questions require a closer look at facilitators, services, payer activity, and chain distribution.

Facilitator activity is concentrated

Coinbase processes more than half of tracked x402 settlements, while a growing group of facilitators serves the rest of the market.

Coinbase is the largest facilitator in the tracked dataset. Dexter, PayAI, Daydreams, Pieverse, Heurist, FluxA, Virtuals Protocol, and a longer tail of smaller facilitators make up the remainder.

Concentration is expected in an early market. Developers tend to begin with the best-known infrastructure, and liquidity gathers around the paths with the most integrations. The useful signal is that the market already supports multiple facilitators and implementation approaches.

The next test is whether these payment rails support a broader and more differentiated service economy.

Search and data APIs lead the visible marketplace

Search, social data, market data, and business data account for much of the visible demand in the Coinbase-discovered marketplace slice.

The leading services reveal what agents are willing to buy today. Search and social data rank highly because they solve a common problem: models need current information that is unavailable in their training data. Market data, business enrichment, travel information, and inference services follow the same pattern.

These are useful products, but the payment wrapper alone creates limited differentiation. A service becomes valuable when it improves reliability, provenance, latency, coverage, or the quality of the final result. Agents need to know that a paid dependency will keep working inside an automated workflow.

The strongest vendors will package expertise and operational reliability, rather than simply resell access to an upstream endpoint.

The active buyer base is probably still measured in thousands

The available data supports a working estimate of roughly 3,000 to 7,000 active payer addresses, with substantial concentration among the busiest services.

The source reports 20,427 payer-to-service relationships but does not expose wallet identifiers that would allow direct deduplication. Assuming an active payer used three to seven paid services during the month produces an estimate of approximately 2,900 to 6,800 unique payer addresses, rounded to 3,000 to 7,000.

This is a scenario estimate, not a direct wallet count. It still provides a useful order of magnitude. x402 has an active market, but it remains early enough for a small number of better products and distribution channels to materially change adoption.

Activity is also concentrated. In the screened marketplace sample, 53.2% of calls came from vendors with unusually high calls per observed payer or very low payer diversity. That is a review flag, not evidence of artificial activity. It shows why transaction totals should be read alongside buyer diversity and repeat usage.

Base dominates settlement activity

• x402 has proven that agents can pay for digital services.
• Products remain unstructured, and buyer demand remains weak.
• Search and data services lead today, but many still lack the finished product experience that buyers are willing to pay for repeatedly.
• Agents and services remain fragmented across chains and marketplaces. Starchild is helping builders deploy across multiple marketplaces and reach more buyers.
• Builders need a shorter path from an idea to a deployed, priced, and discoverable service.
• Starchild's marketplace connects buyers and sellers in one agent-native environment.
• Starchild Relay gives agents one x402-compatible access layer for 17 data sources instead of 17 separate accounts and integrations.
• The next stage of x402 adoption will be measured by useful services, repeat buyers, and sustainable revenue for builders.

If you are building an agent, data product, tool, or paid service and want help deploying or monetizing it, come build with Starchild. If you are curious about the marketplace or want to explore a partnership, reach out to the team.

Most users do not know which AI model is right for the job.

They try a cheaper model, hit its limits on a complex task, get frustrated, and switch to a premium model. Then they leave the premium model selected for everything, including the routine work that a much less expensive model could handle just as well.

That choice used to be simpler. When only a small number of models were genuinely capable, using the best available model for every request was reasonable. The quality gap was obvious, and there were fewer serious options to compare.

The market now looks completely different. Capable models span a widening range from low-cost reasoning models to ultra-high-cost frontier systems. They vary across reasoning, coding, tool use, speed, context, multimodal input, and structured output. More models arrive constantly, and small language models will make the landscape even more fragmented.

This creates a growing allocation problem for every AI product and agent: which model should handle this specific piece of work?

Expecting users to answer that question on every turn does not scale. Most will either overpay for routine tasks or accept unreliable results when the workflow becomes more demanding.

Conductor Mode solves the allocation problem automatically. It evaluates the structure of each task and routes it to the least expensive model equipped to complete it reliably.

The decision does not depend on topic, prompt length, or how technical the request sounds. A dense math problem may need one clean reasoning pass. A two-word reply such as “do it” may continue a workflow involving external data, tool calls, and irreversible actions. The structure of the work is what matters.

How Conductor Mode works

Every time you ask your agent to do something, Conductor Mode asks two simple questions.

1. Does the agent need to complete multiple steps in a specific order?

Some tasks can be answered immediately. Others require the agent to complete one step before it can begin the next.

For example, if you ask, “What is Bitcoin’s price right now, and how has it changed this week?”, the agent must first fetch the current price and historical data. Only then can it calculate the change and answer you.

Research works the same way. The agent may need to search, read several sources, compare what it finds, and then reach a conclusion. Each step depends on the result before it.

This also applies when the agent must read a file, check an account balance, query an API, run code, or verify that an action succeeded.

If the answer depends on information or work the agent must complete first, Conductor Mode sends the task to the strong model.

2. Does the answer need to follow exact instructions so another system can use it?

Sometimes an answer can be useful even if the wording or layout varies. At other times, “almost right” means the task fails.

A tool call must contain the correct fields. Data sent to another application must follow the expected format. Code may need to pass a test. A report may need specific sections that another workflow relies on.

If the result must follow an exact structure or set of instructions, Conductor Mode sends the task to the strong model.

If the answer to both questions is no, the task goes to the low-cost reasoning model. This covers self-contained work such as explanations, brainstorming, rewriting, and many math or coding questions.

What happens when the strong model still needs help?

There are three levels, not two:

1. Low-cost reasoning: handles self-contained everyday work.
2. Strong: handles multi-step work, live data, tools, and exact output requirements.
3. Escalation: a stronger model takes over when a task needs more capability or the strong route cannot complete it reliably.

Conductor Mode chooses between the first two levels at the start. The third is a safety net for the difficult cases. The specific model assigned to each level is reviewed and updated as the available models change, so the routing policy stays current without changing how the workflow decision works.

Images and other multimodal requests use a separate media route with a model designed for visual input.

Topic, prompt length, and how technical a request sounds do not make this decision. The structure of the work does.

Why single-pass math and code can stay cheap

The economy leg is assigned to a cost-efficient reasoning model. The exact model can change as new options are evaluated.

Its role matters because “cheap” no longer means “incapable of reasoning.” A capable reasoning model allows single-pass math, code, analysis, explanations, and other self-contained tasks to remain cost-efficient.

Consider two requests:

• “Explain why this sorting function is O(n log n).”
• “Inspect this repository, find the performance regression, modify the implementation, run the tests, and return the patch in the required format.”

Both concern code. Their workflow structures are completely different.

The first request can be answered directly. The second requires several steps in order, plus an exact deliverable at the end. Conductor Mode routes them accordingly instead of sending both to the same model because they share a topic.

This is the central idea behind cost-aware model routing: spend more intelligence when the workflow needs it, while keeping capable everyday reasoning inexpensive.

The benchmark: four suites, objective scoring

The latest Conductor V3 report compares multi-model routing against single models and frontier baselines on a mixed-150 public set. The equal-weight composite covers four suites: AIME 2025, GPQA Diamond, LiveCodeBench 100, and Everyday tasks. Cost is the mean dollars per task across those four suites, and only models that completed all four are included in the composite ranking.

The benchmark report records one model assignment at a particular point in time: DeepSeek V4 Flash for economy work, GPT-5.6 Luna at xhigh for strong work, and Qwen 3.8 Max for escalation. Images routed to Luna, video routed to Qwen 3.8 Max, and the fallback path was Luna → Qwen 3.8 Max → DeepSeek V4 Flash. These assignments are examples from that benchmark snapshot, not permanent product dependencies. Conductor Mode reviews them regularly and can replace them as model quality, pricing, and availability change.

The report also notes that Conductor V2 is excluded from the four-suite composite because it never ran the GPQA or LiveCodeBench pools. This keeps the comparison aligned to measured runs rather than mixing incomplete result sets.

Cost versus quality across the four-suite benchmark. The upper-left shaded region marks the preferred tradeoff: higher accuracy at lower cost.

Conductor is not trying to beat Kimi on raw accuracy. In the full benchmark, it trails by 3.9 percentage points at roughly one-seventh the cost. On everyday tasks, where most real traffic lands, the gap narrows to about 2.6 points at roughly 1/8.5 the cost. When a task is genuinely difficult, Conductor Mode can route up to a stronger model instead of paying that premium for every request.

Read the full Conductor Mode benchmark report.

What changed from Conductor Mode V2

Earlier versions used a simpler system for deciding which model should handle a request. Conductor Mode V2 improved this by testing models on real agent tasks and choosing them based on the results. This update keeps that testing process, while making the routing itself smarter and more reliable.

• Better task matching: requests involving several connected steps or an exact required format are sent to a stronger model.
• Lower-cost reasoning: the current economy model handles self-contained work, including many math and coding questions, without automatically using a more expensive model.
• Extra help for difficult tasks: if the first model cannot complete the job reliably, the current escalation model can take over.
• Fewer failed requests: if the first routing decision fails, Conductor Mode tries again and has backup models ready.
• Smarter follow-up handling: short replies such as “do it” are understood as part of the task already in progress.
• Better handling for images: requests involving visual content are sent to a model designed for that type of input.
• Easier to improve over time: the routing rules can be updated as models improve, without rebuilding the entire agent system.

Explore the technical overview, or create a Starchild agent and let Conductor Mode choose the right model for the work.

Frequently asked questions

How does Conductor Mode choose a model?

Conductor Mode checks whether the request requires multiple steps in a specific order or an answer that must follow exact instructions. Either condition sends the task to the strong model. If neither applies, the task uses the low-cost reasoning model. A third escalation level handles the most difficult cases. The models assigned to these levels are updated regularly, so the names in any benchmark report should be read as a dated snapshot.

Does technical content always use the strong leg?

No. Topic, prompt length, and technical tone are ignored. A self-contained coding or math request can remain on the low-cost reasoning model if it does not require several connected steps, fetched data, tools, or an exact output format.

Why does fetched data use stronger handling?

The agent must retrieve the information before it can form the answer. Sending these tasks to the strong model reduces the risk of inventing missing facts and improves how the agent handles the retrieved data.

How does Conductor Mode reduce AI agent costs?

It uses a cost-efficient reasoning model for self-contained work and reserves stronger models for tasks involving multiple connected steps or exact output requirements. The escalation model is used only when needed.

How was Conductor Mode benchmarked?

Each model ran the full agent loop with real tools. Results were scored through objective exact-match, with code evaluated on the same grading harness. The benchmark used no LLM judge.

What result did Conductor Mode achieve?

The latest report measures an equal-weight composite across AIME 2025, GPQA Diamond, LiveCodeBench 100, and Everyday tasks. Its headline LiveCodeBench result for the V3 ladder is 90%+ on the 99-problem same-set pool at about $0.02 per problem. These figures describe that benchmark run, while the live model assignments may change as the system is updated.

Most video tools still make you bounce between a prompt box, an upload form, a queue, and a download page. That works for a one-off clip. It breaks down when video has to match a brand system you already run: logos in Drive, messaging in Docs or Notion, preferred shot length and resolution, and the same look every time you ask for a cut.

What Seedance 2.5 unlocks

Seedance 2.5 (ByteDance) is available through Starchild's video skill. In practice, that means your agent can drive generation with the same memory, files, and skills it already uses for everything else.

What you can ask for:

• Clips up to 30 seconds (or auto length)
• 480p or 720p output
• Image-to-video from a locked still
• Multi-reference control when you need consistent subjects or style
• Native audio, including timed voice lines when the shot needs them
• Seamless start/end frame locks for loops (same image as start and end)

The goldfish clip above is a one-shot Seedance 2.5 image-to-video example: a macro still of an orange fish around a dark tank subject, directed motion, and a short spoken line baked into the generation.

5s cut from a Seedance 2.5 image-to-video render on Starchild.

How the agent workflow works

You stay in chat. The agent handles model choice, duration, resolution, references, and file delivery. The important part is what sits around the model call.

1. Pull brand assets from where they already live

You do not have to rebuild a media library inside a video UI. Connect Google Drive, Google Docs, Notion, or other linked apps, then ask the agent to use the logo pack, product still, or brief that already exists there.

Examples that work in plain language:

• "Use the orange wordmark from our brand Drive folder."
• "Pull the hero still from last week's product doc."
• "Match the tone in the Notion launch brief, then generate a 5s Seedance clip."

The agent can read those sources, pick the right file, and feed it into image-to-video or multi-reference generation. Your source of truth stays in Drive or Docs. The video step consumes it.

2. Keep a brand registry the agent can reuse

For teams that generate often, put logos, colors, approved stills, fonts, and do/don't notes in a brand registry the agent can read every time. On Starchild that can be a brand/ folder, a connected Drive pack, or both.

Once that registry exists, you stop re-uploading the same assets into a form. You say "use brand colors and the primary logo," and the agent already knows where those files sit, which variants are approved, and what not to invent.

3. Save preferred settings as workflow skills

Raw UX forces you to re-enter duration, resolution, model, loop rules, and caption style on every run. On Starchild you can turn a repeatable process into a skill:

• Default to Seedance 2.5, 5s, 720p, no hashtags on social cuts
• Always lock start and end frame for seamless loops
• Always pull the latest product still from Drive before rendering
• Always return the file path and a one-line usage note

After that, the instruction shrinks to something like "make the usual product loop from today's still." The skill holds the process. You only change what is new.

4. Direct it in natural language, from any device

Web, Telegram, WeChat, or wherever you already talk to the agent: same memory, same files, same skills. You can start a brief on desktop, approve a still from your phone, and ask for the final cut later without rebuilding the job in a separate video dashboard.

Typical run

1. Point at the brief or brand source ("Drive brand pack," "Notion launch doc," or a local still).
2. State the outcome in plain language: length, resolution, loop, VO, platform.
3. Let the agent resolve assets, apply skill defaults, and generate.
4. Review the file, then iterate with a tighter note ("slower move," "hold logo longer," "swap end frame").

Starchild keeps the prompt, source stills, brand references, outputs, and follow-up edits in one place, so the next cut starts from what already worked.

Video models you can use

Seedance 2.5 is the long-clip / multi-ref option. Starchild also routes other fal.ai video models when you want cheaper iteration, faster drafts, or higher resolution.

Estimated cost per 5 seconds via the Starchild video skill. Dual prices are lower → higher resolution. Hunyuan is billed as a flat job.

Quick picks:

• Cheap iteration: Seedance 2.0 Mini at 480p
• Long clips, loops, multi-ref, native audio: Seedance 2.5
• Highest resolution: Kling v3 4K

Try it

Open your agent and ask for a Seedance 2.5 clip. Start from a still you already like, keep the first version short, and tighten from there.

Generate Seedance 2.5 videos on Starchild

Every DEX builder wants the same thing: users who trade more.

Users who feel confident make more trades. Users who win trade with more size. More trades and bigger positions mean more fees, more revenue, and a platform that grows itself. The question is how you get there.

You get there by putting intelligence directly in the trading interface at the exact moment your users are making decisions, not in a separate tab or a chat window they have to switch to, but right there on the chart, one click away. When users can ask a question and get an answer without leaving the page, they trade more confidently. When they can check exposure, pull indicators, and set alerts without breaking focus, they stay on your platform longer. Confidence becomes activity, activity becomes volume, and volume becomes revenue.

The Starchild module for Orderly does this. It embeds a personal AI agent directly into the trading UI, so the agent sees what the user sees and acts where the user acts. Any DEX built on Orderly can install it through the Orderly module marketplace.

How the WOOFi Pro integration works

WOOFi Pro runs on Orderly's shared orderbook infrastructure. When the Starchild module is installed, a floating Starchild logo appears in the corner of the trading interface. Click it, and the agent launches in an overlay that sits on top of the chart, not in a new tab.

The overlay is dark-themed to match the exchange UI, keyboard accessible, and the floating button is draggable so users can position it anywhere on the screen.

The floating Starchild button sits on the chart. Users drag it anywhere, click to expand the agent overlay.

What the agent does inside the UI

Once launched, the Starchild agent has access to more than 80 premium skills that cover the data and execution layer traders need:

• Real-time market data from CoinGecko, CoinGlass, DeFiLlama, and DeBank, pulled live on every request
• Technical analysis through TAAPI, covering RSI, MACD, Bollinger Bands, ADX, and 200+ indicators
• 24/7 strategy monitoring through custom agents that watch conditions and alert the user when thresholds are hit
• Scheduled tasks so users can set recurring alerts, automated checks, and timed strategies that run on their own

The agent routes tasks to the most efficient AI models available, keeping costs low. Users can bring their own API keys for any model, or use Starchild's included model allocation.

Single sign-on: your users skip the signup form

The module includes Sign in with Starchild, an OAuth-based single sign-on SDK. Users who already have a Starchild account click "Sign in with Starchild," approve access, and land directly inside the trading experience with their full agent intact: persistent memory, configured skills, and the workflows they already set up. No new password, no email verification, no profile setup.

New users get the same fast path. The SDK handles the browser login flow, token storage, automatic refresh, and cross-tab session sharing, so a first-time visitor can go from discovery to a working agent session in seconds. Your backend verifies each access token against Starchild's userinfo endpoint before granting access. Display names and avatars come from the user's Starchild identity, so the agent feels like theirs from the first click.

For DEX builders, this means lower drop-off at the onboarding step and returning users who bring their agent with them.

Install the Starchild module from the Orderly marketplace

Try it on WOOFi Pro today: look for the floating Starchild logo in the corner of the trading interface.

Agents become useful when they can finish the work. With an Agent Wallet, a Starchild agent can pay for 13F filing data through x402, make bids on physical trading cards through Collector Crypt, buy eligible tokenized equities through Treasures Finance, or trade perpetual futures on Hyperliquid. Privy secures the wallet infrastructure, while Starchild's policy layer defines what the agent can do.

The Starchild Wallet supports 28 EVM chains plus Solana, giving your agent access to a broad range of services without installing a browser extension or copying transactions between applications.

Our vision is an ecosystem of agents that create and exchange real value. Worker agents, premium content creators, service providers, and proprietary data providers can make their home on Starchild, monetize what they produce, and pay one another for the capabilities they need.

A wallet that belongs to you

The wallet is powered by Privy and is non-custodial. Starchild does not take custody of the funds, and it does not hold a complete private key that can move them on its own.

The agent is an authorized operator with limited rights, while you remain the owner of the account. This separation is what makes the wallet useful for automation without turning the agent or Starchild into the custodian.

How the private key is secured

Privy protects embedded wallets using Shamir's Secret Sharing, a cryptographic method that splits the private key material into separate shares.

For a Starchild Wallet, the key is distributed across three security boundaries:

• A share associated with your device
• A share protected inside Privy's trusted execution environment
• A recovery share controlled through the user recovery flow

Reconstructing the key requires two of the three shares. A single compromised share is therefore insufficient to recover the private key or move funds.

Key assembly takes place only inside a protected execution environment. The raw private key is not stored as one complete value inside the Starchild application.

You can export the key

Non-custodial should include a practical exit.

You can export the full private key for your Starchild Wallet and use the address with another compatible wallet client. During export, the key is assembled on a different origin from the Starchild application. This separation prevents both Starchild and Privy from seeing the private key during the export flow.

Once exported, the key gives direct control over the wallet. Store it offline and protect it with the same care you would give a seed phrase. Anyone who obtains it can control the funds without going through Starchild's policy layer.

Define and revoke wallet policies in natural language

Useful agents need permission to act without asking you to approve every routine step. The good news is that you can communicate with your agent in natural language to define, change, or revoke those policies.

Ask it to “Check my wallet policy” to see the current rules for EVM or Solana, then describe a change in plain language, such as “Only allow transfers on Base to these addresses” or “Limit transactions to 100 USDC.” The agent prepares the exact policy and shows you a review card. Nothing changes until you approve and sign it. EVM and Solana policies are reviewed and approved separately.

This makes practical workflows possible:

• Paying for an x402 data service during a research task
• Swapping assets to complete an approved DeFi workflow
• Bridging funds between supported chains
• Managing a trading strategy within a fixed allocation
• Sending a known amount to an allowlisted address

The policy determines what the agent can do. Custody remains with you.

Build a business for the agent economy

Have an idea for an agent business, premium content feed, or other paid service? Get in touch with us on Telegram and make a Starchild agent your home. We can help with resources including technical support, marketing, and grants.

Agents can do useful work, but turning that work into a paid service usually creates a second project.

You need payment infrastructure, account management, API keys, billing logic, and a way for customers to discover what you built. For an agent that should be able to create and operate services on its own, that setup becomes the bottleneck.

Starchild now gives your agent a simpler path. It can access x402 marketplaces, pay for the services it needs, and deploy paid x402 services for other agents to use.

From using services to selling them

Your agent can already build tools, process data, run research, generate media, and automate work. With x402 on Starchild, those outputs can become paid services.

For example, your agent could deploy:

• A research endpoint that charges per report
• A data service that charges per request
• A specialized workflow that other agents can call when needed
• A monitoring service with recurring access
• An API built around a model, dataset, or internal process

Other agents can discover the service, pay for access, and use the result inside their own workflows.

How x402 works

x402 brings payments into the normal request and response flow of the web.

When an agent requests a paid resource, the service can respond with 402 Payment Required and provide machine-readable payment instructions. The agent completes the payment and receives access to the resource.

This removes the usual detour through account creation, subscription forms, invoices, and manually managed API keys. Payment becomes part of the interaction between agents and services.

What Starchild handles

Starchild makes the process available through the same agent experience you already use.

Your agent can:

• Browse x402 marketplaces for useful paid services
• Pay for data, tools, media, research, or other work
• Turn something it builds into a paid x402 service
• Choose how access is priced
• Make the service available for other agents to discover and use

You do not need to configure separate payment infrastructure or build the x402 flow from scratch. You tell your agent what to use or what to deploy, and Starchild handles the underlying workflow.

A marketplace built for agents

Traditional software marketplaces assume a person is browsing, comparing plans, creating accounts, and entering payment details.

Agents need a faster path. They need to discover a service, understand its price, pay, and continue working without stopping the workflow for manual setup.

x402 gives agents a standard way to pay one another over the web. Starchild makes that standard practical for everyday agent workflows.

Your agent can buy what it needs and sell what it builds. The whole exchange can happen as part of the work itself.

Start building

Ask your Starchild agent to find an x402 service, or turn one of its existing tools into a paid service for other agents.

No separate billing stack. No manual API key setup. No custom payment flow.

Just build, deploy, and get paid.

Create your agent on Starchild

Most AI agents are effectively single-chain which means they can hold a wallet, and make a swap, execute a trade, but only where their funds happen to sit. If the best opportunity, service, or counterparty is on a different chain, the agent either fails or pushes the bridging requirement back to the user.

What is the LayerZero Value Transfer API?

LayerZero is an omnichain interoperability protocol. Instead of wrapped tokens and centralized bridges, it passes messages directly between smart contracts on different chains. Each message can carry data, instructions, or tokens, and the receiving chain executes based on what it gets.

The Value Transfer API is the programmatic surface that lets applications and agents call into that network. It handles routing, fee estimation, execution, and settlement tracking. An agent calls the API, gets a quoted route, confirms the cost, executes, and polls for settlement on the destination chain. No bridge UI, no manual approvals, and most importantly, no fragmented liquidity.

What this looks like on Starchild

The Starchild skill wraps the LayerZero Value Transfer API so agents can call it directly without writing bridge logic from scratch. A few specifics:

• 850+ tokens across 170+ chains -- EVM, Solana, Aptos, and TON
• Multiple routing options: OFT (Omnichain Fungible Token), Stargate, CCTP (Circle's Cross-Chain Transfer Protocol), and Aori routes
• Quote-then-execute workflow: get a route and estimated cost before committing, then execute in a single call
• Status polling: track transfers until they settle on the destination chain

Why the freedom to be chain-agnostic matters for agents

An AI agent doing serious work eventually hits the chain boundary. Here’s a few places where this shows up in practice:

• A trading agent spots an opportunity on a chain where it does not currently hold funds
• A research agent needs to pay for a data feed or API that accepts a specific token on a specific chain
• An automated strategy needs to rebalance liquidity across multiple chains based on yield or risk conditions
• An agent coordinating with another agent needs to settle payment in a token the counterparty accepts

In each case, the agent either handles the cross-chain step itself or the workflow stalls. This skill makes the first option a reality, which is a huge jump in user experience for whoever depends on the agent for important financial decisions.

The x402 connection

Starchild is building toward x402-native agent payments. The HTTP 402 standard lets any web service return a machine-readable payment request into something that an agent can fulfill automatically without a human in the loop.

The chain gap is one of the main things that limits how useful that becomes. A service running on Arbitrum should not care that a paying agent only holds funds on Base. With LayerZero value transfer, an agent that hits a 402 can route payment to wherever the service expects to receive it, in whatever token it accepts, without the user having to intervene.

Start building

The LayerZero value transfer skill is available in the Starchild marketplace now. Install it on your agent, connect a wallet, and your agent can start moving assets across chains without writing bridge logic from scratch.

Launch your agent on Starchild

What actually changed

Opus 5 replaces Opus 4.8 at exactly the same price, $5 per million input tokens and $25 per million output tokens.

There was a modest jump on benchmarks. Opus 5 scored 61 on the Intelligence Index, eclipsing Opus 4.8 by 5 points.

For reference, Claude Fable 5 costs double and only scores 60. Running the full benchmark suite cost $3,836 on Opus 5 against $5,631 on Fable 5.

Where it does well

Anthropic's pitch is that Opus 5 checks its own work instead of stopping at the first plausible answer. It gave some examples as part of the launch:

Given a drawing of a machine part and no way to view it, Opus 5 wrote its own image-processing code to read the geometry out of the pixels, then rebuilt the part in 3D. No competing model in the same test solved it in five attempts.

Given a real bug in a widely used open-source tool, it found the underlying cause and closed an edge case that the community's own patch had missed.

Early users reported the same pattern in numbers:

The time and step reductions matter as much as the accuracy gains, because the cost of running additional steps on a flagship model can become astronomical.

Where it falls short

Opus 5 is slow. It produces 55 tokens per second, whereas Fable 5 manages 74 and a fast model like Gemini 3.6 Flash does 251. You definitely feel that when vibe-coding something. You will want to get a few tabs going and walk away for a bit.

It is also wordy. Running the same benchmark suite, Opus 5 generated 100 million tokens where Fable 5 needed 87 million and the field average is 63 million.

Looking at OpenAI, GPT-5.6 Sol scores 59 on the Intelligence Index, two points below Opus 5, and costs $2,824 to run the same suite against Opus 5's $3,836. If your work is flexible, Sol is the better value.

How it compares

Model	Price per 1M in / out	Intelligence	Speed
Claude Opus 5	$5 / $25	61	55/s
Claude Fable 5	$10 / $50	60	74/s
GPT-5.6 Sol	$5 / $30	59	65/s
Kimi K3	$3 / $15	57	32/s
Claude Opus 4.8	$5 / $25	56	57/s
GLM-5.2	$1.40 / $4.40	51	170/s
Gemini 3.6 Flash	$1.50 / $7.50	50	251/s

Intelligence scores and speeds from Artificial Analysis, measured at each model's maximum reasoning setting.

When to pick it

Opus 5 is worth its price on work where a wrong answer costs more than a slow one: debugging that needs a root cause, long coding sessions, analysis across large document sets, and any workflow that has to run end to end without someone checking each stage.

For everything that runs often and fast, keep a cheaper model on the job. On Starchild your agent can switch between them, so the practical setup is a fast model handling the routine loops and Opus 5 handling the steps that decide whether the work was any good.

Theoretically, you can also turn its effort down. Anthropic says that even at its lowest setting, Opus 5 passes more Zapier automation tasks than any other model. In Starchild you get low, medium, and high, starting on medium.

Claude Opus 5 is available now. Select it in your agent's model settings, or use Conductor Mode to let Starchild choose per task.

Try Claude Opus 5 on Starchild

Sources: Anthropic's Claude Opus 5 announcement, Anthropic's model documentation, and Artificial Analysis.

Here is how Gemini 3.6 Flash performs, how much it costs to run, and how it compares with other models in a similar price range.

More efficient agent loops

Google reports that Gemini 3.6 Flash uses 17% fewer output tokens than Gemini 3.5 Flash on the Artificial Analysis Index. On DeepSWE, the reduction reaches up to 65%. It also takes fewer reasoning steps and tool calls to complete multi-step workflows.

The Artificial Analysis Intelligence Index combines nine evaluations across mathematics, science, coding, and reasoning into one comparative score. In the latest leaderboard snapshot, Gemini 3.6 Flash ranks 15th with 50.1, narrowly behind Gemini 3.5 Flash and ahead of Claude Sonnet 4.6, Gemini 3.1 Pro Preview, and MiniMax M3.

Rank	Model	Score	Rank	Model	Score
1	Claude Fable 5	59.9	11	GPT-5.6 Luna	51.2
2	GPT-5.6 Sol	58.9	12	GLM-5.2	51.1
3	Kimi K3	57.1	13	Muse Spark 1.1	50.6
4	Claude Opus 4.8	55.7	14	Gemini 3.5 Flash	50.2
5	GPT-5.6 Terra	55.0	15	Gemini 3.6 Flash	50.1
6	GPT-5.5	54.8	16	Claude Sonnet 4.6	47.2
7	Grok 4.5	53.8	17	Gemini 3.1 Pro Preview	46.5
8	Claude Opus 4.7	53.5	18	Qwen3.7 Max	46.0
9	Claude Sonnet 5	53.4	19	MiniMax M3	44.4
10	GPT-5.4	51.4	20	DeepSeek V4 Pro	44.3

The model costs $1.50 per million input tokens and $7.50 per million output tokens. Its predecessor charged the same input price and $9.00 per million output tokens. The lower rate and reduced token use work together, which matters more than either number alone for agents that run repeatedly.

How it compares at a similar price

Gemini 3.6 Flash has real competition in this price band. GPT-5.6 Luna is cheaper and more concise. Grok 4.5 scores higher on intelligence but runs much slower. Claude 4.5 Haiku is less expensive, although it is a non-reasoning model with a smaller context window.

Model	Input / output per 1M	AA Intelligence Index	Output speed	Context
Claude 4.5 Haiku	$1.00 / $5.00	24	92 tok/s	200K
GPT-5.6 Luna, max	$1.00 / $6.00	51.2	162 tok/s	1M
Gemini 3.6 Flash, high	$1.50 / $7.50	50.1	251 tok/s	1M
Grok 4.5, high	$2.00 / $6.00	53.8	67 tok/s	500K

Each model has a clear operating profile:

• GPT-5.6 Luna: Choose it when minimizing token price and output volume matters most.
• Grok 4.5: Choose it for a higher measured intelligence score and lower output-token price. Gemini 3.6 Flash produces tokens almost four times faster and provides twice the context.
• Claude 4.5 Haiku: Choose it for simpler, latency-sensitive tasks that do not need deep reasoning or million-token context.
• Gemini 3.6 Flash: Choose it when an agent needs speed, long context, multimodal input, and substantial reasoning at the same time.

Our pick for most agent workloads is Gemini 3.6 Flash. GPT-5.6 Luna wins on price and Grok 4.5 scores higher on measured intelligence, but Gemini offers the strongest overall balance of speed, context, multimodality, reasoning, and cost. For a general-purpose agent that moves between research, coding, documents, and tools, that balance matters more than winning one metric.

Where it fits on Starchild

Gemini 3.6 Flash accepts text, images, speech, and video. Google lists native support for thinking, function calling, and Computer Use, with a maximum output of 64,000 tokens. That makes it useful for:

• Coding agents that inspect, modify, and test repositories
• Research agents working across documents, screenshots, and recordings
• Browser and interface automation using Computer Use
• Scheduled monitoring where lower cost compounds across repeated runs
• Multi-agent systems that need fast sub-agent loops

Starchild supplies the environment around the model: persistent memory, connected apps, APIs, files, code execution, scheduled tasks, and reusable skills. You can use Gemini 3.6 Flash as the workhorse for frequent or output-heavy steps, then switch to another model when a task needs a different balance of price, speed, or reasoning.

Gemini 3.6 Flash is available on Starchild now. Select it in your agent's model settings, or use Conductor Mode to let Starchild choose based on the task.

Try Gemini 3.6 Flash on Starchild

Sources: Google's Gemini 3.6 Flash announcement, Google's current model documentation, and Artificial Analysis pages for Gemini 3.6 Flash, GPT-5.6 Luna, Grok 4.5, and Claude 4.5 Haiku.

Most models perform well when the task fits inside a short conversation. The harder test begins when an AI agent needs to inspect a repository, research across many sources, call tools repeatedly, and adjust its plan based on what comes back.

Those workflows generate a lot of context. If the model loses track of earlier instructions or discoveries, the agent starts repeating work, contradicting previous decisions, or drifting away from the original goal.

How long-running AI agents work

An AI agent typically operates as a loop:

1. Understand the objective and create a plan.
2. Call a tool, API, browser, or code environment.
3. Reason over the result.
4. Update the plan and take the next action.
5. Repeat until the work is complete.

Each cycle adds instructions, observations, tool outputs, code, and decisions to the working context. A larger context window allows more of that history to remain available as the agent moves through the task.

This matters for repository analysis, technical research, document review, data-heavy investigations, and other multi-step workflows where the early details can still affect decisions much later.

What MiniMax M3 changes

MiniMax M3 supports context windows of up to 1 million tokens using MiniMax Sparse Attention, an architecture designed to reduce the computing cost of processing very long sequences.

According to MiniMax, M3 uses roughly one twentieth of the per-token compute of its previous model at 1 million tokens. The company also reports more than 9 times faster prefill and 15 times faster decoding compared with MiniMax M2 at that context length.

The model was developed around coding and agentic work. In one MiniMax evaluation, M3 completed approximately 24 hours of continuous engineering work involving 1,959 tool calls and 147 benchmark submissions, using the feedback from each run to guide the next iteration.

That is the type of workload where a long-context model earns its place. Short prompts may feel similar across many capable models. The difference becomes more visible when an agent has accumulated hours of history and still needs to connect its latest result to a decision made near the beginning.

Built for the way Starchild agents work

Starchild agents handle work that grows over time. They can research across sources, inspect files, call APIs, write and run code, use connected tools, and continue through scheduled or multi-step workflows. Every action adds context that may affect what the agent should do next.

MiniMax M3 gives those agents more room to retain instructions, tool results, and earlier decisions as a task develops. This makes it a practical choice for repository analysis, ongoing research, document-heavy projects, and repeatable automations where continuity matters as much as the quality of any single response.

MiniMax M3 is available on Starchild now. Select it for an agent, give it a task with enough depth to test its planning and tool use, and see how well it holds the thread.

Try MiniMax M3 on Starchild

TL;DR: The BNBAgent SDK gives users a foundation for building agents with an on-chain identity that can accept paid work, deliver results, and settle payments through escrow on BNB Chain.

Most AI agents can call tools and return answers. Far fewer can prove who they are, advertise what they do, enter a paid agreement, or collect payment without relying on a centralized marketplace.

The BNBAgent SDK brings those capabilities together in a Python toolkit for on-chain agents. Now, it has been added to the Starchild skill marketplace, so anyone can quickly create an agent and start using it without needing to understand code or hardware configurations.

Identity that other agents can discover

The SDK uses ERC-8004 to register an agent as an on-chain identity token. Each registration can include a name, description, metadata, and endpoints for protocols such as A2A or MCP.

This gives developers a portable identity layer for discovery. An agent can publish where it lives and which interfaces it supports, while keeping the underlying record tied to an on-chain owner.

ERC-8004 registration and the commerce layer are independent, so developers can introduce identity without committing to a specific payment workflow.

Find the 'bnbchain' skill in the marketplace and install it on your agent

Paid work with clear settlement rules

The second component is ERC-8183, an agentic commerce protocol for work between a client and a provider.

A client creates a job, assigns a provider, sets a budget, and funds the escrow. The provider completes the work and submits a verifiable deliverable. If the client remains silent through the dispute window, the protocol treats that as approval and releases payment. If the client disputes the result, a voter-based evaluation process can reject the submission and return the funds.

The lifecycle is deliberately explicit:

1. The client creates and funds a job.
2. The provider accepts and delivers the work.
3. The client can dispute during the review window.
4. The protocol settles payment or enables a refund.

That structure gives autonomous agents something API calls alone cannot provide: a shared economic state with rules for failure.

From assistants to economic participants

For Starchild builders, the interesting opportunity sits above the contracts. Persistent agents can combine memory, scheduled execution, research, trading tools, and multi-chain wallets with an open system for identity and paid coordination.

Some ideas for inspiration:

• A research agent could sell a due diligence report to another agent.
• A monitoring agent could receive payment for tracking top-performing wallets.
• A specialized execution agent could help other agents swap safely.

Explore the BNBAgent SDK on GitHub or start building with Starchild.

The headlines focused on the models. The more interesting question is where you get to use them.

What shipped

GPT-5.6 comes in three sizes. Sol is the flagship at $5 input and $30 output per million tokens. Luna is the fast, cheap option at $1 and $6. Terra sits between them at $2.50 and $15, and it is the value story of this release: performance competitive with GPT-5.5 at half the price.

GPT-Live is a different kind of release. It is a family of voice models built on a full-duplex architecture, which means it can listen and speak at the same time. Talking to ChatGPT now works more like a conversation and less like a walkie-talkie.

The part that did not change

Where you use those models stayed the same. ChatGPT lives in its own app or terminal. It's very good at what it does, but it stops at the boundary of its own app.

ChatGPT doesn't have 24/7 scheduled jobs and connected apps. It can't pull a live market feed, check your portfolio, or act on what it finds. More importantly it can't change models to newer open source LLMs that are being released at an increasingly frequent speed. Starchild agents are model-agnostic, which makes them more agile as the agentic landscape evolves.

Your subscription already works harder than that

If you pay for ChatGPT Plus, Pro, or Team, you can sign in to Starchild with that account and put the same subscription behind an agent. No API key, no separate billing. One OAuth step and your agent gets access to the GPT-5.6 family, including Sol, Terra, and Luna, alongside GPT-5.5 and the rest of the lineup.

We covered the economics of this in You're Already Paying for AI. Make It Work Harder. The short version: the subscription is the product, and the app is only one way to use it.

Starchild is a personal AI agent platform, which means the model is one component in a larger setup. Your agent comes with pre-configured data sources and APIs through skills, so it can pull live market data, on-chain state, news, and research without you wiring integrations by hand. It has memory, so it carries your preferences and project context across sessions instead of starting every conversation cold. It can run scheduled jobs, so work continues when you are not at the keyboard. And it can hold a wallet and execute, which is where "assistant" ends and "agent" begins.

How to connect

1. Create a free Starchild account at iamstarchild.com.
2. Open your agent's model settings and choose "Connect my ChatGPT oauth subscription."
3. Approve the device code on OpenAI's page.
4. Pick your model. Sol, Terra, and Luna from your subscription will all be in the list, next to 31+ models from 13 providers.

Model releases will keep coming. The useful question is whether your setup can absorb them.

Starchild memory helps your agent carry preferences, context, and important decisions across chats, so you spend less time re-explaining and more time getting work done.

Why AI memory matters

AI chatbots go into every conversation like a first meeting, which creates a steady tax on the user as preferences have to be repeated and project context has to be rebuilt, while decisions made deep inside long chats disappear as the conversation gets compressed or replaced by a new thread.

For AI agents to become useful collaborators, they need continuity. They need to remember what matters, forget what does not, and carry the work forward without making the user reconstruct everything from scratch.

Some agents try to solve this with complicated solutions you have to find on github and set up. This is also not ideal for most users because with every added layer, it’s harder for the user to understand why the agent makes the mistakes it does.

Memory needs a lifecycle

Memory is a complex problem to solve, since a growing pile of randomly curated facts eventually becomes noisy, stale, and hard to trust. Good memory systems are not about saving everything, but preserving the right things in the right form.

Here are a few key points on the Starchild memory lifecycle:

• Similar memories are deduplicated instead of piling up

• Repeated preferences and rules become stronger over time

• Important lessons are extracted before long conversations get compressed

• Project state is separated from old event history, so the agent understands where the work stands rather than just remembering fragments of what was said

How Starchild remembers

Starchild uses three layers of memory.

1. Core memory stores stable preferences, rules, corrections, writing style, and recurring constraints. It stays small and visible, so important patterns remain usable instead of getting buried in old chat history.

2. Topic memory tracks project state. Each project gets a living notebook with current context, decisions, and useful conclusions. If something important is learned in one conversation, another conversation can use it without starting over.

3. Cross-thread context gives the agent a broader view across threads: what is in flight, what the user is working toward, and what likely needs attention next.

Transparent by design

Memory should also not feel like a hidden profile the user cannot inspect.

In Starchild, the source of truth is stored in readable files, which gives users four things they need:

1. Transparency: you can see what the agent knows.

2. Control: you can edit or delete memory directly.

3. Durability: memory stays small enough to remain useful instead of silently bloating.

4. Trust: the system is not relying on an invisible database to define you behind the scenes.

This matters because persistent memory only works well if users of all technical ability can understand and calibrate it.

How to get started:

The real test of memory is not whether an agent can recite a saved fact, but whether the agent becomes easier to work with over time.

Creating your first Starchild agent is simple - just go to iamstarchild.com and login with email, phone number, a wallet, or any major social login. This process of creating an agent can take less than 30 seconds, and then you can begin suggesting key context to start building your agent’s memory.

From there, start asking your agent to help with whatever keeps you busy. Your agent excels at long-running work: researching ideas, drafting content, organizing context, tracking decisions, managing files, and picking up again when you come back tomorrow.

Enjoy.

Originally published on X: https://x.com/StarchildOnX/status/2074841016234860959

TL;DR: We integrated GLM-5.2 into Conductor Mode, liked what we saw, and joined the Z.ai for Startups program. Users get frontier-grade output at a fraction of the cost of comparable models, and Starchild gets closer to the Z.ai startup ecosystem.

Better support and tapping into the community

For the past few weeks, Starchild team and users have been testing and using GLM 5.2. The feedback has been positive, and as a result we’ve joined Z.ai for Startups. The program gives us direct access to technical resources from the Z.ai team and early access to upcoming model releases, which keeps our platform current as the GLM family evolves. Equally important is the community side, where Z.ai has been building a network of AI-native startups that we want to be an active part of. By connecting with other partners building on GLM and contributing what we learn from running these models in production at scale, we can share resources with other top founders to help everyone grow.

Why GLM-5.2

Z.ai released GLM-5.2 in mid-June, and the benchmark results caught our attention. On SWE-bench Pro, the standard measure of real-world software engineering, it scored 62.1, ahead of many other flagship models.

These are the workloads our users lean on Starchild for: multi-step coding, agentic tool use, and long-context reasoning. Having a model that competes on those tasks with flagship LLMs from other labs, while being openly licensed, is a meaningful addition to the router.

What changes for users

GLM-5.2 is now live in the Starchild Conductor Mode. Conductor Mode is an optional feature many of our users default to, and it selects the best model for each message automatically. When a request comes in, Conductor Mode evaluates the task and, where GLM-5.2 offers the best quality-to-cost tradeoff, it routes there. Users do not need to pick a model or change any settings.

The cost story matters here: GLM-5.2 is priced at roughly a sixth of what comparable frontier models charge. For the long, multi-turn work that Starchild agents do every day, that difference compounds. A user running a coding agent through a long session gets frontier-level output while spending a fraction of what they would on a proprietary model.

To try Starchild and create your first agent, head over to iamstarchild.com

Originally published on X: https://x.com/StarchildOnX/status/2074046903025897808

Most people already have access to ChatGPT, Codex, Grok, or another AI subscription.

The problem is that access usually sits in a separate app or browser tab.

Starchild lets you connect the AI access you already pay for to an agent workspace, for free.

That means ChatGPT, Codex, Grok, or your own API keys can power an agent with memory, files, tools, automated jobs, skills, and persistent context.

1. Connect the AI you already pay for

If you already have ChatGPT, Codex, X Premium, SuperGrok, or provider API credits, start there.

Clicking the link will prompt you to enter a code, which will connect your existing subscription to your Starchild agent's machine.

Use cron jobs instead of full LLM tasks

Recurring work does not always require a full agent session.

If you want a daily price check, a weekly report, a status monitor, a data pull, or a simple threshold alert, a scheduled (cron) job can often do most of the work more cheaply than an LLM task.

In Starchild, scheduled jobs can run lightweight scripts on a schedule and only call a model when interpretation is actually needed. If nothing important happened, the job can stay silent. That means you can automate recurring work without turning every background check into a paid conversation.

Claim free credits through quests

Starchild also gives users ways to earn free credits while they learn about the platform. 100 points is equal to $1 of real platform credits, so you can quickly rack up additional credits for API calls and other premium functions.

Migrate an existing agent for free credits

If you are coming from another agent platform, Starchild supports agent migration.

The migration flow helps bring over useful context and setup work, and users can receive a one-time $10 credit reward for importing from a supported agent platform.

Use referrals to earn and save money

Referral rewards can also offset usage.

When someone binds your referral code, they get a bonus on future top-ups. You can also earn rewards when referred users top up or subscribe.

Host directly on Starchild

Most vibe-coded apps hit the same annoying step: once you are ready to ship it, you need to pay for a hosting service like Vercel or Netlify. With Starchild's Projects, you can tell your agent to deploy the project live once it's ready, and Starchild will give you a public link you can share to the world.

Have feedback or want to try running your own agent?

• Join the Telegram group: t.me/iamstarchild

• Get started: iamstarchild.com

Originally published on X: https://x.com/StarchildOnX/status/2063533921305051582

One of the biggest concerns users have when running agents and AI systems is security. Managing infrastructure, access controls, encryption, and audit trails at a high standard is difficult for even the most advanced of users. Starchild handles this so you don't have to, but does so in a transparent way so you know exactly what is accessed, when, and why.

Starchild's approach is grounded in a core principle: decentralization and privacy shape how we build from the start. We minimize unnecessary access and keep critical actions traceable. At the same time, we are actively researching and developing options for verifiably private hosting so users can choose even stronger decentralization over time.

Access Only When You Request It

Starchild runs your agents inside isolated containers on managed infrastructure. Each container holds your agent's memories, your files, and other materials your agent works with. Starchild handles the container itself (creating it, recovering it if it crashes, scaling resources), but does not read what is inside unless you ask.

It is important to distinguish between two things. Your Starchild agent runs inside the container and has full access to everything in it, as you intend. The Starchild team, however, does not access the contents of your containers by default.

Access to the contents of a container by the Starchild team occurs only when you explicitly request support. When you request support, access follows the principle of least privilege. It is limited to what is necessary to resolve the issue and should remain traceable.

Model Training Policy

Starchild does not use user code, logs, business content, or runtime data to train models. This holds unless a user explicitly authorizes it through a separate agreement, which we may choose to offer later as we scale our open economy and allow users to monetize their activities.

Infrastructure Layer

Starchild runs on Fly.io infrastructure. Fly.io operates a single SOC 2-compliant platform used by all customers. The controls include SSO for internal access, phishing-resistant 2FA, default-deny role-based access, WireGuard mesh networking, mutual TLS between services, Linux LUKS encryption at rest, Firecracker virtualization for compute isolation, and certificate-based SSH with audit trails.

SOC 2 status confirms that audited controls exist around access management and security processes. It indicates that access, when it occurs, should follow documented and auditable paths.

Despite all these protections, we still recommend that for high-sensitivity material (private keys, seed phrases, long-lived production credentials, customer records, or confidential source code), users should apply additional protections rather than rely solely on platform encryption.

Time Machine Snapshots

Starchild treats user data safety as a shared responsibility. We encourage users to keep their own independent backups of important data, especially for business-critical files, code, credentials, trading strategies, automation scripts, or other high-value assets.

In addition to user-side backups, Starchild provides a safety net through the Time Machine feature. Time Machine automatically creates daily snapshots of user data disks and keeps a default snapshot history for the most recent 5 days. These snapshots are designed to provide a recovery option when a user needs to restore or rescue data after accidental deletion, corruption, runtime failure, or other unexpected issues.

This feature is part of Starchild’s broader approach to data safety: reduce the chance of irreversible data loss, provide practical recovery options, and make user environments more resilient when unexpected failures happen.

User-Side Protections That Still Matter

Platform controls and user practices work together. Recommended steps for sensitive workloads include:

• Avoid storing private keys, seed phrases, or high-privilege credentials in plaintext for extended periods.

• Use short-lived tokens or rotatable credentials where feasible.

• Store secrets in a dedicated secrets manager.

• Rotate API keys on a regular schedule.

• Use separate, limited-permission credentials for different agents and environments.

• Maintain independent backups.

Continuing Work on Verifiable Privacy

Our current model relies on policy, access controls, and infrastructure-level encryption. We are actively researching and developing options that would allow users to choose verifiably private hosting, where even platform operators cannot access the environment under defined conditions.

This work is ongoing and adds some interesting narratives to future iterations of Starchild. We intend to be on the leading edge of decentralization and adoption of AI technologies, giving additional utilities to WOO token holders.

Originally published on X: https://x.com/StarchildOnX/status/2059248951145251208

Why the five minutes you skip costs you the next two hours

You ask your coding agent to build a feature. It starts immediately, confident, fast, and thorough-looking. Forty queries later, it delivers something that almost works.

The auth flow is wrong. The database queries target tables that do not exist yet. Half the functions use patterns the agent assumed you wanted.

Now you have two problems: the feature you still do not have, and a broken implementation you need to understand before you can fix.

If you use coding agents, you know this pattern. People call it vibe coding. The fix is simple and usually enough to prevent it.

Add one upstream step: a plan.

What breaks when you skip planning

This failure mode is predictable:

Assumptions compound: The agent starts without confirming understanding. Each guess about architecture, naming, and data model feeds the next one. By the time code lands, it is internally coherent but built on the wrong premises.

Context gets lost: Complex features outgrow context windows. Midway through implementation, intent gets diluted. The next session inherits partial code and missing reasoning.

No mental model: This is the real cost. One-shot code gives you output without visible intent. Debugging requires understanding design choices, but those choices were never surfaced. You are reverse-engineering decisions from artifacts.

What a plan.md step actually gives you

A plan is not overhead. It is the reasoning layer where ambiguity is resolved before code exists.

For the agent:

• Forces structured thinking

• Breaks work into bounded units

• Surfaces edge cases while they are still cheap

For you:

• Exposes assumptions before implementation

• Lets you correct direction at plan time, not rework time

• Gives you a mental model for review and debugging

How to use plan.md

Append one sentence to your prompt:

"let's create a plan.md"

Examples:

"I want to build a full-stack website and do not know where to start, let's create a plan.md."

"I need to add auth to my app, let's create a plan.md."

"I want to refactor the database layer, let's create a plan.md."

That single line changes behavior. The agent stops guessing and starts clarifying. It reads your codebase, asks targeted questions, and writes a plan you can review before any implementation starts.

plan.md will not make every implementation perfect, but it will eliminate the most expensive failure mode, the full restart, and give you what matters most before code is written: A mental model of what is about to happen.

Want to try it out? Head over to Starchild and start vibecoding your first project today: https://iamstarchild.com/

Originally published on X: https://x.com/StarchildOnX/status/2047656084509442142