Can Apollo redline your contracts? Yes, against your playbook, clause by clause

A vendor’s contract lands in the inbox at 4pm on a Friday. Twenty-two pages. Somewhere in clause 9.3 the liability cap is one-twelfth of what you signed last quarter, the auto-renewal is silent, and the payment terms quietly slid from net-60 to net-15. None of it is flagged. None of it is wrong, exactly, it’s just their paper, written to favor them, the way every first draft is. The job in front of you isn’t to read it. It’s to find the three places where it disagrees with how you do business, and push back on each one before you sign.

That job has a name. It’s called redlining, and almost nobody does it well, because doing it well means holding your entire deal history in your head at once.

Redlining isn’t reading a contract, it’s grading each clause against the deals you’ve already agreed to, flagging the off-market term, drafting the counter, and naming the risk. That sentence is the whole product. The rest of this post takes it apart, clause by clause, and shows why the hard part was never the reading.

Reading a contract is not the same as redlining one

Start with the confusion that sinks most “AI for legal” tools.

The naive version reads the contract and summarizes it. You paste in twenty-two pages and get back a tidy paragraph: this is a software services agreement, twelve-month term, with standard liability and confidentiality provisions. Useful, briefly. Then useless, because a summary tells you what the contract says, and the entire point of redlining is to catch what the contract says that you would never agree to. A summary that calls clause 9.3 “standard liability” has already lost, because 9.3 isn’t standard. It’s a twelfth of your normal cap, and “standard” is exactly the word that lets it through.

The pain here is specific, and anyone who has signed a vendor agreement under time pressure knows it. The contract is internally coherent. Every clause reads as reasonable on its own. The off-market term doesn’t look wrong; it looks normal, because the other side wrote it to look normal. You can read the whole thing carefully, understand every word, and still sign a bad deal, because the problem was never comprehension. It was comparison.

Redlining is comparison. It grades each clause not against the dictionary but against a baseline: the terms you’ve actually agreed to before, the floor you won’t go below, the playbook your business runs on. “Net-15” isn’t bad in the abstract. It’s bad relative to the net-60 you’ve signed eleven times. The intelligence isn’t in understanding the clause. It’s in knowing what you consider the clause should say, and noticing, instantly, every place this paper deviates.

So a redlining system can’t start with a reader. It has to start with a memory of your deals.

The playbook is the part nobody can hold in their head

Here’s the thing that makes redlining a job for software and not a smarter prompt.

Your negotiating position isn’t written down in one place. It’s smeared across every contract you’ve ever signed. The liability cap you hold the line on lives in a deal from two years ago. The indemnification language your counsel insists on lives in a template someone saved once and forgot. The fact that you always strike the unilateral-termination clause lives nowhere at all, it lives in the habit of one person who’s negotiated forty of these and just knows. When that person is busy, or on vacation, or gone, the playbook goes with them.

So the naive fix is to ask a sharp generalist to “review this contract for unfavorable terms.” And a sharp generalist will catch the obvious ones, the missing liability cap, the absurd indemnity. But “unfavorable” is relative to a baseline the generalist doesn’t have. They don’t know that you always cap at a specific multiple, that you never accept auto-renewal without a notice window, that net-30 is your floor and net-15 is a walk-away. They flag what’s unusual in general. They can’t flag what’s unusual for you, because the thing that’s unusual for you is encoded in your history, and they’ve never read it.

This is where a company brain changes the shape of the problem. Suppose the system has read every contract you’ve signed, not to summarize them, but to learn the shape of the deals you accept. The liability multiples you’ve held. The payment terms you’ve landed on. The clauses you reliably strike. That’s not a document. It’s a position, distilled from your own history, and it’s the thing the redline grades against. The clause isn’t compared to some platonic “fair contract.” It’s compared to the contracts that have your signature on them.

That’s the foundation. Once the position exists, the redline is three moves on every clause.

Move one: flag the term that’s off your market

The first move is the cut. Twenty-two pages become a short list of the clauses that disagree with your playbook.

The naive version flags everything and helps nothing. You’ve seen this tool, it highlights forty passages in yellow, “for your review,” and now you have a forty-item review instead of a contract. That’s not triage. That’s the same problem in a highlighter. The cost of flagging everything is identical to the cost of flagging nothing: you still have to read all of it to find the three that matter.

The job is the cut, and the cut is only possible because there’s a baseline to cut against. The liability cap matches your floor, pass it, silently, no flag. The confidentiality clause is your standard language, pass it. The payment terms dropped to net-15 against your net-60 history, flag it, because it deviates. The auto-renewal has no notice window where you always require one, flag it. Three flags out of twenty-two clauses, and the other nineteen graded clean and waved through. The reader’s attention goes to the three deviations, not the whole document, because the system already compared all twenty-two and only kept the ones that fight your playbook.

A good redline is mostly silence. Nineteen clauses it never mentions, because nineteen clauses agreed with you. The whole value is in what it doesn’t surface.

Move two: draft the counter, don’t just complain

Flagging is half a job. A flag that says “this term is unfavorable” leaves you exactly where you started, you knew the contract favored them; that’s why it’s their contract. The flag that earns its place comes with the fix already written.

Picture the difference. The weak version says: clause 9.3 caps liability below your typical threshold. True, unhelpful, and now you open a blank document and write the counter yourself at 5pm on a Friday. The strong version says: clause 9.3 caps liability at a fraction of where you usually land; here is the substitute language that restores your normal cap, in the contract’s own phrasing, ready to send back. One is a complaint. The other is a redline, the actual edit, the struck text and the proposed replacement, drafted to drop into the document and go back across the table.

That drafting is where the playbook pays off twice. The counter isn’t invented from a sense of fairness. It’s pulled from the language you’ve successfully negotiated before, the exact cap, the exact notice window, the exact payment term that the other side has accepted from you in the past. The system isn’t guessing what you’d want. It’s proposing what you’ve already won, in language a counterparty has already agreed to, because it learned both from the deals on file.

Three flagged clauses, three drafted counters, each one a real edit and not a feeling about an edit. That’s the difference between a tool that reviews and a tool that negotiates the first pass for you.

Move three: name the risk so a human can decide

The third move is the one that keeps this honest, and it’s the one most “AI lawyer” demos skip.

Every flag carries a reason, in plain language, about what the clause costs you if you sign it as written. Not “this is non-standard.” Rather: as written, this cap means a worst-case incident exposes you well beyond your usual ceiling, here’s the scenario where that bites. The auto-renewal with no notice window: as written, this renews silently, so a year from now you’re locked in for another term unless someone remembers to cancel inside a window that isn’t specified. The shortened payment term: this pulls cash out the door faster than your norm; here’s the working-capital effect if you say yes.

The reason is the whole product, for the same reason it was the whole product in any briefing worth reading. A flag with no reason is a guess you’re asked to trust. A flag with a named risk is intelligence you can act on, and argue with, and override, because you know something the contract doesn’t. Maybe this vendor is strategic and the short payment term is worth it. Maybe the low cap is fine because the engagement is tiny. The system doesn’t know that. You do. So the system’s job ends precisely where judgment begins: it surfaces the deviation, drafts the fix, names the cost, and then it stops.

That stop is not a limitation. It’s the design.

Where the line is: it redlines, you sign

It’s worth being exact about the boundary, because this is the boundary that makes the whole thing usable.

Apollo is built so the system does the comparison and the drafting, the parts that are tedious, error-prone, and dependent on a memory no human reliably has at 5pm on a Friday. It reads the clause, grades it against your history, drafts the counter, names the risk. What it does not do is decide. It does not send the redline back on its own. It does not sign. The contract is a decision with money and liability on it, and a decision like that routes to a person every time, the same way a serious change in a serious codebase routes to a reviewer before it merges.

This is the same shape every trustworthy agent has, and it’s worth saying plainly: the system moves first and decides last. It does the assembly while you’re not looking, and it hands you a decision instead of a chore. The off-market clause that would have slipped through is now a flag with a fix and a reason attached. You read three things instead of twenty-two pages. And the one thing that was always yours, whether this deal, on these terms, is one you want, is the one thing the system leaves entirely to you.

Redlining isn’t reading a contract, it’s grading each clause against the deals you’ve already agreed to, flagging the off-market term, drafting the counter, and naming the risk. The reading was never the hard part. The remembering was.

The turn: stop being your company’s contract memory

Here’s the part that isn’t about software.

Right now, in most companies, somebody is the contract memory. They’re the one who’s negotiated enough of these to feel when a term is off, who reads clause 9.3 and something itches, even if they can’t immediately say why. That instinct is real, and it’s valuable, and it is also a single point of failure wearing a person. It doesn’t scale past the deals one human can hold. It walks out the door when they take a new job. And it fails exactly when it’s needed most, at 5pm on a Friday, on the twenty-second page, when they’re tired and the deal is “basically standard.”

That instinct deserves to be a system, not a person’s burden. Not because the person isn’t good at it, they’re the best at it, which is exactly why their time shouldn’t be spent re-reading boilerplate to find the one clause that moved. The point of redlining against a playbook is that the playbook stops living in one head and starts living in the company. The deviation gets caught whether the expert is in the room or on a beach. And the expert gets to do the part only they can do: not finding the off-market clause, but deciding, with the clause already found and the counter already drafted, whether this is a deal worth doing at all.

---

That’s what we’re building at Apollo, not a tool that reads your contracts faster, but a company brain that remembers every deal you’ve signed and grades the next one against it, so the off-market clause never makes it past Friday. If you’ve ever signed something you’d have caught on a Monday, you already know the problem was never the contract. It was that the memory of all your other contracts wasn’t in the room.