Who Owns the Translation Memory? What Agencies, Freelancers, and Clients Should Settle in Writing

A client leaves. Three weeks later their new agency writes asking for "the TM files." The project manager forwards the email to the owner, the owner forwards it to a lawyer, and the lawyer opens the master services agreement and finds nothing about it at all. That is usually the first time anyone asks who owns translation memory, and by then the question has no clean answer left in it. The problem isn't legal difficulty. It's that nobody wants to raise it while everyone still likes each other.

Why who owns translation memory almost never gets written down

TM ownership sits in an awkward gap. It isn't the deliverable, so it doesn't appear in the statement of work. It isn't confidential information in the usual sense, so the NDA skips past it. It isn't software, so the licensing section ignores it. It just accumulates in the background of a relationship that is, at the time, going fine.

There's a commercial reason nobody raises it, too. For an agency, the TM is part of what makes an account sticky. Ask a client to sign a clause confirming they own the memory and you've told them in writing that they can take it elsewhere. Ask them to sign one confirming you own it and you've told them you're already planning for the day they try. Neither conversation feels good in month one, so it doesn't happen.

Freelancers skip it for a different reason. Most have no contract beyond a PO and an emailed rate. We've asked translators who have worked with the same agency for six years whether they're allowed to keep the memory they built, and the usual answer is a pause, then "I assume so?"

Then something shifts. The client consolidates vendors. The agency gets acquired. A translator wants to stop going through an agency and work with the end client directly. Whatever was unstated becomes the only thing anyone wants to discuss, and the discussion happens at the worst possible moment, with a deadline running.

This doesn't apply if you work exclusively inside a client's own TMS on their own TM. That setup answers the question by construction. Everybody else is exposed.

What a translation memory actually contains

Half the confusion here comes from treating the TM as one object. It isn't one object.

A TM is a database of aligned source and target segments plus metadata: who confirmed each segment, when, in which project, sometimes for which client. Three separable things are stacked inside it.

The source segments came from the client. That's their text, pulled out of their manuals, contracts and product pages. Nobody seriously disputes this part.

The target segments are translations. Under most copyright regimes a translation is a derivative work and its author holds rights in it unless those rights were assigned. In practice nearly every agency contract assigns them, and nearly every freelance PO assigns them too, usually in a single sentence nobody reads twice.

The third thing is the structure: the alignment, the segmentation decisions, the cleanup, the deduplication, the years of maintenance that stop a memory turning into a swamp. That part genuinely is the agency's work, and it's the part contracts almost never mention. A database of 200,000 maintained units is not the same asset as 200,000 raw units carrying three competing translations of the same sentence.

The split matters practically. When a client asks for "the TM," they usually mean the source and target pairs for their own content. When an agency hesitates, it's usually protecting the structure and the maintenance, or protecting a file that has other clients' text sitting in it.

That last case is the one we'd flag hardest. Mixed memories are common in small agencies: one TM for legal, one for technical, everything poured in by domain rather than by client. Handing that file to a departing client hands them somebody else's confidential text, which is a privacy problem before it's ever an ownership problem. It belongs in the same conversation as what you tell clients about data handling.

Three parties, three reasonable claims

Nobody in this argument is being unreasonable. That's what makes it hard to settle.

The client's position

They paid for it. The source text is theirs, the translations were produced under contract and invoiced, and the memory reduces what they'll spend next year. From where they sit, a refusal to hand it over looks like an asset being held hostage to keep the account. Corporate buyers now write TM ownership into RFPs as a matter of routine, and they're right to.

The agency's position

The memory only exists because somebody built it. Alignment, term cleanup, dedupe, judgement calls about what gets committed and what stays out. An agency that handed a clean maintained TM to a client after year one would be funding its own replacement. There's a quality argument underneath it as well: a memory released without its glossary and style guide will be used badly by whoever receives it, and the agency's name is still attached to the output when that goes wrong.

The freelancer's position

Legally the weakest, practically the most sympathetic. A translator running one personal memory across six clients has built the thing that makes them fast and consistent. Stripping a departing client's segments out of it is technically possible in most CAT tools, and almost nobody does it. There's real risk running the other way, though: a translator who keeps everything in one memory is carrying client A's confidential text into client B's project, whatever the PO says.

We've seen one arrangement that keeps all three sides calm, and it isn't a clever clause. A project TM per client, exported on request, with the agency keeping its own maintained master. Everyone gets the thing they actually needed. Nobody gets the argument.

What contracts usually say, and what they leave out

We're not lawyers and none of this is legal advice. Case law on TM ownership is thin in most jurisdictions, which is exactly why the contract language ends up doing so much of the work.

A typical MSA has a work-for-hire or assignment clause covering "all deliverables and work product." Client counsel will read that as covering the TM. Agency counsel will read the deliverable as the translated document and the TM as an internal production tool. Both readings live comfortably in the same sentence, which is another way of saying the clause decides nothing.

What's usually missing:

• whether the TM counts as a deliverable at all
• in what format and on what timeline it gets handed over
• whether the glossary and style guide travel with it
• what happens to it when the contract ends
• whether the agency may keep a copy afterwards
• whether this client's segments may sit in a shared multi-client memory

That last one is the sleeper. An agency can say "you own your TM" with a straight face while running a blended memory that quietly improves output for every other account. Nobody lied. Nobody agreed to anything either.

ISO 17100 pushes in a useful direction by requiring a documented agreement between the language service provider and the client about the service being delivered, but it won't resolve ownership for you. You still have to write the sentence yourself.

For freelancers the gap is wider. A PO reading "all rights in the translation transfer to the agency upon payment" transfers rights in the translation. It says nothing about the translator's own working memory. Most agencies wouldn't dream of demanding a freelancer's personal TM. A few do, usually by quietly adding "and all associated files" at renewal, and that line is worth reading before signing.

Clauses worth settling before the first project

Four sentences cover most of this. Not four pages.

One: name the TM. State whether the translation memory produced from this client's content is a deliverable, an internal tool, or something both sides may use. Any of the three works. Silence doesn't.

Two: set handover terms. Format (TMX is the sane default), timeline (fifteen business days from written request is generous and unambiguous), frequency (on request, quarterly, at termination). A client who knows they can get the memory whenever they ask generally stops asking.

Three: isolate the data. Say that this client's segments live in a client-specific memory and aren't committed to shared or multi-client memories without written consent. That protects the client commercially and protects you from a confidentiality claim two years later.

Four: say what survives termination. Whether the agency retains a copy, how long, and what for. "Retained twelve months for warranty and dispute resolution, then deleted" is a sentence both sides can sign without a negotiation.

For freelance work, one line on the PO does it: "Translator may retain a working translation memory of their own output for consistency purposes; client content will not be disclosed to third parties." Agencies who think it through usually accept, because the alternative is a translator who's slower and less consistent on the next job they send.

Timing matters more than wording. Raise it at contracting, when nobody has anything at stake. Raising it mid-dispute means negotiating with someone who has already decided you're the problem.

Access and portability beat the word "ownership"

Here's the part we'd argue for hardest. Most TM disputes aren't really about ownership. They're about access. The client doesn't want to own a database. They want to not be trapped.

So portability settles more of these arguments than legal drafting does. If a client can request a TMX export and have it in hand within two weeks, the ownership question mostly stops mattering to them. If they can't, no clause is going to reassure them.

Test it before you promise it. Export the memory from whatever platform you use, import it into a different tool, and look at what actually arrived. Metadata loss between systems is routine, segmentation rules differ between tools, and a memory that exported cleanly can land with broken tags or collapsed context. We've gone through the format mechanics in detail elsewhere; the short version is that TMX moves segments reliably and moves everything around them unreliably.

Second thing to test: whether the handover would be usable by the person receiving it. A TM without its glossary is roughly half an asset. If you're going to hand memories over, hand the terminology over with them, or expect the recipient to conclude your TM was low quality.

One note on AI-translated content, since it's in most workflows now. If raw machine or AI output gets committed to a client memory without a post-editing pass, you're building a database whose provenance nobody can reconstruct in two years. Flag those segments or keep them separate. Ownership of a polluted TM isn't worth arguing about.

If the awkward step in your setup is getting AI output out of a document and into a memory at all, the export format is the whole problem. SnapIntel takes DOCX, XLSX and PPTX files, runs domain analysis and glossary and prompt approval before translation starts, then returns the translated file along with a neutral source/target XLSX export and a QA report. That XLSX is a plain bilingual table, so the content stays portable into whichever tool the memory happens to live in rather than being locked to one platform. You can see how the workflow fits together at snapintel.io.

What to do this week

Pull your three largest client contracts and search them for "translation memory," "TM," "work product" and "deliverable." Most people find nothing. That's the finding.

Then, in this order:

1. Check whether any of your memories mix clients. If they do, split them. This is the one item on the list with an actual downside if you leave it alone.
2. Run a single export-and-reimport test, so you know what your handover produces before a client asks for one.
3. Add the four sentences at your next contract renewal rather than reopening live agreements. Renewals are a cheap moment to fix this.

Freelancers: one line on the next PO, and keep per-client memories even though one big memory is more convenient to work with. The convenience is what costs you the argument later.

Nobody wins a TM dispute. The agency that refuses the export loses the reference for good. The client who forces it usually ends up with a file they can't use well. Settle it in a sentence while everybody still gets along.