Hire an AI Agent Developer:Freelancer vs Agency vs In-House

"Should I just hire someone?" That question comes up on discovery calls about AI agents, often right after a founder hears an agency price and compares it in their head with a salary they saw on a job board.

It's a fair question. I run an agency, so you should read everything below knowing that I have a horse in this race. I'd still rather you make the right call than the one that happens to pay me.

So here's the claim, stated up front and dated. As of September 28, 2026, there are three honest ways to get an AI agent built: a freelancer, an agency, or an employee. Each one is the right answer for somebody. Each one is expensive in a way its fans don't mention.

The wrong model most buyers bring to this is that it's a price comparison. Hourly rate against hourly rate, salary against invoice, pick the smallest number. The better model is that you're deciding where the boundary of your company should sit for this piece of work. Price matters, but so do time, ownership, legal exposure, and who is left holding the agent when the person who built it leaves.

Therefore this article compares all three on the same six things, with the numbers verified live on the day I wrote it, and ends with a decision table you can actually use. If you already know you want an outside team and just need a shortlist, the ranked list in our guide to the top AI agent development companies is the faster read.

The three models differ less in who writes the code than in who carries the risk around it.That's the frame to keep in your head for the rest of this piece.

A freelancer sells you hours or a fixed deliverable. They write code. Everything around the code (product decisions, the security review, the test plan, the account ownership, the handover) is yours unless you pay for it explicitly.

An agency sells you a delivery process. You pay more per hour, and in exchange a team absorbs some of the risk: a lead who scopes the work, someone who reviews it, a warranty period, a replacement if a developer leaves. Whether you actually get those things depends entirely on the agency, which is why vetting matters so much.

An in-house employee sells you their time and, over the years, their accumulated knowledge of your business. You carry all the risk and all the management, and you keep all the learning.

There's a fourth option people forget, which is not hiring anyone to write code at all. If your job is a common one (answering the phone, booking appointments, qualifying leads) and the tools you use are ordinary ones, a packaged agent may do it. We sell those too, at a fixed price published on our AI agents page, and I'll come back to where they fit in the decision table.

The table is the summary. The sections that follow are the evidence, starting with the number everyone asks about first.

An in-house AI agent developer costs roughly 1.43 times their salary once benefits are added, and that's before recruiting, equipment or equity.Here's where that multiplier comes from.

First, a problem with the question itself. "AI agent developer salary" is a search term, not an occupation. The US Bureau of Labor Statistics doesn't track it, so there is no official number for it, and anyone who gives you one precisely is either quoting a job board or guessing.

The closest official categories are two. According to the BLS Occupational Employment and Wage Statistics for May 2025, the latest release, software developers (SOC 15-1252) had a median annual wage of $135,980 and a mean of $148,100. Computer and information research scientists (SOC 15-1221), the category closer to research-heavy machine learning work, had a median of $140,300 and a mean of $153,930.

My working assumption, not a measured figure, is that most people building production agents fit the first bucket better: software engineers who learned to work with models, not researchers who train them. So I use the software developer figures as the baseline and treat the research scientist figures as the upper bound of the official data.

Then there's the market data, which tells a different story. Levels.fyi, which collects self-reported offers, showed a US median total compensation of about $280,000 for machine learning engineers and about $249,000 for its ML and AI software engineer focus when I checked in September 2026. Its "AI Engineer" title showed a median closer to $153,750.

To be clear, those Levels.fyi numbers are not comparable to BLS. They're self-reported, they include equity, they skew heavily toward large technology companies, and they move daily. I read them from search snippets rather than the full page. If you're a 30-person company in Ohio, the BLS median is a far better guide to what you'll pay than a figure built from big-tech offer letters.

That $93 an hour is the number worth remembering. It's what a median-wage employee costs per paid hour, including holidays, meetings, onboarding and the weeks where there's no agent work to do. You pay it whether the agent roadmap is full or empty.

Toptal, for what it's worth, cites a Glassdoor base pay range of $99,000 to $132,000 for AI developers as of April 2025 on its AI hiring page. That's a vendor quoting a third party, and Toptal publishes no hourly rate of its own, so treat it as colour rather than a benchmark.

Freelance AI developers on Upwork describe themselves as charging anywhere from about $30 to $150 an hour, and the spread inside that range tells you more than the average.

Upwork's own hiring pages returned an error to our fetcher, so these figures come from the search snippets of those pages in September 2026. They're the marketplace's descriptions of its sellers, not audited rates, and I attribute them accordingly.

Sources for each row: Upwork's pages for AI developers, AI engineer costs and machine learning expert costs. Upwork also runs a dedicated AI agent developers page, which tells you the category is now big enough to sell on its own. The client pays a marketplace fee on top of these rates.

Now compare that with the employee. The median employee costs about $93 per paid hour, fully loaded. An expert AI engineer on Upwork at about $100 an hour is roughly the same money per hour, give or take the marketplace fee.

So why does freelancing look so much cheaper in practice? Because you only pay for the hours you use. Suppose a first agent takes about 400 hours of senior work. At $100 an hour that's about $40,000. The same 400 hours from an employee is also about $37,000 of loaded cost, but you've hired a person for 2,080 hours, not 400. If there's no second agent lined up, the other 1,680 hours are either spent on something else or wasted.

That's the whole case for freelancing in one line: 2,080 ÷ 400 is about 5.2, so for a single bounded agent you're buying roughly a fifth of a year instead of a whole one.

The downside, stated in the same breath: the cheap end of that range is cheap for a reason. A $30-an-hour developer building their first agent will learn on your project, and the lessons they learn (about tool permissions, about testing, about what happens when a customer types something odd) are expensive ones for you. Hourly rate and total cost are different numbers.

Clutch says most AI development companies listed on it charge $25 to $49 an hour, and that US and Canadian providers typically charge $50 to $99. Both numbers need context before you use them.

The Clutch AI development pricing guide, checked in September 2026, is built from verified client reviews on the platform. It says the average AI project costs about $120,595, that projects typically run around ten months, and that the most common project size falls between $10,000 and $49,999. Providers in India, the Philippines and Ukraine typically charge $25 to $49 an hour.

That's useful, but notice who is in the sample. The listed firms skew toward India, the Philippines, Ukraine and other lower-cost regions, so the headline rate is pulled down by geography. The broader Clutch software development pricing guide, updated September 21, 2026, shows the same pattern: most common hourly $25 to $49, most common project $10,000 to $49,999, average project about $132,480 over about 13 months.

I'm going to be plain about our own number, because it sits above the Clutch average. Frenchy Digital's senior-led rate is $150 to $225 an hour. We price most work as fixed-price phases instead: a discovery and workflow audit at $9k to $22k over 2 to 4 weeks, a single-workflow agent at $28k to $70k over 4 to 9 weeks, a multi-workflow platform with system integration at $70k to $180k over 9 to 16 weeks, and enterprise, multi-site or regulated builds at $180k to $420k+ over 14 to 24 weeks.

Why pay more than the Clutch average? You shouldn't, unless you're getting something the average doesn't include. For us that's a senior person on every build, a fixed-price proposal within 5 business days, a 30-day post-launch warranty, and full transfer of source code and IP. You can compare that against what the providers in our roundup of Los Angeles AI agent developers put in writing.

And a second admission. Our packaged agents cost $5,000 plus a one-time $5,000 setup fee, paid through a single Stripe Checkout as one-time charges, not a subscription. Most packaged builds run 2 to 4 weeks according to the product pages, custom ones 2 to 6. That's much less than the $28k to $70k single-workflow band, and people reasonably ask how both can be true.

The answer is scope. A packaged agent is a fixed, pre-scoped job running on systems you already use: the calendar, the inbox, the CRM. The bespoke bands price the work that goes beyond that: several systems to integrate, custom write paths, regulated data, multi-agent orchestration. Ongoing model, telephony and hosting costs aren't published on the product pages; we scope them on the call. The AI agent creation service page covers the bespoke side.

A contractor can usually start within days to a few weeks; an employee takes months, and the interview loop alone is slower for technical roles.

The best public data I found comes from Ashby, which sells applicant tracking software, so read it as a vendor's benchmark. Its Talent Trends report, drawn from more than 54 million applications across about 93,000 jobs between January 2021 and March 2026, shows technical roles taking about 18 days from screen to final interview, against about 14 days for business roles.

That's only the middle of the process. It doesn't include writing the job description, sourcing candidates, the offer negotiation or a notice period at the candidate's current employer. Stack those up and the total is measured in months, not weeks. I've seen longer end-to-end figures quoted for engineering roles in search snippets, but I couldn't confirm them on the pages themselves, so I'm not printing them.

There's also a harder problem underneath the calendar. If nobody at your company has built an agent, who runs the technical interview? A hiring manager without the background can screen for general engineering ability, but can't easily tell a candidate who has shipped an agent to production from one who has built a demo. That's not a timing problem. It's a quality problem that shows up six months later.

Think of it like hiring a contractor to redo your kitchen when you've never renovated anything. You can check reviews and licences. What you can't easily judge is whether their plan for the plumbing is any good, and you find out when the floor gets wet.

Timing favours outside help for a first agent. It stops favouring it once you know what good looks like and have a steady stream of work.

If a freelancer or agency writes your agent and nothing is signed, they probably own the copyright in the code, not you. This is the part of hiring that most founders learn about too late. What follows is general information, not legal advice; have a lawyer review your contract.

The US Copyright Act defines a "work made for hire" in 17 U.S.C. 101. There are two routes. The first is a work prepared by an employee within the scope of their employment, which is why an in-house developer's code belongs to the employer by default.

The second route is a specially ordered or commissioned work that falls into one of nine listed categories (a contribution to a collective work, part of a motion picture or other audiovisual work, a translation, a supplementary work, a compilation, an instructional text, a test, answer material for a test, or an atlas) and where both parties sign a written agreement saying it's a work made for hire.

Software isn't on that list. So the common contract clause that simply declares the contractor's code a "work made for hire" often doesn't do what it claims. The Copyright Office's Circular 30 walks through the same two-part test.

What actually moves ownership is an assignment. Section 204(a) of the same Act requires a transfer of copyright to be in a writing signed by the owner. That's why a good contract includes both: a work-for-hire clause in case some part qualifies, and a present assignment of all rights as the backstop.

The accounts point matters as much as the copyright. Picture an agent where the code was assigned perfectly on paper, but the model provider key, the phone number and the hosting account all sat in the developer's personal name. Owning the copyright in code you can't deploy is a thin sort of ownership.

For what it's worth, full transfer of source code and IP is standard in our contracts, and our Beyond Points build is a fair example of how much sits outside the code itself: a Claude-based multi-agent system over MCP, a Gemini Flash chat layer, a Puppeteer browser agent in Docker on a VPS that completes card-to-partner transfers behind an explicit confirmation gate, and a Supabase backend with 71 edge functions and about 70 migrations. Those are build counts, not outcome claims. The point is that every one of those pieces has an account, a key or a server attached, and each one needs an owner on the client's side.

The classification trap. Calling someone a freelancer doesn't make them one, and in 2026 the federal rule is in flux while California's is strict. Again, this is general information, not legal advice.

At the federal level, the Department of Labor announced a proposed rule on February 26, 2026. It was published in the Federal Register on February 27 and the comment period closed on April 28. The proposal would rescind the 2024 rule and return to an economic reality test closer to the 2021 version, with two core factors: how much control the business has over the work, and whether the worker has a real opportunity for profit or loss.

As of September 28, 2026 that rule is still proposed, not final. The Department has said it isn't applying the 2024 rule in its own investigations, but the 2024 rule technically stays on the books until it is formally rescinded. The DOL rulemaking page is the place to check the current status before you sign anything. The IRS applies its own control-based test for tax purposes, which I didn't research for this piece.

California is where it gets harder. Under Labor Code section 2775, the ABC test, a worker is an employee unless all three of these are true:

• A: The worker is free from the hiring entity's control and direction in doing the work, both in the contract and in fact.
• B: The work is outside the usual course of the hiring entity's business.
• C: The worker is customarily engaged in an independently established trade, occupation or business of the same kind.

Part B is the one that bites software companies. If your business is software and you bring in a solo freelancer to build your core product, attending your standups and working your sprint, you have a hard time saying the work is outside your usual course of business. Exemptions exist in sections 2776 to 2784, and I didn't check them for this article; that's a conversation for an employment lawyer.

An agency engagement tends to sit more comfortably here, because you contract with a business that has its own clients, its own staff and its own methods. That's not a reason to pick an agency by itself. It's a real cost of the freelance route that doesn't appear on the hourly rate.

Every hiring model has a failure mode its advocates skip, and the right choice is the one whose failure you can survive.Here's each one, including mine.

Notice the pattern. Freelancers fail on continuity, agencies on cost, employees on speed and evaluation. None of them is "the safe choice". The useful question is which failure costs you least.

Economists have a clean answer to "should I hire or contract?", and it's older than software.

In his paper The Nature of the Firm, the economist Ronald Coase asked why companies exist at all, if markets are so good at pricing things. His answer, in one sentence: firms do internally the work that would cost more to buy on the open market once you count the cost of searching, negotiating, contracting and policing the deal. Those are transaction costs. When they're high, you make. When they're low, you buy.

Later economists sharpened this into a few questions that decide which way the scale tips. Applied to AI agents, they become three:

• How specific is the work to your business?: An agent that books appointments on a standard calendar is general; the market can price it. An agent wired into your proprietary pricing engine and your quirky ERP is specific; the knowledge of how it works is valuable only to you.
• How often does the work recur?: One agent, built once, is a single transaction. A roadmap of agents, each building on the last, is a continuous stream where contracting costs pile up every time.
• How hard is it to write down what 'done' means?: If you can specify the agent in a page and test it against that page, buying is easy. If 'done' keeps moving as you learn, every change becomes a renegotiation.

Now apply it. A receptionist agent on your existing phone and calendar scores low on all three: general, one-off, easy to specify. That's a buy, and often a packaged buy.

A customer-operations agent that reads from four internal systems and writes to two of them scores medium on specificity, medium on recurrence and high on specification difficulty. That's a buy from a team that can absorb the uncertainty, usually an agency on a phased contract, with knowledge transfer written in.

A company whose product isthe agent scores high on everything. Coase would tell you to make it, and so would I. That's a hire, possibly with outside help to get the first version out while you recruit.

The value of the frame is that it moves the conversation off hourly rates. A freelancer at $75 an hour can be the expensive choice if every change needs a new statement of work. An employee at $93 an hour loaded can be the cheap one if they're building the fifth agent on the same platform.

Find the row that looks most like your situation and start there; it's a default, not a verdict. I built it from the cost, time, ownership and transaction-cost reasoning above.

The last row is one I often lean toward, and I'll admit it suits my business. But it also matches the Coase logic: the uncertainty is highest on the first agent, which is exactly when buying a team's experience is worth the premium. Once you know what good looks like, bringing it in-house gets cheaper.

If your situation is the first row, look at the fixed-scope option before you hire anybody. The custom workflow agent page shows the same $5,000 plus $5,000 setup structure applied to a workflow that isn't a receptionist or a scheduler, with the four steps we run: discovery, build, guardrails, and launch and tune.

Whether you're interviewing a freelancer, an agency or a future employee, the same eight questions separate people who have shipped agents from people who have built demos. Listen for specifics: named tools, real failures, numbers they measured.

1. 1.Walk me through one agent you put into production. What was it allowed to do on its own, and what was it never allowed to do?
2. 2.What broke first after launch, and how did you find out?
3. 3.How did you test it before launch? Show me a test case you wrote from a real failure.
4. 4.How do you handle prompt injection? (A good answer is about limiting what the agent can reach and requiring confirmation for anything irreversible. A bad answer says it's solved.)
5. 5.Which model does it run on, and what happens when that model is deprecated?
6. 6.How do you monitor it now? What would you look at on a Monday morning?
7. 7.Who owns the code, the prompts, the evaluation data and the accounts at the end?
8. 8.If you left tomorrow, what would the next developer need to keep it running?

The prompt injection question does the most work. The UK's National Cyber Security Centre wrote in December 2025 that there's a good chance prompt injection will never be properly mitigated the way SQL injection was, because language models don't separate instructions from data. It's also first on the OWASP LLM Top 10 for 2026, as LLM01, with Excessive Agency at LLM03 and Improper Output Handling at LLM10. A candidate who frames security as reducing the blast radius rather than solving the problem is telling you they understand this.

The deprecation question is the sleeper. Anthropic's deprecation policy promises at least 60 days' notice for publicly released models; Claude Sonnet 4 and Opus 4, for example, were notified on April 14, 2026 and retired on June 15. OpenAI's deprecations page notes that preview models may get as little as about two weeks. An agent is not a build-once asset. Someone has to own the upgrade, and a candidate who hasn't thought about that has probably never maintained one.

A practical tip: ask for a paid trial task rather than a take-home test. Something small and real, like adding one tool with a confirmation step to a sandbox agent, paid at their rate. You learn more from four paid hours than from four unpaid interviews.

A bad hire often announces itself early, in the proposal or the first call, if you know what to listen for. We cover the full checklist in ten red flags when hiring an AI agent developer; these are the ones that matter most for choosing between the three models.

• Guaranteed outcomes: A promised accuracy rate, a guaranteed cost saving or a fixed percentage of tickets resolved. Nobody can guarantee what a model will do on your data before testing.
• Security described as solved: Any claim that prompt injection is fixed or that the agent 'can't be tricked'.
• No written IP assignment: Reluctance to sign an assignment of code, prompts and data, or a contract that only says 'work made for hire' for software.
• Accounts in their name: The repository, model keys or phone numbers set up under the developer's own account with no plan to transfer them.
• No testing or monitoring in the quote: A build price with nothing for evaluation, logging or post-launch fixes.
• No answer on deprecation: No plan for what happens when the underlying model is retired.
• Borrowed statistics: A pitch built on industry failure rates or ROI figures that can't be traced to a primary source.
• Faceless team: An agency that won't name who will write the code, or a freelancer who subcontracts without telling you.

These aren't hypothetical worries. The FTC finalised an order against DoNotPay in early 2025 over claims that its AI could stand in for a lawyer; the order required $193,000 in monetary relief and notice to subscribers from 2021 to 2023, per the FTC's announcement. In March 2026 the FTC announced a proposed settlement with Air AI, whose complaint included the claim that its AI could replace human sales reps. That order was filed but not shown as entered when I checked, and the $18 million judgment is largely suspended with $50,000 to be paid, so it is not an $18 million fine, whatever you may read elsewhere.

Here's what I chased for this piece and couldn't pin down, so you know where the numbers are soft.

• No official AI agent developer wage: BLS doesn't track the role. The software developer and research scientist figures are the nearest proxies, not the thing itself.
• The loaded-cost figure is an estimate: The 30.0% benefit share is an all-private-industry average from ECEC, not developer specific, and excludes recruiting, equipment, overhead and equity.
• Levels.fyi and Upwork were read from snippets: Both pages blocked or limited our fetcher. The figures are hedged and attributed; both change often.
• Clutch's sample skews offshore: Its averages describe firms listed on Clutch, weighted toward lower-cost regions. They're not a guide to senior US rates.
• Time to hire is partial: Ashby's verified figure covers screen to final interview only. Longer end-to-end figures I saw weren't confirmed on the source page.
• Legal points are not exhaustive: I didn't check California's exemptions in sections 2776 to 2784, the IRS test, or any state other than California. None of this is legal advice.
• Our own figures are ours: Frenchy Digital's rates and bands are what we charge, stated as such. They're not an industry benchmark.

None of this changes the direction of the argument. The multipliers are solid enough to decide with; the exact dollars are soft enough that you should re-check them against the offers and quotes in front of you.

You can get from this article to a hiring decision in about a week.Here's the order I'd do it in.

1. 1.Write one page describing the agent: what job it does, which systems it reads, which it writes to, and what it must never do. Then score it on Coase's three questions (specific, recurring, hard to specify). That score picks your row in the decision table.
2. 2.Draft the ownership terms before you talk to anyone: a signed IP assignment covering code, prompts and evaluation data, and every account opened in your company's name. Send it with your first message to any candidate and watch who flinches.
3. 3.Run the eight interview questions with two or three candidates from the model you picked, and pay the best one for a four-hour trial task. Decide on what they built, not on what they said.

Then hire, and get to work.