Earlier in this section I wrote about when local models are worth the trouble, and I didn’t name a single one. On purpose. Model recommendations go stale fast.

This piece names names. At some point the abstract version stops helping and you need to know what to actually install. Then it does something I haven’t seen another firm write down: it shows how to turn that capability into a choice the client makes, in the engagement letter, with a price on it.

The two halves go together. A client’s election is worthless if the firm can’t technically honor it. Running your own models is what turns “nothing about my matter leaves your building” from a promise into a control.

Part One: The stack

Why Qwen

The Qwen family, from Alibaba’s Qwen team, has become the go-to pick for running models locally. The reasons are practical.

The license. Qwen’s open-weight models are released under Apache 2.0. For a law firm that’s a big deal. Apache 2.0 means you can download the weights, run them on your own hardware, use them commercially, and keep doing it — no royalty, no usage reporting, and no clause that lets anybody pull the rug out later. Several otherwise excellent open-weight models ship under custom licenses with acceptable-use terms and revocation language. When your practice leans on something every day, a standard, permissive license is worth a lot.

The size ladder. Qwen ships an unusually wide range, from models under a billion parameters up to very large mixture-of-experts versions. Different jobs in a law office want different sizes, and staying inside one family means you prompt them the same way and the same tools work on all of them.

Where things stand as I write this. Qwen3 runs from roughly 0.6B to 235B. Qwen3.5 landed in February 2026, and Qwen3.6 followed in April, including a 27B dense model with a 256K context window that runs in roughly 17 GB of memory. That last one is the sweet spot for legal work right now. 27B is big enough to actually help, 17 GB fits comfortably on a well-equipped laptop, and 256K of context holds a good chunk of a matter file.

Those version numbers will spoil. The family and the license won’t.

Choosing a size

Here’s rough guidance by the job you’re actually doing:

That last row is the one that matters. I’ve said it before and it hasn’t changed. On bounded, mechanical work, local models are close enough that the gap doesn’t matter. On hard reasoning they’re behind, and there the gap is the whole point. Run the volume locally. Send the twelve documents that matter to the best model you can get.

Pick a runtime

There are four real options, and the choice matters a lot less than the internet would have you believe.

Ollama is where almost everybody should start. One install, ollama pull qwen3:27b, and you’ve got a local API on your machine. It grabs the quantized weights for you and exposes an HTTP endpoint most tools already speak. Recent versions run Apple’s MLX under the hood on M-series chips, so you get the Apple-silicon speed without babysitting it.

LM Studio is the same idea with a GUI: a model browser, a chat window, a server switch. If nobody at your firm wants to touch a terminal, start here.

llama.cpp is the engine under a lot of this, and the GGUF quantization format comes out of its family tree. Use it directly when you need control the wrappers don’t give you.

MLX is Apple’s own framework, and on M-series hardware it’s the fastest path. Third-party benchmarks put it meaningfully ahead of GGUF equivalents on token throughput for bigger models, and MLX-format weights tend to be a little smaller on disk. If your whole firm is on Apple silicon and speed matters to you, it’s worth the extra setup.

My advice: start with Ollama. Move to MLX only if you measure a reason to.

Quantization, briefly

Model weights are normally 16-bit numbers. Quantization stores them at lower precision — 8-bit, 4-bit — which roughly halves or quarters the memory you need, at some cost in quality.

The practical answer is Q4_K_M, the default most people run. It’s a four-bit format, but it gives the attention and embedding layers a slightly bigger bit budget, and that’s why it holds up noticeably better than the older flat four-bit formats. Unless you’ve measured a reason to go higher, use it and move on.

For capacity planning, the rule of thumb is that a 4-bit quantized model needs roughly 0.6 GB of memory per billion parameters, plus room for context. A 27B model lands around 17 GB, which squares with the numbers above. A 32B model needs a bit over 20 GB. Add several more GB if you plan on long context, because the key-value cache grows with it, and on long legal documents that’s no rounding error.

Hardware

On Apple silicon, unified memory is the number to watch, because the CPU and GPU share one pool.

• 16 GB — 4B–8B models. Real classification and extraction work. A genuine starting point, not a toy.
• 32 GB — up to about 14B comfortably, 27B with a short context.
• 64 GB — 27B–32B with real context. This is the practical target for a firm that wants local drafting.
• 128 GB+ — larger models and multiple loaded at once.

For a small firm, here’s the whole budget: the jump from 32 GB to 64 GB on a machine you were buying anyway is the entire capital cost of this program. That’s not nothing. It’s also not a server room.

Part Two: Letting the client choose

This is the part I think is actually new, and it started with a question a client asked me straight out: “Are you using AI on my case, and do I get a say?”

The answer to the second half should be yes. So we built one.

The tier election

Put an election in the engagement letter. The client picks one, and it governs the matter.

Tier 0 — No AI. No model of any kind touches this matter. Traditional research, human drafting, human review. Anybody can have it, for any reason or none.

Tier 1 — In-house only. Only models running on the firm’s own hardware. No information relating to the representation is transmitted to any outside provider. This is the tier Qwen is here for.

Tier 2 — In-house plus contracted providers. (Default.) Bulk work runs locally; specific, selected excerpts may go to an outside provider working under a written agreement that forbids training on our inputs and limits retention. For most matters it’s the best mix of cost and quality.

Tier 3 — Maximum leverage. Everything in Tier 2, plus AI-assisted review at scale on big document sets, and automated monitoring. It’s for high-volume matters where the alternative is a review budget the client can’t afford.

What makes it more than a form

1. Price the tiers, in dollars, in the letter.

This is the one that matters, and it’s the one most firms won’t want to do.

If the client can’t price an election, it isn’t an election. If Tier 0 means the work takes longer, the client has to see what that costs before picking it. Otherwise “no AI” is a free option everybody takes for comfort, and the firm quietly eats the difference or, worse, quietly doesn’t honor it.

So the letter says what each tier costs. That’s no penalty for picking Tier 0. It’s the actual price of the actual work. A document review that takes 90 hours by hand and 12 hours assisted is two different bills, and the client gets to know that before deciding which one they’re buying.

Here’s the effect I didn’t see coming, and I’ve come to think it’s the best argument for the whole thing. Publishing the price difference forces the efficiency through to the client. A firm that shows a client “Tier 2 saves you $9,000 on this matter” can’t turn around and bill Tier 2 work at Tier 0 rates. The election puts the savings in plain view, and savings in plain view are savings the client actually gets. That’s the point of everything else in this section.

2. The default is the middle, and silence is never consent to the top.

If a client doesn’t pick, they get Tier 2. Not Tier 3. A client who never engaged with the question should land somewhere ordinary and defensible, not at maximum leverage.

3. The election has to be technically enforceable.

This is where the two halves meet, and it’s the difference between a control and a promise.

If a client elects Tier 1, the firm has to be built so it can’t send their information to an outside provider. Promising to remember isn’t good enough. In practice the matter gets flagged, the flag gates the routing, and the tools on that matter have no road to an external API. A local-only stack is what makes that enforceable, because the work has somewhere else to go.

I’ve made this argument about other things over and over: an unimplemented endpoint is a wall, an instruction is a request. It hits harder here than anywhere, because here the promise went to a client in writing.

What doesn’t change by tier

The letter should spell this out, because it’s what clients actually worry about:

• A lawyer reviews and signs everything. At every tier, including Tier 3.
• Every citation is verified against the source. At every tier.
• Confidentiality obligations are identical. Tier 3 isn’t a lower standard of care. It’s a different toolset under the same duty.
• The lawyer is responsible for the work. Not the tool, not the vendor, not the tier.

The rules underneath it

Rule 1.4(b) requires a lawyer to “explain a matter to the extent reasonably necessary to permit the client to make informed decisions regarding the representation.” Rule 1.6(c) requires “reasonable efforts to prevent the inadvertent or unauthorized disclosure of, or unauthorized access to, information relating to the representation of a client.” The ABA’s Formal Opinion 512 runs generative AI through those same duties, and its confidentiality analysis turns on the client’s informed consent where information relating to the representation would be exposed.

A tier election is, I’d argue, a fairly direct way to carry out all three. It gives the client the information, it gives them the decision, and it puts both in writing. I don’t know of any authority that requires it, and I’m not saying it’s required. I’m saying it answers those rules better than a paragraph of boilerplate nobody reads.

Where this is weakest

Is it coercive to price Tier 0 higher? A client who can’t afford the no-AI option hasn’t really been given a choice. There’s a real argument that offering an option you’ve made more expensive is a soft kind of pressure, especially on an individual with limited means up against an institutional opponent.

My answer is that the price gap isn’t manufactured. The work really does take longer, and charging the same for both would mean overcharging one client to pay for another’s preference. But I’m less sure of that answer than I’d like to be. So keep the gap honest instead of punitive, explain plainly why it’s there, and never treat a Tier 0 client as a difficult client.

And one I don’t have a good answer to at all: the tier governs how we handle our client’s information. It doesn’t govern the other side’s documents, or a third party’s records produced in discovery. Those people didn’t elect anything and get no say. That’s a real hole in the framework, and I don’t think client consent fills it. The only discipline I’ve found that touches it is minimum-necessary handling of everybody’s information, no matter whose it is. That’s a practice. It isn’t a control.

Why bother with any of this

Because the question is coming, and the firms that haven’t thought about it are going to answer badly.

Clients are going to ask what you’re doing with their information. The wrong answer is a startled improvisation, or a clause in the engagement letter that authorizes everything. The right answer is: here are your options, here’s what each one costs, here’s what stays the same no matter what, and here’s how we make sure your choice is honored.

You need the technical capability first. You can’t offer Tier 1 if everything you do runs through somebody else’s API. That’s the real reason to spend a weekend with Ollama and a 27B model. It isn’t that local is cheaper, though it is. It isn’t speed, because it’s not faster.

It’s that it lets you hand the decision to the person whose information it is.

Sources

• Qwen open-weight model releases (Apache 2.0); Qwen3, Qwen3.5 (February 2026), Qwen3.6 (April 2026)
• Ollama, LM Studio, llama.cpp, and MLX
• Minn. R. Prof. Conduct 1.4 and Rule 1.6
• ABA Standing Committee on Ethics and Professional Responsibility, Formal Opinion 512 (July 29, 2024)

Rules quoted were verified against the Revisor of Statutes. Model versions, memory figures, and runtime performance characteristics change rapidly and are current only as of writing — verify before relying on them. General commentary on practice management; not legal advice, not ethics advice, and not a hardware or vendor recommendation. The tier framework described here is this firm’s own approach, not a standard, and Formal Opinion 512 is advisory rather than binding in any jurisdiction.