Comparison
Agency, freelancer, in-house team or agent-assisted senior team: how should you get software built?
By Rare Agentics engineering teamLast updated First published 10 minute read
Hire in-house when software is the core of the business for years to come and you can recruit and manage engineers well. Use a freelancer for a well-defined piece of work that one person can own and someone else can review, and an agency when you need a large team for a defined project and can live with its pace and price. An agent-assisted senior team, where senior engineers lead and AI agents do the volume of the work, suits founders and growing businesses that need production software in weeks at a fixed price, with the code in their own accounts.
What are the real options for getting software built?
Most founders and growing businesses end up choosing between four routes, sometimes without noticing they made a choice.
An in-house team. You hire engineers as employees. They work only on your product, and the knowledge stays in the building, for as long as they do.
A freelancer. You contract one independent developer, usually by the day or by the project. You get one person's skills and attention, and nothing else comes with them.
An agency. You contract a firm that supplies a team, usually with a project manager, designers and several developers, and bills by the day, by the sprint or by the project.
An agent-assisted senior team. A small group of senior engineers plan the work, set the rules and check every result, while AI agents do the volume of the building and testing in parallel. This is how we work, so read this section with that in mind. We have tried to be fair to the other three, because for some businesses they are the better answer.
There is a fifth route that deserves a mention: building it yourself with AI tools such as Lovable, Bolt, Cursor, Replit or v0. That is a fine way to get a prototype in front of users. It is a poor way to run customer data or payments without a review, and we cover that separately in how to make an AI-built app safe before launch.
How do the four compare side by side?
| In-house team | Freelancer | Agency | Agent-assisted senior team | |
|---|---|---|---|---|
| Time to start | Months, once you count recruiting | Days to weeks, depending on who is free | Weeks, after contracting and onboarding | Days to a week for a plan and a price |
| Cost shape | Salaries plus employer's National Insurance, pension, recruitment fees and equipment, every month, whether or not there is work | Day rate or project fee for one person | Day rates or project fees, scaled by team size | Fixed price per build or phase, agreed in writing |
| Who does the work | Your employees | One person, who also reviews their own work | A team chosen by the agency, often with juniors doing the volume | Senior engineers leading, agents doing the volume, people checking every result |
| Ownership of code and data | Yours by default under UK law, if the accounts are in the company's name | Theirs unless the contract assigns it, and often in their accounts | Theirs unless the contract assigns it, and often in their accounts until handover | Should be in your accounts from the first commit |
| Continuity | Strong while people stay, fragile when a key person leaves | Ends when that person is ill, busy or moves on | Ends with the contract unless you keep paying | Depends on documentation and ownership, so insist on both |
| Best for | Software that is the business, long term | A bounded piece of work with a clear owner on your side | Large, well-defined projects with a big budget | First products, new features, internal platforms and agents, delivered in weeks |
| Main risk | Hiring the wrong people, or too early | A single point of failure, with nobody checking the work | Slow delivery, rising cost and dependence after handover | Choosing a supplier who lets agents act without controls |
No row in that table is a verdict on its own. The right answer depends on how long you need the software built and run, how certain the scope is, and how much management time you have.
When is hiring in-house the right answer?
Hire when the software is the product, the roadmap is years long, and you, or someone you trust, can recruit and lead engineers.
An in-house team builds context that no supplier can match: why a decision was made three years ago, which customer complained about what, which shortcuts were taken and why. That context is worth paying for once you have a product that is working and growing.
The traps are timing and seniority. Founders often hire before they know what they are building, and end up with an expensive team waiting on decisions. Or they hire one junior developer because it is affordable, and ask them to make architecture decisions that a senior engineer would get right the first time. Neither is a failure of the people. It is a failure of sequencing.
Ask yourself honestly:
- Do I know what the first version needs to do, well enough to write it down?
- Who will review this person's code and decisions?
- What happens to the product if they leave in month four?
- Can I afford the team in a month where there is no new work for it?
If those questions are uncomfortable, it is often better to get the first version built and live, then hire people to run and grow something that exists.
When is a freelancer the right answer, and where does it go wrong?
A good freelancer is often the fastest and cheapest way to get a defined piece of work done. There is no account manager, no project overhead and no team to coordinate. You talk to the person writing the code.
That makes a freelancer a strong choice when the work is bounded and the risk is contained: a marketing site, an integration between two tools you already use, a feature on a codebase someone else maintains, or a prototype you expect to throw away. It also works well when you already have a technical lead who can set the direction and review what comes back.
The problems start when one person is asked to carry a whole product.
A single point of failure. Holidays, illness, a better-paid contract or a full diary all stop the work. Nobody else knows the system well enough to pick it up.
Nobody checks the work. A freelancer reviews their own code, sets their own architecture and decides their own security. Even an excellent engineer misses things that a second pair of eyes would catch, and the gaps usually show up as access rules, keys in the wrong place and missing tests.
Accounts in the wrong name. It is common for a freelancer to set up the repository, the hosting and the database in their own accounts because it is quicker. That is fine until you part company. Insist that everything is created in your accounts from the first day, with the freelancer invited in.
Employment status. If you are a medium or large business, the off-payroll working rules (IR35) make you responsible for deciding whether a contractor working through their own company is in effect an employee for tax purposes.
Availability after launch. A freelancer between contracts can respond in minutes. One in the middle of another client's launch may not respond for a week. If the software matters to your customers, agree response times in writing.
None of this is a reason to avoid freelancers. It is a reason to keep the work bounded, keep the accounts yours and have someone independent review anything that holds customer data or takes payments.
When does an agency make sense, and where does it go wrong?
A good agency brings a whole team at once: design, front end, back end, testing and project management. For a large project with a clear brief, a fixed launch date and a budget to match, that breadth is useful.
The problems tend to be structural rather than personal.
Pace. A large team needs coordination. Meetings, handoffs and status reports take time that a smaller team spends building.
Who does the work. The senior people you meet in the pitch are not always the people writing the code. Ask to meet the team that will actually build it.
Cost that grows. Day-rate billing rewards more days. That is not dishonesty, it is the incentive, and it means overruns are usually yours to pay for.
Dependence after handover. If the code lives in the agency's repositories and the product runs in their hosting accounts, the handover is a negotiation. Some agencies are excellent about this. Check before you sign, not after.
None of these are reasons to avoid agencies. They are reasons to ask sharper questions, which we list below.
What is an agent-assisted senior team, and what are its limits?
The idea is simple. AI agents are now good at producing large amounts of code, tests and documentation quickly. They are not good at deciding what to build, judging trade-offs or standing behind a release. So a small senior team does those parts, and agents do the volume.
In practice, with us, that looks like six steps. You describe the outcome in plain language. Agents draft the plan, and we check it and set the price. You approve the plan and the price before the build starts. Agents build in parallel, each in its own separate workspace. Agents test and review, and we read every result. A named engineer ships it, and agents have no access to production.
The benefits are speed and cost shape: senior judgement on every decision without paying for a large team. A single feature lands in 1 to 2 weeks. A first product typically takes 1 to 8 weeks, and larger platforms are delivered in phases of 6 to 8 weeks, each priced before it starts.
The limits are real, and you should hear them from us rather than discover them.
- It needs a clear owner on your side. Fast building exposes slow decisions. If nobody can approve the plan, nothing moves.
- It is not a substitute for a long-term team on a product that will need daily engineering for years. It can build the first version and hand over cleanly, or run alongside the people you hire.
- The controls matter more than the speed. An agent-assisted supplier without strict controls is worse than a slow agency. Agents should never be able to merge, deploy or touch production, and a person should approve every release. Ask how that is enforced, and expect the answer to be access controls rather than instructions.
- A small team has limited capacity. Ask how many builds run at once, and who covers if the lead engineer is unavailable.
What should you ask whichever option you choose?
These questions work for a candidate engineer, a freelancer, an agency or a partner like us. We go further in what to ask a software development company before you hire one.
- Where will the code and data live from day one? The answer should be your repositories and your cloud accounts.
- Who, by name, approves each release to production?
- Is the price fixed, and what happens when the scope changes? Any change should be re-scoped and re-priced in writing before it is built.
- What do I get besides the software? Tests, documentation and a handover should be in the price.
- What happens after launch? Ask about a warranty, and about response times if something breaks, as in a Run and improve plan.
- If we stop working together, what do I need to keep running it?
- For anyone using AI agents: what can the agents reach, and how is every agent action recorded?
The sixth question is the one most buyers forget, and the one that tells you most. A supplier who is confident in their work has nothing to gain from making you dependent. We go into this further in how to own your code with a software partner.
Can you combine the options?
Often the best route is a sequence rather than a single choice.
A common pattern: a partner builds the first version and takes it to production, you hire your first engineer once there is a live product to work on, and the partner hands over or stays on for the specialist work. That only works if the code was in your accounts from the start, with tests and documentation good enough for a new person to pick up. Otherwise the handover becomes a rebuild.
Another: a freelancer or a small in-house team runs the core product, and a partner builds a separate piece alongside it, such as an internal operating platform or a custom agent, without pulling the team off the roadmap.
For early-stage companies short on cash, there is also a middle path. Our founder partnership is a reduced fee plus a small equity stake, with the same controls, fixed pricing and code ownership as any build. It is not for every founder, and we take on a small number, but it can make the difference between building now and waiting.
How Rare Agentics can help
If you need a first product, a new feature or an internal platform built properly and quickly, start with our bespoke software builds: a fixed price before work starts, working software every week and code in your own accounts. If you want to judge us on something small first, a proof sprint is from £3,000 and takes 1 to 2 weeks. Tell us what you are trying to build and you will get a first view within two working days.