Short answer: In most countries, the agency that writes your code owns the copyright until a signed contract says otherwise. Paying the invoices gets you the right to use the software. It doesn’t automatically give you ownership, the freedom to change it, or any way to stop the agency from reusing it elsewhere.
Maya paid an agency about $90,000 to build her app. (She’s a composite, but her story is painfully common.) Eight months later it launched, users showed up, and an investor asked a boring question: “Can you send over the IP assignment for the code?”
Maya dug out the contract. Scope, timeline, payment schedule, a confidentiality clause. Not one sentence about who owns the code.
“Then technically,” the investor’s lawyer said, “your agency does.”
If that made your stomach drop, good. This guide exists so it drops now, when the fix costs one email, instead of during due diligence, when it can cost a funding round. We’ll walk through what the law actually says in the US, UK, EU and Saudi Arabia, the hidden traps that catch even careful founders, and the contract language worth asking for.
The quick version
- The default flips what you’d expect. Whoever creates code owns it first. You get ownership only through a signed, written transfer.
- Payment usually buys a license, not the deed. Courts often find an “implied license” to use what you paid for. It’s thin, non-exclusive and uncertain.
- Rules vary by country, but the cure is the same everywhere: put ownership in writing before work starts.
- Six traps catch people who think they’re covered: the agency’s own reusable code, open-source licenses, AI-written code, payment-conditioned handovers, a broken subcontractor chain, and freelancer quirks.
- A good contract has a present-tense assignment, a clear carve-out for the agency’s tools, a handover plan and a short list of warranties.
Why the agency owns your code by default
Copyright is automatic. The moment someone writes original code, they own it. That’s the starting point in the US, the UK and most of the world, and it doesn’t care who asked for the code or who paid for it.
There’s one big exception, called work made for hire. In the US, when an employee writes code as part of their job, the employer owns it from day one. That’s why code written by your in-house developers belongs to your company without extra paperwork.
An agency isn’t your employee. In Community for Creative Non-Violence v. Reid (1989), the Supreme Court said you decide whether someone is an employee for this purpose using ordinary agency-law factors, not just by asking who steered the result. The hiring group in that case had directed a sculptor’s design closely, yet the Court still treated him as an independent contractor, so the statue was not a work made for hire (read the opinion). An outside software agency, with its own staff, tools, schedule and other clients, is about as textbook an independent contractor as you’ll find.
Contractors can technically still be work-for-hire if there’s a signed agreement and the work falls into one of nine statutory categories. Custom software rarely fits any of them, which is why legal scholars have long called this rule an awkward fit for the software industry (Michigan Law Review).
So ownership has to move by assignment. US law requires that kind of transfer to be in writing and signed by the owner. No writing, no transfer.
There’s also an invisible chain behind that. The developer who typed your code is usually the agency’s employee, so the agency owns it first. For you to own it, the agency has to pass it along. Every link (developer to agency, agency to you, plus any freelancer or offshore team in between) needs paper. One missing link and the chain breaks.
“But I paid for it!” What payment really buys you
In Effects Associates v. Cohen (9th Cir. 1990), a low-budget filmmaker commissioned special-effects footage for a horror movie, paid less than the agreed price, and used the footage without any written license or assignment. The effects company sued for infringement. The court agreed the company still owned the copyright, since nothing had been signed over. But it also held the filmmaker had an implied non-exclusive license to use the footage, because it was made at his request and handed over for exactly that use (the decision).
Read that in both directions. The good news: if you commissioned and paid for software, you’re unlikely to be shut out of your own product. The bad news: an implied license is a flimsy thing.
- It’s non-exclusive. The agency may be free to reuse or resell the same code, including to your competitor.
- Its scope is fuzzy. Can you hand the code to a new developer? Modify it? Sell the company? A judge decides afterward.
- It proves nothing in a data room. No investor can underwrite “probably licensed.”
UK courts have landed in different places depending on the facts. In Griggs v Evans (2005), the owners of the Dr. Martens brand commissioned a logo without discussing copyright, and the freelance designer later assigned his rights to a rival overseas. The Court of Appeal ultimately treated Griggs as the beneficial owner, but only after litigation, reasoning that the logo would be useless to Griggs if competitors could use it (Reed Smith summary). In Clearsprings v Businesslink (2005), the court refused to imply an assignment of commissioned software, partly because the developer had built on its own existing code and needed to keep reusing it (Osborne Clarke). And in Sprint Electric v Potamianos (2019), the High Court found an implied assignment based on the client’s equitable ownership of the software (IPKat).
Three cases, three different outcomes, years of legal fees. A judge might rescue you. That’s not a plan.
Ownership around the world: same problem, different wrinkles
- United States. Contractors own what they write unless there’s a signed assignment or, rarely, a valid work-for-hire agreement covering one of nine categories.
- United Kingdom. Same starting point: the developer is the first owner. Courts sometimes recognize the client as the equitable owner when the contract is silent, but not reliably. Legal title still needs a signed written assignment.
- EU and Germany. The EU software directive gives employers the economic rights in programs their employees create (Article 2(3)). It says nothing special about outside contractors. In Germany, copyright itself can’t be sold, so clients receive exclusive “rights of use,” and when the contract is vague, courts read the grant according to the contract’s purpose (Legal 500 guide).
- Italy. The pendulum swings toward clients. In 2025, courts in Venice and Brescia sided with companies demanding source code from the developers they’d hired. Still, nobody wants to win that fight in court when a contract could have prevented it.
- Saudi Arabia. A new Copyright Law issued in early 2026 adds a statutory work-for-hire rule for employees, but for work created for another party, the economic rights stay with the author unless the contract says otherwise (Baker McKenzie). Moral rights are described as perpetual and non-waivable (Mondaq). Check current implementation details with a local lawyer.
The pattern is hard to miss. Where the default isn’t “the creator owns it,” you’re relying on a court’s sympathy. Where it is, you’re relying on your signature. Either way, the written agreement does the heavy lifting.
Six traps hiding behind “the agency assigns all rights”
Getting a clause that says all rights belong to you is step one. These are the places where that clause quietly falls short.
Trap 1: The agency’s toolbox
Agencies rarely write everything from scratch. They bring starter kits, internal frameworks, component libraries and deployment scripts that they’ve refined over dozens of projects. They’re not going to give those away to every client, and they shouldn’t have to.
That tension was at the heart of Clearsprings. According to Osborne Clarke’s write-up, giving the client the copyright would have stopped the developer reusing its own programs for other customers (source). The fix is a clean split in the contract: Deliverables (what’s built for you, which you own) and Background IP (what the agency owned before or builds independently, which it keeps). Then add a perpetual, irrevocable, transferable license to any Background IP that’s baked into your product, or you’ll own a car whose engine you’re not allowed to run.
Trap 2: Open source and third-party code inside your product
Almost every modern app is mostly other people’s code. Black Duck’s 2026 audit of 947 commercial codebases found open source in 98% of them, and 68% had license conflicts, up from 56% the year before (press release). Roughly 17% of open-source components arrived outside normal package managers, through copy-pasted snippets, vendor drops or AI generation, which makes them harder for scanners to see (Black Duck).
Why you should care: some licenses (the GPL family, for instance) can attach obligations that reach your own code, such as sharing source in certain situations. An agency can hand you a perfect assignment of its code and still leave you with a license problem.
Ask for a software bill of materials and a license report at handover. Also ask which commercial assets (UI kits, fonts, stock media, paid APIs) are licensed to the agency rather than to you, and whether those licenses can move to your company.
Trap 3: AI-written code
Developers have embraced AI tools. Stack Overflow’s 2026 survey found only about 17% of respondents don’t use any, while just 24% said their employer had published approved tools or formal guidance (IT Brief summary). Odds are good that your agency’s developers use AI assistants, whether or not your contract mentions it. That creates two separate problems.
Ownership. US law requires human authorship. On March 2, 2026, the Supreme Court declined to hear Thaler v. Perlmutter, leaving intact a ruling that AI alone can’t be an author (Finnegan). The Copyright Office’s 2025 report adds that prompts alone don’t make you the author of a model’s output, though human-written code, and a person’s creative selection, arrangement or modification of AI output, can still be protected (IPWatchdog). The UK government’s March 2026 report leans the same way, proposing to scrap special protection for wholly computer-generated works while keeping protection for AI-assisted ones (Reed Smith).
Here’s why that matters to you: an agency can only assign what it owns. If large chunks of your product are essentially unedited AI output, the assignment may be worth less than it looks.
Contamination. Black Duck’s report ties part of the license-conflict spike to what it calls “license laundering,” where assistants produce snippets derived from copyleft code without the original license attached.
Questions worth asking: Which AI tools do you use? Does our code or data leave your environment? Who reviews generated code before it ships? Will you disclose significant AI-generated sections and warrant that you haven’t knowingly included infringing material?
Trap 4: Ownership on paper, hostage in practice
Plenty of fair contracts say ownership transfers once you’ve paid in full. That’s reasonable. Nobody wants to give away the goods unpaid. But check three things: what counts as “paid” if you dispute an invoice, whether you hold a license in the meantime, and what happens if you part ways mid-project.
The sharp edge shows up in a UK dispute covered by law firm Farrer. After the relationship broke down, the client demanded the unfinished source code. The contract tied handover to payment of outstanding invoices, the client hadn’t met that condition, and its application failed (Farrer). In Venice in 2025, a start-up whose developer refused to deliver the code for its marketplace app had to seek an urgent court order, with its business stuck in the meantime.
Even a perfect assignment can’t help if the developer is sitting on the keys. From day one, make sure these live in accounts you control: the code repository organization, cloud hosting, domain and DNS, app-store developer accounts, CI/CD pipelines, analytics, and a password manager holding the secrets. The agency gets invited in. You never get invited out.
Trap 5: Two small words and a missing signature
“Agrees to assign” is a promise about the future. “Hereby assigns” transfers rights now. The difference became famous in Stanford v. Roche, a patent case in which a university lost out because its paperwork only promised to assign while a company’s paperwork actually did (Perkins Coie). Lawyers carry the same lesson into software contracts: for code that doesn’t exist yet, insist on present-tense wording.
Then ask who actually writes the code. If your agency leans on freelancers or an offshore partner, you’re relying on the agency’s own assignments from them. Require the agency to warrant that everyone who contributes has signed over their rights, and ask for a subcontractor list.
Trap 6: Freelancer quirks
Hiring an individual instead of an agency adds a few wrinkles.
- US termination rights. An individual author who assigns copyright can generally terminate that grant after 35 years, regardless of what the contract says. True works made for hire are exempt (Columbia’s Kernochan Center). It’s a long-dated issue, but it explains why lawyers structure these deals carefully.
- California. Signing a “work made for hire” clause with an individual contractor can make you their employer for workers’ compensation and unemployment insurance purposes (Foley). Many lawyers use an assignment instead.
- Moral rights. The right to be credited or to object to distortion can’t always be waived. The contract should address consent and attribution rather than pretend they vanish.
What investors and buyers will check
Sooner or later someone will ask for your chain of title: the documented path from each person who wrote the code to the company claiming to own it. UK law firm Travers Smith puts it plainly in its software M&A briefing: unless a consultancy agreement says otherwise, outside consultants own the IP they create, so a seller must prove an effective assignment (Travers Smith). Technical due-diligence checklists tell buyers to confirm signed assignments for every contractor who ever touched the code, even the agency from years ago (BD Emerson). A 2026 discussion from Williams Mullen’s IP team lists missing contractor assignments among the gaps that can affect valuation, indemnities and closing conditions (Williams Mullen).
A missing signature rarely kills a deal outright. It hands the other side leverage. And the agency that built your first version may have shut down, merged, or lost the one person who remembers you. Getting the paper now is far easier than hunting for that person later.
The contract checklist: 10 things to get in writing
- A present-tense assignment of all rights in the Deliverables, worldwide, perpetual, in all media.
- A precise definition of Deliverables: source code, build scripts, infrastructure-as-code, designs, data models, tests and documentation, not just the compiled app.
- A Background IP carve-out plus a perpetual, irrevocable, transferable license to anything of the agency’s that’s embedded in your product.
- Flow-down from people to agency: a warranty that every employee, freelancer and subcontractor has assigned their rights, and a list of who they are.
- Clear payment mechanics: assignment effective on creation, or on payment of undisputed fees, with an immediate interim license so a billing dispute can’t freeze your product.
- Open-source and third-party disclosure: a bill of materials, license report, and no copyleft components without your approval.
- AI-use terms: which tools are allowed, what data they may see, disclosure of significant generated sections, and a non-infringement warranty.
- Handover duties: repositories, credentials, accounts, documentation and a handover window that applies even in a dispute. For hosted or long-running systems, consider source-code escrow.
- Further assurances: the agency must sign whatever extra papers you need later, even after the contract ends, plus consent or waiver of moral rights where the local law allows it.
- Protection clauses: confidentiality, no reuse of your bespoke code or confidential information, limited portfolio rights, and an indemnity for IP infringement claims.
Here’s the spirit of the key clause in plain English (have a lawyer adapt it to your country and deal):
The Agency hereby assigns to the Client all rights in the Deliverables, effective as each is created and, where payment is a condition, on payment of the undisputed fees. The Agency confirms every person who contributes has assigned their rights to it, and will sign any further document the Client reasonably needs to confirm this transfer.
Note that in countries like Germany, where copyright itself can’t be transferred, the equivalent is an exclusive, perpetual, transferable grant of rights of use that’s broad enough to cover everything you plan to do.
Already live without a clean contract? Five steps
- Find your contract and read the IP clause. If it’s silent, or only says the agency “grants a license,” you have a gap.
- Ask for a confirmatory assignment. A short signed addendum in which the agency assigns all rights in work already delivered, backdated to creation. Agencies that want a long relationship with you usually sign when asked politely.
- Secure the keys. Move repositories, cloud accounts, domains and app-store listings under your company’s control.
- Scan for open source. A software composition scan shows what’s inside and under which licenses.
- Keep a tidy file. Contracts, assignments, subcontractor lists and the scan report in one folder, ready for the next diligence request. One Saudi law firm’s advice for completed projects is similar: fix the paper with a signed addendum and keep an official record where your local system supports one (Origami).
The fair middle: what agencies reasonably want
It’s not a villain-and-victim story. Good agencies reuse generic components because that’s how they deliver faster and cheaper. They also want to show their work in a portfolio and keep their general know-how.
A healthy deal usually looks like this: you own the bespoke code and designs built for you, the agency keeps its pre-existing tools, and you receive a perpetual license to whatever of theirs sits inside your product. That’s not a red flag. These are:
- A contract that only grants you “a license to use” the software when you’re paying for a custom build.
- Refusal to name subcontractors or confirm they’ve signed.
- No repository access until the final payment.
- Vague language like “ownership to be agreed.”
- Hosting, domains and accounts registered in the agency’s name.
If you want a license instead, for a white-label platform the agency sells to many customers, for example, that can be fine. Just negotiate exclusivity, price protection, escrow and exit rights as seriously as you would for ownership.
Before you sign (or before your next funding round)
Here’s the whole article in three moves. Check that your contract contains a present-tense assignment. Make sure the agency’s tools and everyone else’s code are accounted for. And hold the keys to your own repositories, accounts and domains.
That’s maybe an hour of attention now, against months of friction later. Maya, by the way, got her agency to sign a confirmatory assignment in a week. It helped that she asked before the investor’s deadline, and before the relationship soured.
Nothing here replaces advice from a lawyer in your jurisdiction, but you now know which questions to put in front of one.
Sources and further reading
