DEV Community: Apptycoons

Vibe-coded app to production: a readiness checklist for AI-built apps

Apptycoons — Mon, 19 Oct 2026 12:00:00 +0000

Quick answer: An AI-built prototype is ready for production when access rules are enforced on the server, secrets stay out of the app, backups have been restored once, payments and bookings survive retries, errors reach a person, gated integrations are approved, app store rules are met and every account is in your name. Audit first, then fix or rebuild.

In 2025 a researcher scanned 1,645 apps built with Lovable and found 170 of them, about 10.3%, with database access rules loose enough that strangers could read or change the data. The record for that issue, CVE-2025-48757, scores it 9.3 out of 10. Lovable disputes it, on the grounds that each customer is responsible for protecting their own app’s data.

That dispute is the whole problem in one line. The tool built the app. Making it safe to run is still the owner’s job.

If you built a prototype with an AI tool and people already use it, the hard question is behind you: the idea works. What is left is the work nobody sees in a demo. It covers who can read which row, what happens when a payment call times out, whether Apple will accept the build and who holds the keys. This guide is the checklist for that work, and a way to decide what to fix and what to rebuild.

Why AI-built prototypes break once real users arrive

AI-built prototypes break in production because the tools optimize for a working screen, not for the conditions around it. The complaints are usually the same five: it breaks once real users arrive, it fails a security review, it can’t connect to the systems the business uses, the app store rejects it, and nobody understands the code.

The security part is measured. Veracode tested more than 100 large language models on 80 coding tasks and found security flaws in 45% of the results. Java failed more than 70% of the time. The models left code open to cross-site scripting in 86% of the relevant cases and to log injection in 88%. Larger models did not do significantly better than smaller ones.

How often AI-generated code failed Veracode’s security checks

All tasks: 45%
Java tasks: 70%+
Cross-site scripting cases: 86%
Log injection cases: 88%

Veracode, July 30, 2025: more than 100 models, 80 tasks. Veracode sells application security tools.

Operations fail in a different way. In July 2025, during a code freeze, Replit’s AI agent deleted a live company database in a test run by SaaStr’s founder, erasing records for more than 1,200 executives and over 1,190 companies, according to Fortune. Replit’s CEO called it unacceptable. The company then announced automatic separation of development and production databases. That separation is exactly the kind of thing a prototype skips.

None of this means the prototype was a mistake. It proved the product. It was never built to carry other people’s money and data.

The production-readiness checklist for an AI-built app

Each item below has a test you can run or ask for. If nobody can show the test passing, treat the item as open.

Security

Server-side access rules. Every read and write is checked on the server, not hidden in the interface. Test: log in as one user, change the record ID in a request to another user’s, and confirm the server refuses.
Row-level security, deny by default. On Supabase and similar backends, every table with user data has row-level security switched on and a policy per action. A table with no policy should return nothing, not everything.
Secrets out of the client. No service keys, AI API keys or payment secrets in the browser bundle or the mobile app. Calls that need them go through your server. Rotate any key that was ever shipped to a client.
Input validation. Every form and API input is validated on the server for type, length and format, and output is escaped. That is where cross-site scripting and log injection start.
Auth that can be revoked. Email verification where identity matters, rate limits on login and password reset, and sessions you can end from the server.

Watch out

A missing policy is an open door

In CVE-2025-48757, insufficient row-level security let unauthenticated users read or write tables in generated sites. Test with a logged-out request and with a second account, not only as yourself.

Data

Backups you have restored. Automatic backups, plus one restore into a separate environment to prove they work.
Separate development and production. A different database and different keys for each, so a test, a migration or an agent can’t touch live data.
Migrations in version control. Schema changes are scripts in the repository, run the same way every time, not edits made in a dashboard.
A ledger for money. If the app holds balances, credits, commissions or payouts, record every movement as an entry and derive the balance from the entries. A balance column that gets overwritten can’t be audited or reconciled with the payment provider.

Reliability

Idempotent payment and booking calls. A retried request must not charge twice or book twice. Stripe’s API takes an idempotency key for exactly this: repeat the request after a connection error and it does not create a second object. Your own booking and order endpoints need the same rule.
Retries with limits. Calls to outside services retry with backoff, then stop and record the failure instead of looping.
Webhooks handled once. Payment and subscription webhooks are verified, stored and processed once, even when the provider sends them twice.
Error tracking and monitoring. Errors reach a named person, with alerts on failed payments, failed jobs and spend on AI APIs. Rate-limit anything that costs money per call.

Integrations

Gated APIs planned early. Some systems have no self-serve key. Dealership scheduling software is one example: access to Xtime runs through Cox Automotive’s partner program, with an agreement, fees and a certified demo, and then each dealership opts in. Our Xtime API integration guide lists the steps. Find out which of your integrations work like this before you promise a launch date.
Writes that can be undone. Every write to another system has error handling and a way to correct it.

App stores

Apple guideline 4.2. An app needs “features, content, and UI that elevate it beyond a repackaged website.” A web prototype wrapped in an app shell is the case this rule describes.
Apple guideline 4.2.6. Apps “created from a commercialized template or app generation service will be rejected unless they are submitted directly by the provider of the app’s content.” Submit from your own developer account, under your own name.
Store rules for payments. Apple’s guideline 3.1.1 requires in-app purchase for access to features or content inside the app, subscriptions included. That changes your fees and your revenue math, so check it before you price the plan.

Code ownership

Accounts in your company’s name. The repository, cloud, database, domain, Apple and Google developer accounts, payment provider and every API key. Nothing held by a freelancer or a builder platform alone.
A build that runs outside the tool. Someone other than the original builder can clone the repository, run it locally and deploy it from written steps.

Maintainability

Tests on the paths that move money or data. Not full coverage: sign-up, login, payment, booking and anything that deletes.
One way of doing each thing. Prompt-by-prompt building can leave duplicate libraries and parallel auth flows. Pick one of each and delete the rest, because dead generated code is still reachable code.
A README a new engineer can follow. How to run it, how to deploy it, where the secrets live and who to call.

Fix or rebuild: how to decide

Fix the prototype when its foundations are sound and the problems are local. Rebuild the parts whose foundations are wrong, which is rarely the whole app. The test is not how the code looks. It is whether the data model and access model can express what the product has to do.

Fix in place or rebuild a layer

Fix in place (Foundations hold)

Every row records which user or organization owns it
Problems are local: a missing policy, an exposed key, no backups
The app builds and deploys outside the AI tool

Rebuild the layer (Foundations don’t)

Ownership isn’t in the schema, so access can’t be enforced
Money is an overwritten balance with no history
Each change breaks another feature and nobody knows why

Two more cases point to a rebuild. The first is a platform limit: an app that has to control hardware over Bluetooth, run in the background or pass review as a native app may need native code the builder can’t produce. The second is an integration that needs a server-side partner connection the prototype has no place for.

The usual pattern per layer. The audit decides for your app.

The usual result is a mix. The screens stay, because they are what users already know. The access rules get rewritten. The data model gets a review, and the money tables get a ledger.

Can the AI tool make the app production ready on its own?

Partly. An AI tool can fix a named issue fast, and our own engineers use AI tools every day. What it can’t do is decide what to check, notice what is missing or answer for the result. Production needs a senior engineer hands-on: someone who reads the access rules, runs the restore and signs off on the payment flow.

Professional developers already work this way. In Stack Overflow’s 2025 survey of developers, 72% said vibe coding is not part of their professional work. More developers distrusted the accuracy of AI tools (46%) than trusted it (33%). And 75.3% said they would ask a person when they don’t trust an AI’s answer. Google’s DORA 2025 report, from nearly 5,000 technology professionals, describes AI’s main role in software development as “an amplifier”. It strengthens a team’s good practices and its bad ones alike.

So the question is not AI or no AI. It is whether someone with production experience is steering it.

What a production-readiness audit should deliver

A useful audit ends with decisions, not a list of worries. Ask for these before you pay for one:

A findings list ranked by risk. Each finding says what is wrong, how it was tested and what an attacker or a bad day could do with it. Launch blockers are marked as blockers.
A fix-or-rebuild call per layer. For screens, business rules, data model, access rules, integrations and hosting, with the reason.
An ownership inventory. Every account and key, who holds it now and the steps to move it to you.
Integration and store risks. Which APIs need partner approval, and how long it takes. Whether the app is likely to pass App Store review as built.
A fixed quote for the fix list. Scope, price and order of work, so you can compare it with rebuilding or doing it in-house.

From prototype to production

Prototype: Real users, proven demand
Audit: Test each checklist item
Fix list: Ranked, with a fix-or-rebuild call
Harden: Fixed scope, fixed price
Launch: Accounts and code in your name

Who does the audit matters as much as the list. At Apptycoons it is done by our senior engineers, who were writing production code before AI tools existed. A technical project manager then turns the findings into a scope. The first conversation is free. The audit itself is scoped and priced before it starts, and if the fix list is big enough to be a project, it is quoted as a Fixed-Price Build in our $25k–$120k band. Our guide to fixed price or time and materials explains why we quote that way.

Where our builds cover these parts

None of the apps below started as an AI-built prototype. We built them from scratch, and each one covers a part of the checklist above.

Access by role. Switch is shared banking for clubs and teams. An account belongs to a group, so treasurers, admins and members each get different rights over money and cards, and a card’s state has to show the same on every device.
Money that reconciles. Freedom Pro pays commissions to a partner network and holds USD and stablecoin balances. The same team activity must always produce the same commission, and balances have to reconcile with the provider’s records.
Payouts and store purchases. DubCam pays creators 50% of each subscription on the first of the month, with subscriptions on the phone apps running through in-app purchases. The revenue share guide covers the ledger and the store fee math.
A native app through review. OHM Fitness runs separate native iOS and Android apps that control a 20-electrode suit over Bluetooth LE, live on the App Store and Google Play.
A gated integration. Innovative AI runs voice agents that book dealership service in Xtime, one of the systems you can’t reach with a self-serve key.

If you want us to do this work on your app, our AI prototype to production service runs the audit and the fixes at a fixed price. For new web apps, our web app development page describes how we build them. For store releases, see mobile app development.

When you don’t need an agency

You don’t need an agency if the app is a demo, a waitlist or an internal tool with a handful of users, no payments and no sensitive data. Keep building with the AI tool. Work through the security and data sections of the checklist yourself, and turn on backups.

One experienced freelance engineer is often enough when the app has one clear risk: a missing access policy, an exposed key, a deploy that only works from the builder. Ask them to show you the tests passing.

A senior team earns its cost when several of these are true at once: money moves through the app, it stores personal data, an integration needs partner approval, a native app has to pass review, or you plan to raise money and someone will look at the code. If two or more apply, book an audit and bring the repository, the list of accounts and the problem that worries you most.

Sources

AI-Generated Code Poses Major Security Risks in Nearly Half of All Development Tasks, Veracode Research Reveals, Veracode (July 30, 2025)
CVE-2025-48757 Detail, NIST National Vulnerability Database (published May 30, 2025; disputed by the supplier)
Statement on CVE-2025-48757, Matt Palmer (2025)
An AI-powered coding tool wiped out a software company’s database, then apologized for a ‘catastrophic failure on my part’, Fortune (July 23, 2025)
App Review Guidelines (4.2 Minimum Functionality), Apple Developer (checked October 19, 2026)
Idempotent requests, Stripe API reference (checked October 19, 2026)
2025 Stack Overflow Developer Survey: AI, Stack Overflow (2025)
DORA 2025 State of AI-assisted Software Development Report, DORA, Google (2025)

Originally published at apptycoons.com.

Xtime API integration for AI voice agents: a build guide

Apptycoons — Sun, 18 Oct 2026 12:00:00 +0000

Quick answer: Xtime has no self-serve API. As of October 2026, access runs through Cox Automotive’s partner program: an NDA, a partner agreement, fees, a business review and a certified demo, then an invitation code from each dealership. The scheduling API reads capacity and open times and creates or cancels appointments by year, make and model or by VIN.

Xtime has no self-serve API keys. As of October 2026, Supergood’s assessment of the Xtime API lists six things before the first production call: an NDA, a partner agreement, setup and per-dealer fees, a Cox Automotive business review, a certified demo and an invitation code from each dealership.

We built AI voice agents for Innovative AI that book service appointments at US car dealerships through Xtime and run sales follow-up through VinSolutions, Cox Automotive’s dealership CRM. The agents are still live in production. On that build, the hard parts were matching a caller’s words to one service out of a long menu, checking slots and handling transport. Those, plus the access steps and our recommendations on safe retries, are what this guide covers, from the system side. If you want the finished product rather than the build notes, our custom AI voice agents page has the scope.

How do you get Xtime API access?

You get Xtime API access through Cox Automotive’s partner program, not by signing up for a key. Supergood, which grades vendor APIs, lists the steps as of October 2026: an NDA and a partner agreement, a setup fee plus annual and per-dealer fees, a business review by Cox, and a certified demo before production approval. After that, each dealership opts in with an invitation code.

The steps to production access, per Supergood (as of October 2026)

NDA and agreement: Partner agreement with Cox
Fees: Setup, annual and per-dealer
Business review: Run by Cox
Certified demo: Before production approval
Dealer opt-in: One invitation code per dealership

The reference documentation is behind a login on the Cox Automotive Integration Platform. Supergood notes that Service Scheduling 1.0 and Service Marketing 1.0 are listed on Cox’s developer portal, and labels the scheduling capabilities as the Consumer Scheduling API.

Two consequences for planning:

The calendar is not yours. The business review and the certified demo run on Cox’s schedule. Build against what you can test, and keep the demo-ready flow small.
Contracts sit with whoever holds the integration. Decide early whether the dealer group, a software vendor or the build team signs, because the per-dealer fees and the support obligations follow that party.

We don’t quote the fee amounts here. They are set by Cox and should come from Cox in writing.

What the scheduling API covers, and what it doesn’t

The Xtime scheduling API covers the booking itself: dealer capacity, available appointment times, and creating or canceling appointments by year, make and model or by VIN, according to Supergood as of October 2026. It does not cover repair orders or inspection results.

That split decides what a voice agent can answer on its own.

Caller requests and whether the scheduling API answers them (scope per Supergood, as of October 2026)

Caller wants to	Scheduling API	What else you need
Book a service for a known vehicle	Yes: capacity, open times, create	The vehicle’s service menu and a way to pick the right item
Move or cancel a booking	Yes: cancel, then create	Identity check before changing anything
Hear the price of a service	Not listed in the report card	The dealership’s menu pricing, if exposed to you
Ask whether the car is ready	No: repair orders are not offered	DMS access or a handoff to a service advisor
Ask what the inspection found	No	A service advisor

Watch out

“Is my car ready?” is not a scheduling question

Repair orders are not offered by the scheduling API, so a status question needs DMS access or a handoff to a service advisor.

Xtime’s own product page describes “dynamic menus that reflect your dealership’s pricing, promotions, and service recommendations”. Menus are set by each dealership, so treat menu content as dealer data that changes, not as a fixed catalog you can hard-code.

The data flow on one booking call

One booking call touches Xtime at three points: the vehicle’s service menu, the open times for the chosen service, and the appointment itself. Everything else is the agent’s own logic and its own store.

The table is our recommended data flow, in the order the Innovative AI case study describes the call. It shows which system each step reads or writes, not how the conversation sounds.

Data read and written on one service booking call (our recommended flow)

Step	Data read or written	Source of truth
1. Route the call	The caller’s intent: book service, check on a car in for work, or something else	The caller
2. Identify the vehicle	Year, make, model and trim	The caller
3. Load the service menu	That vehicle’s services, each with its own op code	Xtime
4. Choose the service	One op code from that menu, confirmed with the caller	The caller’s confirmation
5. Find a time	Open times for that service on the requested day	Xtime
6. Settle transport	The transport option and, where needed, an address	Per-dealer configuration
7. Book	The appointment: vehicle, op code, time	Xtime

Steps 3, 5 and 7 are the only Xtime calls, and step 3 has to come before any talk about times: the agent cannot offer a slot until it knows which service it is booking, and it cannot know the service until it has the vehicle. Transport options differ by dealership, so they live in configuration rather than in code. The case study covers the menu sizes and transport choices from that build.

Returning-caller recognition sits beside this flow rather than in it: on that build, the caller’s name, vehicle and recent service were saved against the phone number, so a repeat caller skipped questions the agent could already answer. The same system also looked up and confirmed existing appointments, and placed follow-up calls when the dealership’s CRM showed a booked customer had not arrived.

What the voice agent needs on top of the API

A voice agent needs five system-side pieces that no scheduling API provides: a menu-constrained output, an availability check inside the booking step, per-dealer transport configuration, a caller profile store and a create step that is safe to retry. The rest of this section is our engineering recommendations, not a description of the Innovative AI system and not Cox documentation. How the conversation itself should sound, from matching a caller’s words to offering another time, is in our guide to AI service scheduling for dealerships.

A menu-constrained output. The model’s choice of service should be an op code from the menu Xtime returned for that vehicle and nothing else. Pass the menu in as the only allowed values and validate the answer against it in code, so a request for “the 30k service” can only resolve to a line that exists. An answer that matches nothing is a handoff, never a guess.

Availability inside the booking step. Treat the open times read earlier in the call as a hint. The create step reads availability for that service and time again and books only if the slot is still returned, so the check and the write sit together in one function.

Per-dealer transport configuration. Store each rooftop’s options as data: whether it offers a shuttle, loaners, pickup or mobile service, and the service area for the last two. The agent asks only about options that dealership’s record lists, and the address field is required only when pickup or mobile service is chosen.

A caller profile store. Name, vehicle and recent service saved against the phone number live in your own store, not in Xtime. It is personal data: keep only those fields, set a retention period and delete profiles that pass it.

A retry-safe create. Calls drop. If the line cuts out after the agent sent the booking and before it heard the result, a naive retry or a callback can book the same car twice. Record each booking attempt on your side, tied to the call, before you send it. On any retry, check that record and the customer’s existing appointments first, and only create when neither shows the booking. The same confirm-before-write pattern appears in our AI agent guardrails checklist.

Where VinSolutions fits: the sales side

VinSolutions is Cox Automotive’s dealership CRM, so on an all-Cox stack the service side and the sales side come from the same company. VinSolutions calls itself “the AI-powered CRM with exclusive Cox Automotive shopper data and integrations with top industry providers”, and Cox’s brand list carries it next to Xtime (both as of October 2026).

Partner access points to the same place. VinSolutions’ integrations page tells vendors “If you are interested in becoming an integrated partner please visit our API Storefront”, and that link goes to Cox Automotive’s developer site, the one that hosts the Xtime reference documentation (as of October 2026).

On the Innovative AI build, sales follow-up runs through VinSolutions. The agent works through leads who visited a dealership and didn’t buy: a message first, then a call to learn the reason, such as price or a different car, and to capture what they want. It closes by telling them a supervisor will call back.

When a dealer group runs more than one vendor

Our build was all Cox Automotive: Xtime for service, VinSolutions for sales, and other Cox products at other rooftops. Not every group is. Cox’s own brand list, as of October 2026, includes Xtime for service, VinSolutions for CRM and Dealertrack for dealership management. A group whose CRM or dealer management system comes from another vendor is dealing with that vendor’s access program as well. CDK Global, for example, runs its own automotive API platform, Fortellis; the fortellis.io footer says “Fortellis is a trademark of CDK Global, LLC”. That means a second company, a second contract and a second style of API, and it was not part of the Innovative AI build.

The design we recommend for any mix of systems, including several products from one vendor, is one internal model and one adapter per system:

One internal shape for a vehicle, a service, an appointment and a lead, used by the agent’s logic everywhere.
One adapter per vendor , which translates that shape to Xtime, to VinSolutions or to the next system, and owns its credentials and error handling.
Per-dealer configuration that says which adapter handles scheduling and which handles leads at each rooftop.

Our recommended design: adding a dealership on a different stack means an adapter, not a new call flow.

The agent’s prompts and tools then talk about appointments and leads, never about a vendor. Adding a dealership on a different stack means writing or reusing an adapter, not rewriting the call flow.

Rolling out dealer by dealer

An Xtime integration goes live one dealership at a time, because each one opts in with its own invitation code. Each rooftop also brings its own menu: op codes vary by dealership and system, and myKaarma’s documentation says dealerships “may contain a large number of opcodes, sometimes exceeding thousands”, which is why its API pages through them (myKaarma docs, as of October 2026).

Our recommendation is one test rooftop first, with a checklist per dealership after it:

Checklist per dealership, after the test rooftop

Invitation accepted: Test bookings visible to the service team.
Menus pulled: For the vehicles that dealership services most, and a sample of plain-language requests matched against them.
Transport options set: Shuttle, loaner, pickup, mobile service, and the service area for the last two.
Handoffs set: Handoff numbers and hours for service advisors and the sales desk.
Test calls: In noisy settings and with a range of accents, since those, along with requests too odd to match, were behind our misses.

Only move to the next rooftop when the first one’s service team trusts what lands in its schedule.

When not to build your own integration

A single dealership that wants after-hours answering and basic booking should buy a product that is already integrated with Xtime. The case is clearest on the integration side: a product already integrated with Xtime has done the partner work once, and a one-store build would repeat the agreement, review and demo for one invitation code. Xtime’s Schedule page lists a voice add-on (Brooke.ai), as of October 2026.

Building custom is our business, so read this with that bias in mind. The wider buy-or-build call, including when a custom agent pays off, is in the buy-or-build section of our scheduling guide.

What an integration adds to the build cost

An Xtime integration fits inside a Fixed-Price Build of $25k–$120k, and where it lands in that band depends on how many systems the agent talks to, not on the Xtime connection alone. Scheduling through Xtime with the op-code matcher, slot negotiation and retry-safe booking is one scope. Adding VinSolutions for sales follow-up, outbound calls and per-dealer adapters is a larger one. We fix the price after a $5,000 Discovery Sprint, and the pricing page shows the model.

Two costs sit outside our quote: Cox’s partner and per-dealer fees, and the time the business review and certified demo take. Put both in the budget before the build starts.

Before you scope it, have these ready: who will hold the Xtime agreement and the CRM access, the list of rooftops and the systems each one runs, the transport options each offers, and where calls should go when the agent hands off. With those four answers, a discovery sprint can price the work. For how this looks across the dealership, see our page on car dealership software.

Sources

Xtime API report card, Supergood (third-party assessment, last verified October 2026)
Xtime Schedule, Xtime (Cox Automotive)
Our brands, Cox Automotive
Auto Dealership CRM & Sales Software, VinSolutions (Cox Automotive), as of October 18, 2026
Integrations with VinSolutions, VinSolutions (Cox Automotive), as of October 18, 2026
Fortellis, Fortellis (CDK Global), as of October 18, 2026
How to get operation codes and service-menus, myKaarma, as of October 2026

Originally published at apptycoons.com.

AI voice agent cost in 2026: per-minute vs custom build

Apptycoons — Wed, 07 Oct 2026 12:00:00 +0000

Quick answer: Hosted voice platforms cost about $0.08 to $0.15 per minute all-in at list prices, plus extras such as HIPAA add-ons. A custom stack’s usage costs about $0.04 per minute, but it needs a $25k–$120k build and its own hosting. On list prices, custom starts paying back somewhere between 11,000 and 31,000 minutes a month.

Vapi advertises $0.05 a minute. Add the speech-to-text, the language model and the voice that every call needs, and the same agent costs $0.082 to $0.129 a minute on Vapi’s own calculator. The advertised rate covers one layer of a five-layer stack; the other four arrive as separate line items.

In our model, built only from public price lists, a hosted platform costs about $0.08 to $0.15 a minute all-in and a custom stack about $0.04 a minute before hosting and the build. Every figure below is a list price rechecked on October 18, 2026, and every calculation is shown, so you can rerun it with your own call volume.

How much does an AI voice agent cost per minute?

At list prices, a hosted voice platform costs about $0.08 to $0.15 per minute once every layer is included. A custom stack that pays each vendor directly costs about $0.04 per minute in usage, but you have to build and host it. The platform’s advertised rate, $0.05 on Vapi or $0.055 on Retell, is only the orchestration fee.

All-in cost per minute, list prices (checked Oct 18, 2026)

Option	Per minute	What is included
Vapi	$0.082–$0.129	$0.05 hosting plus speech-to-text, model and voice passed through at cost, on Vapi telephony (no transport fee)
Retell, Claude 4.5 Haiku	$0.110	$0.055 infrastructure, $0.015 voice, $0.025 model, $0.015 telephony
Retell, recommended tier	$0.149	Same, with a $0.064 recommended-tier model such as Claude 5 Sonnet
Custom stack	about $0.043	Twilio, Deepgram Nova-3, Deepgram Aura-2 voice, Claude Sonnet 5.5; hosting and build not included

The five line items inside every per-minute price

Every AI phone call pays for the same five things, whether a platform bundles them or you buy them separately. Knowing them is how you compare quotes.

Telephony carries the call. Twilio lists US inbound calls to a local number at $0.0085 a minute, and streaming the audio to your server at $0.0044 a minute.
Speech-to-text transcribes the caller. Deepgram lists streaming Nova-3 at a regular price of $0.0077 a minute, currently discounted to $0.0048; we use the regular price.
The language model decides what to say and which tools to call. It is billed per token, so its per-minute cost depends on prompt size and how often the caller speaks.
Text-to-speech speaks the reply. Deepgram lists Aura-2 at $0.030 per 1,000 characters; Retell lists voices from $0.015 to $0.10 a minute depending on the provider.
Orchestration handles turn-taking, interruptions and tool calls. Platforms charge for it per minute; on a custom stack you host it yourself.

On Retell the platform fee is half the minute; on a custom stack you host orchestration yourself. Model and voice per-minute figures use the assumptions below.

How we turned token prices into a per-minute cost

Two of these layers are not priced per minute, so we converted them with stated assumptions. For the model, we assume five model calls per minute of conversation, each sending 3,000 input tokens (2,500 of them a cached system prompt) and receiving 80 output tokens. At Claude Sonnet 5.5 list prices of $2 per million input tokens, $0.10 for cache reads (Anthropic bills cache hits on Sonnet 5.5 at 0.05 times the input price) and $10 output, that is about $0.0021 per call and $0.0103 a minute. For the voice, we assume the agent talks for about 45% of the call at around 150 words a minute, roughly 400 characters, which is $0.012 a minute on Aura-2.

Platform pricing: what Vapi and Retell charge

Both platforms publish their prices, so a fair comparison is possible. They differ in what is bundled and what costs extra.

Platform price lists compared (checked Oct 18, 2026)

	Vapi	Retell
Platform fee	$0.05/min hosting	$0.055/min voice infrastructure
Models and voices	Passed through at cost; calculator examples $0.0095–$0.0099 transcriber, $0.0077–$0.0452 model, $0.0146–$0.0238 voice	Priced per minute: voices $0.015–$0.10; models from under $0.01 to over $0.30, with Claude 4.5 Haiku at $0.025 and the recommended tier at $0.064
Telephony	Vapi telephony and SIP free, one number on the free tier; Twilio numbers billed by Twilio	$0.015/min, numbers $2 a month
Plans	No Success Package $0 with $5 credit; Core $29 a month; Pro 10% of hosting, $999 a month minimum; Premier custom	Usage-based, $10 in free credits; enterprise plan at custom pricing
Concurrent calls	4 / 10 / 30 by plan, extra lines $10 each a month	First 20 free, then $8 each a month
HIPAA	$2,000 a month add-on	HIPAA and BAA listed on pay-as-you-go and enterprise; custom BAA on enterprise (checked Oct 19, 2026)

The choice of model and voice moves the platform price more than the choice of platform. On Retell, swapping a recommended-tier model for Claude 4.5 Haiku takes the all-in rate from $0.149 to $0.110 a minute, the most expensive models on Retell’s list cost over $0.30 a minute on their own, and moving to a premium ElevenLabs voice can add up to $0.085.

What a custom AI voice agent costs to build

With us, a custom voice agent falls in the same $25k–$120k band as any agent we build, with the price fixed after discovery (the pricing page has the model). “Custom” means you own the orchestration code, run it in your cloud and pay each vendor directly, typically on an open-source framework such as LiveKit or Pipecat instead of a hosted platform.

Five things set where a voice build lands in that band:

the systems the agent books into or updates, such as a scheduler, CRM or order system,
the number of call flows, from a single booking flow to triage across several departments,
warm transfer to a person with a summary of the call,
latency tuning, because slow replies make a conversation feel broken (see voice agent latency),
compliance, such as HIPAA, call recording consent and data retention.

A platform build is not free either. Someone still writes the prompts, connects the agent to your systems and tests the call flows. That work is similar on both routes, so the comparison below charges only the custom route with a build, which favors the platforms.

Total cost at 1,000, 10,000 and 50,000 minutes a month

At 1,000 minutes a month a platform costs roughly a tenth of a custom stack; at 50,000 the order flips. The table adds usage at list prices and, for the custom stack, two fixed monthly costs we state as assumptions: $500 a month for hosting and monitoring, and the minimum build of $25k spread over 36 months, about $694 a month.

Monthly cost by call volume (list prices, assumptions above)

Minutes a month	Vapi	Retell	Custom usage	Custom all-in
1,000	$82–$129	$110–$149	$43	$1,237
10,000	$818–$1,289	$1,100–$1,490	$429	$1,623
50,000	$4,090–$6,445	$5,500–$7,450	$2,143	$3,337

The platform columns exclude plan fees, concurrency charges and HIPAA add-ons, and the custom column excludes the cost of your team’s time to operate it. Both omissions matter at the edges, so treat the table as a starting model, not a quote.

The break-even point for a custom voice agent

On these list prices, a custom stack breaks even at about 11,300 minutes a month against Retell’s recommended tier, 13,900 against Vapi’s higher configuration, 17,800 against Retell with Claude 4.5 Haiku, and 30,700 against Vapi’s lowest configuration. The arithmetic is the custom stack’s fixed monthly cost, about $1,194, divided by the per-minute saving.

Break-even minutes per month for a custom stack

Compared with	Platform per minute	Saving per minute	Break-even
Retell, recommended tier	$0.149	$0.106	about 11,300
Vapi, higher configuration	$0.129	$0.086	about 13,900
Retell, Claude 4.5 Haiku	$0.110	$0.067	about 17,800
Vapi, lowest configuration	$0.082	$0.039	about 30,700

Two things move the break-even sharply, in opposite directions. A HIPAA add-on of $2,000 a month on a platform is larger than the custom stack’s entire fixed cost in this model, so it pulls the break-even down, although a custom stack has its own compliance costs, such as Twilio’s Security Edition for a BAA. A larger build, say for several call flows and integrations, pushes it up by roughly 6,500 to 17,800 minutes for every additional $25k spread over three years, depending on the platform you compare against.

A HIPAA add-on vs the custom stack’s fixed monthly costs

Custom: hosting and monitoring: $500
Custom: minimum build over 36 months: $694
Vapi HIPAA add-on: $2,000

Custom stack assumptions from the total-cost section: about $1,194 a month in all.

Costs that per-minute quotes leave out

A per-minute rate is the biggest line on the bill, but not the only one. Budget for these as well, on any route:

Concurrent calls. Platforms include a set number of simultaneous calls and charge for more: Retell includes 20 and charges $8 a month for each extra, and Vapi includes 4, 10 or 30 depending on the plan and charges $10 a month per additional line. Size this for your busiest hour, not your average.
Plan minimums. Vapi’s Core plan costs $29 a month, and its Pro plan bills 10% of the hosting fee with a $999 a month minimum. At 5,000 minutes a month, Pro’s hosting share is $25, so the minimum, not the percentage, sets the bill until volume is far higher.
Phone numbers. Small, but they add up across locations: Twilio lists local numbers at $1.15 a month and toll-free at $2.15.
Transfers. When the agent hands a caller to a person, the outbound leg is billed too; Twilio lists outbound calls at $0.0140 a minute.
Recordings and transcripts. Storage and retention rules matter more than the storage price, especially for regulated calls.
Testing. Every prompt or model change should be replayed against recorded test calls before it goes live, and those test calls use real minutes.
Change. Models, voices and prices change; someone has to evaluate and apply those changes.

The integration is the cost that no per-minute quote shows, because it sits in the build. On the service booking agent we built for Innovative AI, every booking call loaded that vehicle’s own menu of 100–200 services from Xtime, checked the dealership’s open slots and settled drop-off, pickup or mobile service before it booked anything. In a build like this, each lookup is typically a tool the agent calls mid-conversation, and how AI service scheduling works at a dealership walks through them in order.

HIPAA and the BAA chain

A voice agent that hears patient information is only as compliant as the weakest vendor on the call. Under HIPAA, every vendor that receives protected health information must sign a business associate agreement, and on a voice call that is the carrier, speech-to-text, the language model, text-to-speech, the orchestration layer and wherever recordings and transcripts are stored.

Price this chain before you choose a stack. Vapi lists HIPAA-eligible data handling at $2,000 a month. Retell’s plan comparison lists HIPAA and a BAA on pay-as-you-go as well as enterprise, with a custom BAA on enterprise only (checked October 19, 2026). Twilio signs a BAA only for customers on its Security or Enterprise Edition. On a custom stack you sign each agreement yourself and can choose vendors and regions accordingly, which is often the deciding factor for healthcare work. There is no such thing as being “HIPAA certified”, so ask each vendor for its BAA, not a badge.

Outbound calls: consent rules change the cost

An agent that places calls costs more to build than one that answers them, because US law treats its voice as artificial. In February 2024 the FCC confirmed, in a declaratory ruling (FCC 24-17), that the TCPA’s restrictions on “artificial or prerecorded voice” cover current AI technologies that generate human voices. Such calls need the called party’s prior express consent, absent an emergency purpose or an exemption.

For a build, that turns into line items an inbound receptionist mostly avoids:

consent capture and storage, tied to each number the agent may call,
do-not-call list scrubbing before every campaign,
an opt-out path inside the call that the agent honors at once,
calling-hour limits by the recipient’s time zone,
logs that show which consent covered which call.

Budget these as scope, not as a later fix; they decide whether the agent can dial at all. This is a summary of the ruling, not legal advice, and state rules can add to it.

Calls with a sales purpose count as telemarketing and need prior express written consent, so an unsold-lead callback carries a heavier consent flow than a reminder about a booked service, as our guide to no-show and unsold-lead follow-up calls explains.

When a platform is the right answer

For most first voice agents, a platform is the better choice. Choose one when:

volume is under about 10,000 minutes a month and not growing fast;
the call flow is standard, such as answering questions, booking into a common scheduler or taking messages;
you want to test whether callers accept an AI agent before you invest in a build;
or nobody will run voice infrastructure after launch.

Go custom when volume is high or rising, when compliance needs control over every vendor in the chain, when the agent must act inside your own systems in ways a platform’s integrations cannot, or when latency and voice quality are part of your product. Many teams start on a platform and move once the numbers above favor it; designing prompts and tools to be portable makes that move cheaper. The same trade-off applies to text agents, and our guide to build vs buy AI agents runs it over three years.

Platform or custom, in short

Hosted platform (Vapi, Retell)

Under about 10,000 minutes a month
A standard call flow
Testing whether callers accept an AI agent
Nobody to run voice infrastructure

Custom stack (LiveKit, Pipecat)

High or rising volume
Control over every vendor in the compliance chain
Actions inside your own systems
Latency and voice quality are part of your product

Is an AI voice agent worth it? Compare with missed calls

The right comparison is not the agent’s cost against a receptionist’s salary; it is the agent’s cost against the revenue lost to calls nobody answers. A business taking 60 calls a day at three minutes each uses about 5,400 minutes a month, which costs roughly $440 to $800 a month in platform usage at the list prices above.

Then estimate what missed calls cost you: calls a month, times the share you miss, times the share of those callers who would have bought, times the value of a customer. We walk through that model in what missed calls really cost, and you can run it with your own numbers in the AI voice agent ROI calculator. If the lost revenue is a multiple of the agent’s monthly cost, the case is easy at any of the prices in this guide.

How to lower the per-minute cost of a voice agent

The biggest savings come from the model and the voice, not from haggling over the platform fee.

Use the smallest model that passes your call tests, and keep the system prompt stable so it can be cached.
Pick a standard voice unless the voice is part of your brand; premium voices can cost several times more per minute.
Keep calls short with clear flows and fast handoff to a person when the agent cannot help.
Route by intent, so simple calls never reach the expensive model.
Recheck list prices before you commit. This guide uses prices checked on October 18, 2026, and vendors update them; our AI voice agent pricing tracker rechecks them every month.

If you want these numbers worked out for your own call volume and systems, our AI voice agents team can model both routes in a free audit before you commit to either.

Sources

Retell AI pricing, Retell AI
Vapi pricing, Vapi
Twilio Programmable Voice pricing (United States), Twilio
Deepgram pricing, Deepgram
Claude API pricing, Anthropic
HIPAA compliance at Twilio, Twilio
Implications of Artificial Intelligence Technologies on Protecting Consumers from Unwanted Robocalls and Robotexts, Declaratory Ruling (FCC 24-17), Federal Communications Commission

Originally published at apptycoons.com.

AI agent development cost in 2026: real price ranges

Apptycoons — Wed, 07 Oct 2026 12:00:00 +0000

Quick answer: A production AI agent typically costs $25k–$120k to build at a fixed price, after a $5,000 two-week discovery sprint. Running it adds model tokens, hosting and monitoring, often a few hundred to a few thousand dollars a month. Integrations, compliance, evaluation and human approval steps move the price far more than the model does.

A workflow agent that handles 20,000 tasks a month costs about $356 a month in Claude Haiku 4.5 tokens at list price. Building the system that lets it do those tasks safely, inside your CRM or ERP, with approvals and an audit log, costs $25k–$120k. That gap is the whole story of AI agent cost: the model is cheap, and everything around it is not.

The figures below are the ones on our pricing page, the same ones we quote against.

How much does an AI agent cost to build?

A production AI agent costs $25k–$120k as a Fixed-Price Build, after a two-week, $5,000 Discovery Sprint whose fee is credited to the build. Where a project lands in that band depends on three things: how many systems the agent touches, how much it may do without a person, and which compliance rules apply. The same math holds for agentic AI development in general: the cost follows the number of tools an agent can call and the actions it may take on its own, not the model you pick.

The total cost of an agent has three parts, and most budgets only plan for the middle one:

The three costs of an AI agent

Cost	What it covers	Our published price	When you pay it
Discover	Workshops, a working prototype on your real data, architecture and integration plan, fixed quote	$5,000 fixed fee, credited to the build	Weeks 1–2
Build	Production agent, integrations, guardrails, evaluation set, security review, launch, 30 days of support	$25k–$120k per project	6–16 weeks, billed in milestones
Run	Model tokens, hosting, logging, monitoring, evaluation runs, prompt and model updates	Usage-based (see the worked example below); optional dedicated team from $12k per month	Every month after launch

What you pay for in discovery, build and run

Each phase removes a different risk.

Discovery: proving the agent can work on your data

Discovery is two weeks with a senior architect. It ends with a prototype running on your real data (not a slide deck), the architecture, a plan for each integration, and a fixed quote. Its job is to surface the problems that make AI projects overrun: data that is messier than the demo set, APIs that need approval to access, and approval rules nobody wrote down.

Build: turning a prototype into a system you can trust

The build is where most of the money goes, and little of it is spent on the model. It pays for connecting the agent to your systems of record, adding approval steps for high-impact actions, writing an evaluation set that proves the agent behaves, a security review, and launch. Work happens in two-week sprints with live demos, and the code sits in your repository from day one.

Model calls are one part of seven. The build pays for integrations, approvals, the audit log, the evaluation set and guardrails; model calls and hosting are monthly run costs.

Run: the monthly bill after launch

Running costs are model tokens, hosting, logs and monitoring, plus the time to update prompts and models as vendors release new versions. For most business agents tokens are the smallest of these at modest volume, and the largest at high volume. The worked example below shows how to estimate them.

AI agent cost by type

The type of agent decides most of the build price, because it decides how many systems the agent touches and how much it is trusted to do alone. The ranges below are how we place work inside our published band; the fixed quote comes from discovery.

Where common agent types land in a $25k–$120k build

Agent type	What it does	Typical scope	Where it usually lands
Single-task assistant	Answers questions or drafts replies from one knowledge source; a person sends	One system, read-only, citations, basic evaluation	Low end, from $25k
Workflow agent	Reads and writes two to four systems and takes actions inside rules, with approvals	CRM or ERP writes, approval queue, audit log, evaluation per action	Middle of the range
Multi-agent system	Specialist agents work in parallel, process documents and cite every finding to its source	Document intelligence, several data feeds, tenant isolation	Top of the range, up to $120k; larger scopes are phased

Two of our own builds sit at different points on that table. Superdeal is a workflow agent inside a campaign CRM: its scope is creator discovery on three social platforms, drafted offers, and an approval step on everything it sends. Relm is a multi-agent system: specialist agents run in parallel over 20+ data feeds and uploaded documents, and every finding cites its source. Relm’s scope is much larger, and the reasons are integrations and documents, not the model.

Two agent types carry extra line items the table does not show. A single-task assistant that answers from documents is a RAG system, and the RAG assistants we build are priced by how messy and permissioned those documents are; RAG development cost breaks that down. Voice agents add telephony, speech-to-text and text-to-speech to every minute of every call, which AI voice agent cost prices line by line.

What drives the cost of an AI agent?

Five things move a quote, and the choice of model is not one of them. Model choice changes the running cost, but it rarely changes the build price by much.

Cost drivers and how to keep each one down

Driver	Why it costs money	How to keep it down
Integrations	Each system needs auth, rate-limit handling, error paths and tests, and writes need rollback	Start read-only; add writes once the agent’s decisions are trusted
Data readiness	Scans, inconsistent fields and missing history must be cleaned or worked around	Prototype on real data in discovery, not a curated sample
Compliance	HIPAA, PCI or SOC 2 controls add hosting constraints, logging and review	Keep regulated data out of scope for version one where you can
Evaluation	Every action needs test cases that prove correct behavior, rerun on each change	Build the evaluation set from real past cases you already have
Autonomy	The more the agent does without a person, the more guardrails and approval logic it needs	Launch with human approval on high-impact steps, then relax it with data

Integrations are usually the biggest line item

An agent that cannot read from and write to your systems of record is a demo. Each integration means authentication, handling the API’s limits and failures, mapping fields, and testing what happens when a write half-succeeds. With three or more integrations, this work can outweigh the agent logic itself.

Evaluation is what makes an agent shippable

Pilots skip evaluation and pay for it later. An evaluation set is a library of real cases with the correct outcome, run against every prompt or model change. It is the difference between “it worked in the demo” and “we know it works”. Budget for it as its own line: someone has to collect the cases, agree the correct outcomes with the people who do the work today, and rerun the set whenever a prompt or model changes. We cover why skipping it stalls projects in why AI pilots stall before production.

Human approval is cheaper than full autonomy

Every step an agent takes on its own needs guardrails: confidence thresholds, limits, rollback and logging. Putting a person on the high-impact steps for the first months is faster to build and easier to get past risk and compliance review. You remove approvals one by one as the logs show the agent is reliable. Our checklist of AI agent guardrails lists the controls an agent needs before any approval comes off.

Worked example: what an AI agent costs to run each month

An agent’s running cost is mostly tokens: the text sent to the model and the text it writes back. Here is the arithmetic for a realistic workflow agent, using list prices from Anthropic’s pricing page.

Assumptions: the agent handles 20,000 tasks a month. Each task makes four model calls. Each call sends 6,000 input tokens, of which 4,500 are a stable system prompt and tool definitions that prompt caching can reuse, and gets back 500 output tokens. List prices per million tokens, checked October 18, 2026, are $2 input, $0.10 cache read and $10 output for Claude Sonnet 5.5, and $1, $0.10 and $5 for Claude Haiku 4.5. Anthropic bills cache reads at 0.1 times the input price on most models and at 0.05 times on Sonnet 5.5, which is why both read prices are $0.10.

Monthly token cost for 20,000 tasks (list prices)

Model	Cost per call, cached	Monthly, with caching	Monthly, no caching
Claude Haiku 4.5	$0.0045	about $356	about $680
Claude Sonnet 5.5	$0.0085	about $676	about $1,360

How the cached Sonnet 5.5 call is worked out: 1,500 uncached input tokens at $2 per million is $0.0030, 4,500 cached tokens at $0.10 per million is $0.00045, and 500 output tokens at $10 per million is $0.0050, so about $0.0085 per call. Four calls per task and 20,000 tasks give about $676. The small premium for writing to the cache is left out because it is paid once per cache window, not per call.

One cached Sonnet 5.5 call, about $0.0085

Output, 500 tokens: $0.0050
Uncached input, 1,500 tokens: $0.0030
Cached input, 4,500 tokens: $0.00045

Four calls per task and 20,000 tasks: about $676 a month.

Three things change this number more than the model price does:

Caching. Reusing the stable part of the prompt roughly halves the bill here.
Routing. Sending easy steps to a small model and only hard ones to a larger model lowers the average cost per task; the table shows the gap between the two tiers is about 2x.
Tokenizer. Anthropic notes that Claude 4.7 and later models use a tokenizer that produces about 30% more tokens for the same text, so estimates made with an older tokenizer will run low.

The same agent at 2,000, 20,000 and 100,000 tasks a month

Token cost grows in a straight line with volume; the build price does not move. Multiplying the per-call figures above by four calls per task gives these monthly totals:

Monthly token cost by volume (4 calls per task, list prices checked Oct 18, 2026)

Tasks a month	Haiku 4.5, cached	Haiku 4.5, no cache	Sonnet 5.5, cached	Sonnet 5.5, no cache
2,000	about $36	about $68	about $68	about $136
20,000	about $356	about $680	about $676	about $1,360
100,000	about $1,780	about $3,400	about $3,380	about $6,800

Read across a row and the cheapest option is always the small model with caching; read down a column and only volume changes the bill. At 2,000 tasks the model is a rounding error next to hosting. At 100,000 it is a real line, and caching and routing decide whether it is $1,780 or $6,800.

On top of tokens, budget for hosting the agent service, logs and traces, and scheduled evaluation runs. These depend on your cloud and your retention rules, so treat them as their own line rather than guessing a percentage.

What an AI agent costs to maintain after launch

Maintenance is the engineering that keeps an agent correct while everything around it changes. The model bill is predictable; these four jobs are what surprise budgets:

Model and price changes. Vendors retire models and change prices; each switch means rerunning the evaluation set before the new model goes live.
Evaluation reruns. Every prompt change, tool change or new edge case from production goes through the full test set, and the set grows as users find new cases.
Monitoring and traces. Someone reads the logs of failed and escalated tasks each week and turns them into fixes or new test cases.
Integration drift. When a connected CRM, ERP or API changes a field or an auth flow, the agent starts failing without an error message unless a test catches it.

Our builds include 30 days of support after launch. After that, owners usually choose small fixed-price change requests for occasional updates, or a Dedicated Team when the agent has a roadmap of its own. We don’t publish a maintenance percentage of the build price, because it depends on how many integrations can drift and how often your process changes, not on what the build cost.

Why quotes for the same AI agent differ so much

Two quotes for the “same” agent usually describe different systems. One vendor prices a prototype with a read-only connection; another prices writes, approvals, an audit log and a test set. Before comparing totals, line the quotes up against six questions:

Check every AI agent quote for these six items

Check	What a complete quote states	What a thin quote leaves out
Integrations	Each system named, read or write, and who supplies API access	“Integrates with your CRM”
Evaluation set	Roughly how many real cases, who writes the expected outcomes, when it runs	“Testing” as one line
Approval steps	Which actions need a person and how the approval queue works	Nothing, or “human in the loop” with no detail
Audit log	What is logged per action and how long it is kept	Nothing
Ownership	Code, prompts, evaluation set and cloud accounts in your name	A license to use the vendor’s platform
Post-launch support	A fixed support window and how changes are priced after it	“Ongoing support available”

Watch out

A thin quote is not a cheaper one

A quote that is low because it leaves out the evaluation set or the approval steps is not cheaper; it moves that cost to after launch, when it is paid as an incident.

For the questions to put to the vendor behind the quote, see questions to ask an AI agent development company.

Fixed price vs time and materials for an AI agent

A fixed price after discovery protects the buyer from overruns; time and materials protects the vendor. For AI agents, where the main risk is unknown data and integrations, the fix is to resolve those unknowns first and then fix the price, which is what discovery is for.

Pricing models for an AI agent build

	Fixed price after discovery	Time and materials	Dedicated team
Best for	A defined agent or product	Research with no clear end	An ongoing roadmap
Who carries overrun risk	The vendor	You	Shared, scope flexes monthly
Scope changes	Change request	Anytime, billed hourly	Anytime
Our price	$25k–$120k per project	Not offered	From $12k per month

We recommend fixing the price for the first production version, and moving to a Dedicated Team only if the agent becomes a product with its own roadmap. The trade-offs between the contract models are in our guide to fixed price vs time and materials.

When a custom AI agent is not worth paying for

A custom agent is not worth its build price when a product already does the job at your volume for less. The quickest test is arithmetic: multiply the product’s usage price by the volume you expect in year three, and compare it with the build plus three years of running cost.

Two published price lists show what that comparison looks like. Intercom lists its Fin AI Agent from $0.99 per outcome, so 1,000 outcomes a month is about $12,000 a year, well under a $25k build plus hosting and maintenance. Microsoft sells Copilot Studio as packs of 25,000 credits for $200 a month, which suits internal assistants that live inside Microsoft 365. At that kind of volume, inside tools you already use, buying wins on cost.

The arithmetic turns the other way when volume grows, when the agent has to write to your own systems, or when how it works is part of what you sell. A full three-year model, the lock-in questions to put to vendors, and the part-bought, part-built setup most agents end up with are in build vs buy AI agents.

How to budget for an AI agent project

Budget for the system, not the model. A realistic plan has four lines:

Four budget lines for an AI agent

Discovery: $5,000 (Weeks 1–2): Two weeks, ending with a working prototype and a fixed quote.
Build: $25k–$120k (6–16 weeks): Depending on agent type, integrations and compliance.
Run (Every month): Tokens from a worked estimate like the one above, plus hosting and monitoring.
Change (Ongoing): Model and prompt updates as vendors ship new versions, either as small fixed-price changes or a dedicated team.

Then pick one workflow and one number to move, such as hours saved, tickets resolved or decisions made per day, and hold the build to it. That keeps scope honest and makes the return easy to measure. If you want a fixed price for your own agent, our AI agent development team starts with a free AI audit: book the audit and bring the workflow you have in mind.

Sources

Claude API pricing, Anthropic
Intercom pricing (Fin AI Agent), Intercom
Microsoft Copilot Studio pricing, Microsoft

Originally published at apptycoons.com.

Creator platform revenue share: how to build splits, payouts and statements

Apptycoons — Tue, 08 Sep 2026 12:00:00 +0000

Quick answer: A creator revenue share needs attribution that ties every payment to one creator, a ledger that records each split as its own entry, and payouts on a fixed schedule. Decide before launch whether the share comes from gross or net revenue, since app store fees take 15% to 30%, and price your payout threshold against per-payout fees.

On DubCam, a fan picks a program at sign-up, 50% of every subscription is attributed to that program, and the money goes out on the 1st of the month with no minimum threshold. That one sentence hides four systems: attribution, a ledger, payouts and tax reporting. It also hides a choice most platforms make too late: is 50% of the price the fan paid, or of what is left after the app store takes its cut?

This guide covers each system with real published fees and the arithmetic, so you can set the rules before the first statement goes out.

What a creator revenue share system needs

A revenue share is four systems that must agree with each other every month:

Attribution: every payment linked to exactly one creator, by a rule the fan can see.
Ledger: every split, fee, refund and payout recorded as its own entry.
Payouts: creators paid on a fixed schedule through a provider that verifies who they are.
Statements and tax: each creator sees how their number was calculated, and the platform files the forms the law requires.

The percentage in the contract is the easy part. Creators leave when a statement can’t be explained or a payout is late, not when the split is a few points lower than a rival’s.

Attribution: decide who gets credit, once

The most trusted attribution rule is the one the fan chooses. On DubCam the fan picks who to back at sign-up, and renewals follow that choice until the fan changes it. Store the choice on the subscription, keep a history of every change with its date, and show the fan who they are supporting.

Attribution on DubCam: the fan chooses

Fan signs up: Picks a program to back
Choice stored: On the subscription, with its history
50% attributed: Renewals follow the choice
Paid on the 1st: No minimum threshold

Disputes start when credit is inferred, for example from viewing time that nobody outside the platform can see. If your model has to split one subscription across several creators by usage, publish the formula and keep the usage data each split was based on, because a creator will ask.

The ledger: every split as an entry

Each payment should create separate ledger entries for the fee, the platform’s share and the creator’s share, all linked to the original transaction. Refunds and chargebacks create new entries that reverse the old ones; nothing is edited.

Here is one $10 web subscription with a 50% creator share of gross, refunded the next week. The fee is Stripe’s standard US card rate of 2.9% plus 30 cents, as listed in October 2026; the numbers are illustrative, not a client’s.

Ledger entries for one $10 web subscription and its refund (illustrative)

Event	Entry	Amount
Payment	Cash received	+$10.00
Payment	Card processing fee	−$0.59
Payment	Creator payable (50% of gross)	+$5.00
Payment	Platform revenue (what remains)	+$4.41
Refund	Cash returned	−$10.00
Refund	Creator payable reversed	−$5.00
Refund	Platform revenue reversed	−$4.41

Whether the processing fee comes back on a refund depends on your processor’s terms, so model it as its own entry rather than assuming. A creator statement is then a filtered view of the creator payable lines, and any line traces back to the payment that produced it.

Gross or net: the store fee decides

App store fees take 15% to 30% of an in-app subscription, so a share of gross and a share of net can differ by more than a dollar on a $10 plan. Apple pays developers 70% of an auto-renewable subscription price in a subscriber’s first year and 85% after one year of paid service; free trials don’t count toward that year. Members of the App Store Small Business Program, for developers with up to $1 million in proceeds in the prior year, receive 85% from the start. Google Play lists 10% plus a 5% billing fee on auto-renewing subscriptions bought through Play Billing by users in the US, EEA and UK (rolled out June 30, 2026) and in Australia and Japan (September 30, 2026), on a developer’s first $1 million of annual earnings.

$10 monthly subscription, 50% creator share, by channel (our arithmetic on published rates, taxes excluded, October 2026)

Channel	Fee	Platform receives	Creator at 50% of gross	Creator at 50% of net	Platform keeps if share is of gross
Web, card via Stripe (2.9% + 30¢)	$0.59	$9.41	$5.00	$4.71	$4.41
iOS, subscriber’s first year (30%)	$3.00	$7.00	$5.00	$3.50	$2.00
iOS after one year, or Small Business Program (15%)	$1.50	$8.50	$5.00	$4.25	$3.50
Google Play, US Play Billing (10% + 5%)	$1.50	$8.50	$5.00	$4.25	$3.50

The last column is the one founders miss. A share of gross on iOS in year one leaves the platform $2.00 of every $10, before hosting, streaming and payout costs. A share of net keeps the platform’s margin steady but pays creators less on mobile than on the web. Neither is wrong. The creator terms must say which rule applies, the ledger must calculate it the same way, and the statement must show it.

Our arithmetic on Apple’s published 70% first-year rate, taxes excluded.

Can you send fans to the web to pay?

In the United States storefront, yes. Apple’s App Review Guidelines, section 3.1.1(a), say entitlements “are not required for developers to include buttons, external links, or other calls to action in their United States storefront apps.”

Watch out

The US rule is not global

In other storefronts, links to outside purchasing need a specific entitlement or are not allowed, so check the guidelines for each country you launch in.

A web checkout changes the fee line in the table above, not the creator rule. Record the channel on every payment, and decide whether creators earn the same share whichever way the fan paid. Most platforms keep the rule identical so creators don’t have to understand app store economics.

What payouts cost, and why most platforms set a minimum

Paying a creator has a fixed cost per account and per payout, so small payouts are expensive. Stripe Connect’s pricing where the platform sets its own fees lists $2 per monthly active account (an account is active in any month it receives a payout), 0.25% plus 25 cents per payout, 1% for instant payouts and $2.99 per 1099 form e-filed with the IRS, as of October 2026.

Cost of one monthly payout on Stripe Connect (our arithmetic, October 2026 list prices)

Creator owed	Active account	Payout fee	Total	Share of the payout
$3	$2.00	$0.26	About $2.26	About 75%
$30	$2.00	$0.33	About $2.33	About 8%
$300	$2.00	$1.00	About $3.00	About 1%

That is why most platforms set a minimum and roll smaller balances into the next month. DubCam pays on the 1st with no minimum threshold, which makes the promise to a small high-school program simple. Paying with no minimum means small balances carry per-payout fees in full, so decide who bears them before launch. It is a product decision, and it should be made with this table in front of you.

Payouts don’t have to leave your platform as bank transfers. Earnings can land in an in-app balance or wallet that creators spend by card, the model behind stablecoin wallet payouts on a platform we built for a partner network.

Refunds, chargebacks and payout timing

Pay creators from settled money, not from payments that can still be reversed. Three rules keep a platform from paying out money it later loses:

Hold period. Pay a month’s earnings after the refund window for that month has closed, or hold back a reserve until it does.
Reversals as entries. A refund or chargeback after payout creates a negative entry for the creator, linked to the original payment.
Negative balances carry forward. Deduct them from the next payout instead of chasing the creator, and show the deduction on the statement.

Tell creators the schedule and the hold rule in writing before their first payout. A late payout explained in advance costs less trust than an early one clawed back.

Tax and identity: what the platform must collect

Verify every creator before the first payout and collect tax details at onboarding, not at year end. Payout providers such as Stripe Connect run identity verification of the people you pay; your onboarding should collect a W-9 from US creators and a W-8 from non-US creators.

In the US, the IRS says payment apps and online marketplaces must file Form 1099-K when a payee’s payments for goods or services exceed $20,000 in more than 200 transactions, and that payees may receive the form for smaller amounts. In the EU, the DAC7 directive (Council Directive (EU) 2021/514, applied from January 1, 2023) requires platform operators to report sellers carrying out certain activities, including personal services, defined as time- or task-based work done at a user’s request. Whether a creator subscription counts depends on the model, so put the question to tax counsel during discovery. This section is not tax advice.

Build or buy a creator payout system

Buy when monetization isn’t your product. Patreon, for example, lists a 10% platform fee on creators’ income for creators who publish after August 4, 2025, plus payment processing, currency conversion and payout fees, as of October 2026. For a creator who only needs a membership page, that is cheaper than any build.

Buy a membership tool or build the payout system

Buy (Patreon, for example)

10% platform fee for creators who publish after August 4, 2025
Plus processing, currency conversion and payout fees
Cheapest when a membership page is all you need

Build (DubCam, for example)

Fans back a specific program
Split rules no membership tool expresses
Live video and payouts in one branded app

Build when the split, the attribution or the app is the product: a network where fans back a specific program, a share that follows rules no membership tool expresses, or live video and payouts inside one branded app. DubCam is that case. The same build or buy test applies to partner commissions, and the three-year numbers for that decision are in affiliate tracking: build or buy.

A custom build also decides your platforms. Live video and subscriptions on iOS, Android and the web is a different scope from a web-only membership site; the trade-offs between one shared codebase and separate apps are in native vs cross-platform development.

What we learned building DubCam

Letting the fan choose the creator at sign-up made everything downstream simpler. Attribution is a stored field, not a model. A creator’s statement is a list of their supporters’ payments. Support questions about “why did I earn this” have one answer.

DubCam ships as iOS and Android apps plus the web, with a ten-minute free preview before a fan subscribes, in-app purchases on the App Store and Google Play, and automated payouts on the 1st. The no-minimum rule tells a small program that every supporter counts.

What a revenue share build costs

A streaming app with subscriptions, attribution, a ledger and payouts is a fixed-price build within our $25k–$120k range, delivered in 6–16 weeks after a Discovery Sprint. In our judgment, these move it up the band: live video rather than uploads only, iOS plus Android plus web, more than one payout rail, a creator statements portal, and usage-based splits instead of fan-chosen ones. The pricing page has the terms.

If you are planning a creator or streaming product, our live streaming and creator platform development work covers subscriptions, splits and payouts, and our mobile app development team ships the iOS and Android apps.

Sources

Auto-renewable subscriptions, Apple Developer
App Review Guidelines, Apple Developer
Service fees, Google Play Console Help
Connect pricing, Stripe
Pricing, Stripe
A standard platform fee for new creators, effective after August 4, 2025, Patreon Help Center
Understanding your Form 1099-K, IRS
Council Directive (EU) 2021/514 (DAC7), EUR-Lex

Originally published at apptycoons.com.

Why sub-second latency makes or breaks a voice agent

Apptycoons — Thu, 30 Jul 2026 12:00:00 +0000

Quick answer: Aim for the agent to start speaking within about one second of the caller finishing, and faster where you can. People leave gaps of roughly 200 ms between turns, so longer silences feel like a broken line. Measure from the end of the caller’s speech to the first audio they hear, at the median and the 95th percentile.

In conversation, people leave about 200 ms between turns. When an agent takes two seconds to respond, callers start talking over it — or hang up.

That pause is the first thing a caller judges, before they notice the voice or what the agent says, and most of it can be engineered away.

How fast should a voice agent respond?

A voice agent should start speaking within about one second of the caller finishing, and faster is noticeably better. That target comes from how people talk to each other, not from what the technology finds easy.

Conversation research is consistent here. Levinson and Torreira summarize it as gaps between turns “of the order of 200 ms”, while the time a person needs to plan even a short utterance is over 600 ms. People manage this by predicting how the other speaker will finish and preparing a reply while they are still listening. A comparison of ten languages by Stivers and colleagues found the same pattern everywhere: speakers avoid overlap and minimize silence, and the average gap varies by language only within about 250 ms of the cross-language mean.

The phone network has its own guideline. ITU-T G.114 sets a target of 150 ms one-way delay for most voice uses, before any AI is involved. Together, these numbers explain why a two-second silence feels broken: it is roughly ten times longer than the gap a caller expects.

Where the time goes

Where one turn’s time goes, in order

Network in: Caller audio reaches your services
Speech to text: Finishing the caller’s sentence
Language model: Deciding what to say or which tool to call
Text to speech: Producing the first audio
Network out: Audio travels back to the caller, plus the network hops between each service

Each item hides a further delay. Before transcription can finish, the system has to decide that the caller has stopped talking. The model’s first token arrives quickly, but a long system prompt, a large model or a tool call can push the first useful sentence much later. Speech synthesis needs a full phrase to sound natural. And on a phone call, audio travels from the carrier to your telephony provider, then to each AI service and back, so a service hosted far from the others adds a round trip on every turn.

Mid-call lookups belong in the same budget: when a dealership booking agent loads a vehicle’s service menu or checks open slots during an Xtime API integration, each request is a tool call inside the caller’s turn, and the caller waits through it.

A latency budget, stage by stage

A one-second target only works if each stage has its own share of it, written down before the build. The table splits a turn into stages, with the published figure for each where one exists, checked October 18, 2026, and how to measure the rest.

Latency budget for one voice agent turn (published figures checked October 18, 2026)

Stage	Published figure	What the figure covers	How to measure it on your calls
Phone network, each direction	150 ms one-way target (ITU-T G.114)	Mouth-to-ear delay for most voice uses	Carrier and telephony timestamps on test calls
End-of-turn detection	500 ms silence in OpenAI’s example VAD setting	An example configuration, not a default	Time from the caller’s last word to the turn-end event
Speech-to-text final	No comparable figure	Depends on model, audio and region	Turn-end event to final transcript
Language model	No comparable figure	Depends on model, prompt length and load	Transcript to first complete sentence
Tool calls	Your own APIs	Lookups in your systems	Request to response, per tool
Text-to-speech first audio	About 75 ms for ElevenLabs Flash v2.5	Model only, excluding application and network latency	Sentence sent to first audio byte

The table shows why the fixed parts matter. With the network at the G.114 limit in both directions and a 500 ms silence threshold, those two items alone take 800 ms (150 + 150 + 500), before transcription, the model or speech start. That is illustrative arithmetic, not a measurement, but it is why end-of-turn tuning and same-region hosting do more for latency than swapping models.

150 + 150 + 500 = 800 ms before transcription, the model or speech start.

Why vendor latency numbers don’t add up

Vendor latency figures usually measure one model in isolation, while the caller hears the whole chain. ElevenLabs is explicit about this: its models page lists Flash v2.5 at about 75 ms and marks the figure as excluding application and network latency.

That is a fair way to describe a model, and it is the right comparison between models. It is not what a caller experiences. Add up model-only figures for speech-to-text, the language model and text-to-speech, and the sum still leaves out end-of-turn detection, the phone network, the hops between services and any tool call. Those are the stages that set the pause a caller hears.

When a vendor quotes a latency number, ask three questions: which stages it covers, whether it is a median or a 95th percentile, and whether it was measured on a phone call or in a browser.

End-of-turn detection is the hidden delay

The most overlooked delay is deciding when the caller has finished. A simple voice activity detector waits for a fixed stretch of silence before it ends the turn. OpenAI’s documentation for its realtime API describes the trade-off directly: with a shorter silence duration, turns are detected more quickly. Set it too short, and the agent interrupts people who pause mid-sentence; set it too long, and every reply starts late.

Newer approaches look at meaning as well as silence. LiveKit’s agent framework, for example, uses a turn detector model that predicts the end of a turn from both what was said and how it sounded, on top of voice activity detection, and can adapt its delay to the caller’s own pauses. OpenAI offers a semantic mode with an adjustable eagerness setting. Neither removes the trade-off, but both let the agent answer quickly when a sentence is clearly complete and wait when it is not.

How to cut latency without making the agent worse

We stream every stage, start speaking before the full response is generated, and run tool calls in parallel with filler acknowledgements — so the agent feels present even while it works.

That comes down to six choices:

Stream transcription, generation and speech, so each stage starts on partial output instead of waiting for the previous one to finish.
Send the first sentence to speech synthesis as soon as it is complete, and keep generating the rest while it plays.
Keep the speech, model and telephony services in the same region, and keep connections warm between calls.
Keep the system prompt short and move rarely needed instructions into tools, so the model reads less on every turn.
Use a smaller, faster model for routing and simple turns, and a larger one only where reasoning is needed.
Cache data that does not change during a call, such as opening hours or the caller’s account, after the first lookup.

None of these require a worse answer. The goal is to remove waiting, not thinking.

Interruptions matter as much as speed

A fast agent that cannot be interrupted still feels robotic. When a caller starts talking, the agent should stop speaking almost at once, keep what it heard, and respond to the interruption rather than finishing its script. Frameworks such as LiveKit pause agent speech when they detect the caller and can tell a real interruption from a backchannel like “uh-huh”, so the agent does not stop every time someone agrees with it.

Test this on purpose. Interrupt the agent mid-sentence, talk over it in a noisy room, and pause halfway through a long account number. These are the moments callers remember.

Latency targets by call type

Not every call needs the same speed, and the right target depends on what the caller is trying to do. A booking or FAQ call is made of short, scripted turns where speed is most of the experience. A discovery or sales call has longer answers where quality matters more than shaving a few hundred milliseconds.

Booking, FAQs and routing. Short questions and short answers. Aim for the fastest turns you can measure, a small fast model for most turns, and cached data such as opening hours.
Account lookups and changes. The tool call dominates. Acknowledge at once (“Let me check that”), run the lookup in parallel, and set a budget per tool.
Discovery, sales and support with judgment. Longer reasoning is acceptable if the agent signals it is thinking. Keep the first sentence fast and let the rest follow.
Regulated calls, such as healthcare scheduling. A disclosure or confirmation step adds a turn by design; budget for it instead of cutting it. Our healthcare software development page covers the privacy side of those calls.

Example call (illustrative): acknowledge, then look up

Caller: Can I move my appointment to Friday?
AI agent: Let me check that.
AI agent: Friday has 10 am or 2 pm open. Which works better?
Caller: 2 pm, please.

Whatever the type, measure the same way and report the median and the 95th percentile separately for each call flow.

Platform or custom pipeline: who controls the latency?

Hosted voice platforms such as Vapi and Retell assemble the pipeline for you: telephony, transcription, model and voice behind one API. That is the fastest way to a working agent, and for many call flows their latency is good enough. The trade-off is control. You choose from the vendors and regions the platform supports, and when a turn is slow, you can see less of why.

A custom pipeline, built on frameworks such as LiveKit or Pipecat, puts every stage under your control: where each service runs, which models handle which turns, how end-of-turn detection is tuned, and how tool calls are scheduled. It takes more engineering and more operational work. It is worth it when calls involve heavy lookups in your own systems, when data must stay in a specific region, or when volume makes per-minute platform fees a large line item. Same-region hosting does double duty there: it cuts a network hop on every turn and it is also how an agent keeps EU callers’ data in an EU region when a client asks for it; the transfer rules are explained in EU AI Act and GDPR rules for AI agents. The per-minute side of the decision is worked through in AI voice agent cost. Whichever route you take, measure it the same way.

Who controls the latency

Hosted platform (Vapi, Retell)

Fastest way to a working agent
Vendors and regions the platform supports
Less visibility into why a turn is slow

Custom pipeline (LiveKit, Pipecat)

More engineering and operational work
You choose where each service runs
Every stage under your control

How to measure voice agent latency

Measure what the caller hears, not what a dashboard reports. The number that matters is the time from the end of the caller’s speech to the first audio of the reply, recorded on a real phone call.

Place test calls over the phone network, not only in a browser demo, because the carrier and telephony hops add delay a demo never sees.
Record both sides of the call and mark the end of caller speech and the start of agent audio.
Report the median and the 95th percentile across many turns; a good median with a slow tail still produces awkward calls.
Log each stage separately, so a slow turn points to transcription, the model, a tool or speech synthesis.
Repeat the test with background noise, accents and the longest tool calls in your flow.

Run this test on your own call flows before launch, because a latency figure measured on a different script, network or vendor mix says little about your calls.

“Latency isn’t a technical metric. It’s the difference between a conversation and a phone tree.”

What to do next

If you are planning a voice agent, set a latency target alongside your business goals, and ask any vendor or platform how they measured theirs. Our AI voice agent development work starts with your call flows, integrations and a latency budget for each one. To put a value on every answered call, read what missed calls really cost or put your own call volume into the AI voice agent ROI calculator.

Sources

Timing in turn-taking and its implications for processing models of language, Frontiers in Psychology (Levinson & Torreira, 2015)
Universals and cultural variation in turn-taking in conversation, PNAS (Stivers et al., 2009)
What is latency? (ITU-T G.114 one-way delay target), Twilio
Turn detection and interruptions, LiveKit Agents docs
Voice activity detection (VAD), OpenAI API docs
Models, ElevenLabs docs

Originally published at apptycoons.com.