Who Owns the IP When You Hire a Development Agency? (Get This in Writing)

You hire a development agency, sign the proposal, and pay every invoice on time. In your mind, that settles who owns the IP: you do.

It rarely works that way by default. Who owns the IP when you hire a development agency comes down to one thing: what your contract says in writing, not who paid for the work.

Under copyright law in most countries, whoever writes the code owns it the moment it exists. That default survives even a fully paid invoice.

A signed clause is the only thing that changes it, a gap our guide to software development contract red flags touches in one section. This is the full breakdown.

Quick answer: By default, your development agency, or the developer who wrote the code, owns the copyright to everything it builds for you, even after full payment, unless a signed clause assigns those rights to you.

A safe contract names the ownership model as full assignment, not a license, ties the transfer to each payment milestone, discloses any pre-existing frameworks the agency reused, and confirms every subcontractor signed away their own rights too.

Anything short of that leaves you with permission to use the software, not legal ownership of it.

Key takeaways

• Ownership transfers through a signed written assignment, never through payment alone. That’s a legal execution requirement, not just good practice.
• Employee, contractor, and agency defaults are all different. Courts use a specific multi-factor test, not gut feeling, to sort a relationship into 1 of those 3 buckets.
• “Work made for hire” rarely applies to custom software by default. It covers only 9 narrow categories, and general software isn’t 1 of them.
• Your agency might not legally own what it’s selling you, if the freelancers or subcontractors it used never signed proper assignments of their own. Almost no buyer checks this.
• AI-assisted code adds a genuinely new wrinkle in 2026. Code with no meaningful human input isn’t copyrightable to anyone, per the U.S. Copyright Office’s 2025 findings.

What counts as IP when you hire a development agency

“IP” in a software engagement usually bundles 4 different things together.

IP type	Protected by	Common mistake
Source code, UI copy, documentation	Copyright	Assumed transferred automatically on payment
A novel technical process or algorithm	Patent	Never mentioned in the contract at all
App name, logo, product branding	Trademark	Left with the design agency, not registered by the client
Proprietary data models, undisclosed methods	Trade secret	Protected only by an NDA, not by copyright

Most disputes involve the first row, copyright, which is why the rest of this guide focuses there. It’s also what decides your website development team’s long-term flexibility. A dedicated section further down covers why the other 3 rows still matter.

Who owns the IP by default, and the Supreme Court case that decides it

1. The default rule under copyright law

Copyright attaches to a work the instant it’s written. It belongs to whoever wrote it, not whoever paid for it.

Per the U.S. Copyright Office’s circular on works made for hire, only 2 things override that default:

• The creator is a true employee, working within their job
• A signed, written clause assigns the copyright to someone else

A developer who builds your whole product, cashes the final check, and hands over a working app still owns that code without 1 of those 2 things in writing. This holds whether you hired a solo freelancer or a full agency team.

2. The Reid test: how courts actually decide who counts as an employee

Most explanations stop at “employees are different.” Courts use a real, named test instead.

In Community for Creative Non-Violence v. Reid, the Supreme Court ruled a nonprofit didn’t own a statue’s copyright, despite paying for it, because the sculptor was legally an independent contractor. The court weighed:

• Who controlled how, when, and where the work got done
• Whether specialized skill was required
• Who supplied the tools and workspace
• How long the relationship lasted, and whether more work could be assigned
• How the worker was paid and taxed, and whether benefits applied

No single factor decides it alone. That’s why a long-term “dedicated” arrangement can sit legally closer to employment than a short freelance gig, even without payroll.

3. Employee vs. contractor vs. agency, side by side

Relationship	Default ownership	What changes it
Employee, on payroll, working within job duties	Employer owns the work automatically	Almost nothing; the 1 relationship copyright law hands you ownership for free
Independent contractor or freelancer	Contractor owns the work	A signed assignment or a valid work-for-hire clause
Agency, a company rather than an individual	The agency owns the work	A signed assignment naming your company as owner

A dedicated development team sits closer to the employee end of that table in day-to-day practice. The legal default still follows the contract, not the working style.

Work made for hire: the phrase most agency contracts get wrong, and the 2 things that actually fix it

1. Why “work for hire” language alone rarely works for software

Plenty of agency contracts include a line like “this is a work made for hire,” and stop there. That single phrase usually isn’t enough.

Under 17 U.S. Code § 101, it applies automatically in only 2 cases:

• Work by a true employee, made within their job
• Work fitting 1 of 9 narrow commissioned categories (translations, supplementary materials, and similar), backed by a signed agreement using that phrase

General custom software doesn’t fit those 9 categories on its own.

2. The written, signed assignment clause that’s the real backup

Because “work for hire” is unreliable here, the language that matters is a copyright assignment: the developer transfers all rights, title, and interest to your company.

A contract that actually protects you needs both:

• Work-for-hire language, as the first attempt
• A separate assignment clause, as the legal backup that holds even if the first one doesn’t qualify

This isn’t optional. Under 17 U.S. Code § 204(a), a transfer of copyright is invalid unless it’s in writing and signed. A handshake doesn’t count.

3. What happens with no signed agreement at all

Courts have repeatedly found that when someone creates a work at your request and hands it over expecting you to use it, an implied, non-exclusive license exists, a doctrine traced to Effects Associates, Inc. v. Cohen.

That implied license:

• Does let you keep using the software as intended
• Doesn’t let you modify, resell, or hand the code to a new developer without separate permission

That gap is exactly why a software project rescue so often starts with an ownership check before any new code gets written.

The three ownership models, and the subcontractor risk almost nobody checks

1. Full assignment, exclusive license, non-exclusive license, compared

Model	What you get	What the agency keeps
Full assignment	All rights transfer to you, on signing or on payment	Nothing, beyond a right to list the work in its portfolio, if agreed separately
Exclusive license	You’re the only one allowed to use the software	The underlying copyright, and leverage to negotiate a buyout later
Non-exclusive license	The right to use the software	The right to resell or reuse the same code for other clients, including a competitor of yours

Full assignment is the standard to expect for custom-built software your business runs on. A non-exclusive license is the weakest option on the table.

2. Why your agency might not legally own what it’s promising you

An agency rarely writes every line of code with its own full-time staff. Most real projects get touched by:

• Subcontracted freelancers
• Offshore development partners
• Short-term contract hires

Basic contract law follows an old rule: nobody can transfer rights they never legally held.

If any of them never signed an assignment to the agency, the agency has nothing valid to hand you, no matter what your own contract says. It’s exactly the kind of gap that becomes 1 of the common software development problems nobody notices until it’s expensive.

A clause worth asking for directly: the agency warrants that it holds, or will secure, a signed assignment from every individual who contributes code, and will provide those records on request. Very few buyers ask for this, and it’s one of the cheapest questions that carries real legal weight.

Background IP vs. foreground IP, and the proprietary core trap

1. What background IP is, and why agencies keep it

Almost no agency writes every line of your product from a blank file. Most bring:

• Reusable internal code libraries
• Boilerplate authentication systems
• Utility frameworks built across dozens of past projects

That pre-existing material is background IP. Reasonable agencies keep ownership of it while granting you a broad license to use it inside your product. Foreground IP, the code written specifically for you, is what should transfer under a full assignment.

2. The proprietary core trap: when your product can’t actually be separated from theirs

The riskier version shows up when an agency builds your app on its own closed, unreleased platform, instead of standard open frameworks.

Even with a full assignment on paper, you can end up owning code that literally can’t run, be modified, or be handed to a new team without the agency’s core underneath it.

This is functionally the same risk as choosing a locked no-code or low-code platform over custom development, even when the marketing calls it “custom.” Ask directly:

• Does this run on the agency’s proprietary internal platform, or a stack any developer could pick up?
• Could a new team take over without the agency’s continued involvement?

A properly scoped SaaS or custom software build should make that answer obvious before you sign, not after you try to switch vendors.

Third-party code, open source, and the fix almost nobody asks for

Custom software almost never means fully original code. Most projects lean on open-source libraries, paid components, and third-party APIs, and integrating those brings its own hidden costs beyond licensing fees.

The risk with open source specifically:

• Some licenses, particularly GPL-family licenses, require anything built on top of them to be released under the same open terms
• A dependency pulled in without checking its license can quietly limit what you’re allowed to do with your product later
• Nobody at your company may even know the dependency exists until a due-diligence review flags it

The fix used in more mature engineering shops: a software bill of materials, a full itemized list of every library, package, and version your product depends on.

Ask your agency for one as a deliverable. Require it to confirm each component’s license permits your intended commercial use.

When payment doesn’t transfer ownership

1. The “full and final payment” trap

Some contracts trigger the assignment clause only “upon receipt of full and final payment.” That sounds fine on paper. In practice, it means you own nothing, not even delivered parts, until every invoice clears.

Weak wording	Strong wording
“Assigned upon full and final payment”	“Assigned upon payment for each milestone”

If a dispute happens mid-project and you withhold a final payment over a legitimate quality issue, the weak version can leave you with no legal claim to work you’ve already paid for.

2. Milestone-based transfer instead

The stronger structure ties ownership to each milestone payment, not to 1 final release. As each phase gets paid, that phase’s code becomes yours.

This mirrors the milestone-based payment structure most well-run engagements already use for the money side. The IP side should follow the same schedule.

AI-generated code and the ownership gray zone nobody’s contract addresses yet

1. What’s copyrightable, and what isn’t

Most software contracts still don’t mention this. In its 2025 report on AI and copyrightability, the U.S. Copyright Office reaffirmed that copyright requires human authorship.

• Copyrightable: the parts a developer actually wrote, edited, or made deliberate creative choices about
• Not copyrightable to anyone: code accepted verbatim from an AI tool with no meaningful human input, not to the developer, the AI vendor, or you

Ownership of the copyrightable parts follows the same assignment rules covered above.

2. What to ask your agency about AI-assisted work

Ask directly:

• How much of the codebase came from AI-assisted tools like Copilot or Claude Code?
• How much of that was reviewed and meaningfully modified by a human, versus accepted as generated?

This matters most on projects leaning on AI services and integration, where human-authored and machine-generated code blur together by default.

A reputable agency keeps a simple provenance record as it goes. Where AI tools genuinely help, and where a human developer is still required, affects what part of your product you can legally claim as your own.

IP is bigger than copyright: patents, trademarks, and moral rights

1. Patents and trademarks need their own clause, not a shared one

A full copyright assignment doesn’t automatically transfer patent rights. If your agency’s engineers invent a genuinely novel technical process, an explicit invention-assignment clause is needed on top of the copyright language.

The same gap exists inside employment too. Several U.S. states restrict what an employer can automatically claim from an employee’s inventions, New York’s Labor Law § 203-f among them.

“The contract said work for hire” isn’t a complete answer for patents, even when it correctly covers the code.

Trademarks follow their own registration process too. A logo or name an agency designs as part of your brand identity doesn’t become a registered trademark just because you own the copyright to the artwork.

2. Moral rights, and why “full assignment” doesn’t always end the conversation

Outside the U.S., particularly in the UK and continental Europe, creators keep moral rights (the right to be credited, and to object to damaging changes) even after a full copyright assignment.

Region	How moral rights work
United States	Very limited outside visual art; a standard assignment usually resolves it
United Kingdom	Can be waived in writing; most agency contracts should include that waiver
Germany and continental Europe	Generally cannot be waived or transferred, only licensed around

This rarely surfaces in day-to-day SaaS or web work. It matters if your agency operates in the UK or EU and your product will ever be resold or white-labeled.

Why sloppy IP ownership becomes urgent the moment you raise money or sell the company

Nobody notices a missing assignment clause during a smooth build. It surfaces during due diligence, when an investor’s or acquirer’s legal team asks for a clean chain of title.

A real diligence review checks:

• Signed assignments from every past contractor and freelancer
• No orphaned contributions from developers who’ve since left
• A documented background IP schedule

A gap here doesn’t just slow the deal down. It can lower the valuation, or stop the transaction until every past developer is tracked down for a signature.

Fixing this before you hire costs a fraction of the legal fees it saves during a funding round under pressure, the same reason a pre-launch security review exists.

Who can show the work off afterward, and what happens if you switch agencies

1. Portfolio and case study rights

Full IP assignment usually still leaves 1 thing with the agency: the right to list your project in its portfolio and case studies, unless your contract restricts it.

Most businesses are fine with this, since a strong portfolio is part of why they picked that agency. If your product involves sensitive data or a competitive edge you’d rather keep quiet, say so in writing before the project starts.

2. Keeping your IP intact if you ever change development teams

A clean handoff to a new team needs:

• A repository under your own organization’s account
• Documented background IP
• Signed assignment records for every contributor

Without that paperwork, a switch to a new developer often starts with an access-and-ownership audit before any new code gets written, the same first step used when a solo developer disappears mid-project.

The OWNS framework: a 4-point IP check before you sign

1. The four checks

• O, Ownership model named. Full assignment, exclusive license, or non-exclusive license, stated by name, not implied.
• W, Work-for-hire language verified. Present as a backup to a real assignment clause, not standing alone.
• N, Nested background IP disclosed. Any reused frameworks, libraries, or proprietary platforms named, with a clear license to use them in your product.
• S, Source materials confirmed. Source code, design files, documentation, and credentials transfer with the code, and every subcontractor has signed their own assignment.

Run any agency contract through those 4 checks before you sign. Most gaps hide in exactly 1 of them, which is also the fastest way to spot the other contract red flags that tend to travel alongside a weak IP clause.

2. A sample IP assignment clause, in plain English

A clause that actually does its job usually reads close to this:

“Upon payment for each deliverable, [Agency] assigns to [Client] all right, title, and interest in and to the code, designs, and documentation created specifically for this project, excluding Agency’s pre-existing background IP as listed in Exhibit A, which is licensed to Client on a perpetual, worldwide, royalty-free basis for use within the delivered product. Agency warrants that all personnel and subcontractors who contributed to the Work have assigned their rights to Agency.”

This isn’t a substitute for legal review, especially on a project worth tens of thousands of dollars or more. It’s a fast way to tell whether an agency’s own template already covers the ground above.

FAQs

1. Does paying for a website mean I own the code?

Not automatically. Payment alone doesn’t transfer copyright; a written, signed assignment clause does. Without one, you likely have an implied license to use the site, not ownership of the underlying code.

2. Can my developer reuse code they built for me on another client’s project?

Only for background IP they disclosed and kept ownership of. Code assigned to you under a full-assignment clause shouldn’t legally reappear in a competitor’s product, though enforcing that is harder than preventing it with clear language upfront.

3. What happens to my IP if my agency shuts down or gets acquired?

Whatever you legally own stays yours regardless of what happens to the agency, provided the assignment was properly documented and signed. What you lose without proper paperwork is the practical ability to prove ownership, and why a project rescue team’s first question is always about documentation, not code quality.

4. Do I own code written by AI tools like Copilot or Claude Code?

Only the parts a human meaningfully shaped, reviewed, and modified. Code accepted verbatim from an AI tool with no real human creative input generally isn’t copyrightable to anyone under current U.S. Copyright Office guidance.

5. What’s the real difference between a license and full IP ownership?

A license lets you use the software under terms the owner sets. Ownership lets you modify, resell, relicense, or hand the code to a different developer without asking anyone’s permission first.

6. Is a verbal agreement enough to establish who owns the code?

No. Under 17 U.S. Code § 204(a), copyright ownership only transfers through a written, signed document. A verbal agreement might create an implied license to use the work, but it’s a weak substitute for a real assignment clause.

7. Do freelancers and agencies follow the same IP rules?

Yes, the underlying copyright rules are identical for both. The practical risk differs: an agency’s contract usually already covers this by default, while freelancer agreements are more likely to skip it entirely.

8. Should I ask for source code escrow on top of an IP assignment?

Assignment settles who legally owns the code. Escrow settles what happens if your agency disappears before handing over working access to it, and the 2 problems aren’t the same. Escrow mechanics are covered in more depth here if your business depends on the software running continuously.

Get your IP ownership in writing before you sign anything

Who owns the IP when you hire a development agency almost always traces back to 1 missing sentence, not bad faith on either side.

Running a proposed contract through the OWNS check above catches nearly all of them before they turn into an expensive surprise, a funding delay, or a rebuild.

GVM Technologies builds every engagement, custom web development, mobile app development, or an MVP build, on a full IP assignment by default.

Ownership is tied to each milestone payment instead of 1 lump handover at the end, with subcontractor assignments confirmed before your project starts.

Book a free contract and IP review with GVM Technologies before you sign anything with any development agency. No obligation, and you’ll know exactly what you’re getting into within 1 conversation.