I spent an hour this week watching Cursor’s Grok Bot webinar, and honestly, I went in expecting the usual product pitch. The framing is what got me, not any single feature.
Stop thinking of an agent as something you hand a task to. Start thinking of it as a colleague: a role, a memory of everything you’ve worked on together, its own computer, the ability to hand work off to other agents without you in the loop. Close your laptop and the work doesn’t stop.
I spent most of the rest of the session doing something else entirely - recognizing our own roadmap in someone else’s slide deck.
We’ve been building toward this at Customertimes for a while now, using Cursor (Grok Bot isn’t in the stack yet) on Salesforce Spiff and SPM implementations. Four stages of delivery are already heavily automated: presales scoping, where a prospect gets a rough estimate in under an hour instead of days; solution design, where a phased build plan gets pulled straight from the client’s requirements; the actual build, where agents handle much of the system configuration themselves; and documentation and training, generated from the implementation itself instead of written up after the fact by whoever drew the short straw.
That’s the part I keep coming back to. Grok Bot already ships with its own memory. What we’re building on top of that is a second layer, our own institutional knowledge, and feeding it back into Cursor is what makes an already smart agent noticeably smarter, with a memory that goes well beyond what came out of the box.
Any enterprise software shop accumulates hundreds of small lessons over the years - the kind that never make it into a wiki page, that a good consultant just knows in their bones. Which steps have to happen in a specific order, and which ones you can reorder without consequence. Which shortcuts save you a day now and cost you three weeks later. Which configurations look perfectly fine in the sandbox and quietly fail the moment they touch production. And how you actually check that the result is right, as opposed to how the documentation says you’re supposed to check it.
For decades that knowledge lived in people’s heads. Every new team learned it the same way the last one did - the hard way, usually on a client’s dime.
We can capture it once now. Every agent on every project gets to start from what the last twenty implementations already taught us, instead of starting from zero.
On our first production run with this model, we cut both effort and delivery time by a wide margin, and in the same project reconciled several thousand compensation statements against the client’s actual payout data without anyone doing it line by line.
There’s a boundary worth being explicit about here. Agents get the width of the work. Humans keep the judgment - the business calls, the interpretation of ambiguous rules, the sign-off before anything goes live. That part hasn’t moved, and I don’t expect it to for a while.
Cursor’s right that the paradigm shifted. Where I’d push back a little is on what matters most about it, for a consulting business specifically.
The easy part to build is agents that work continuously, collaborate, and take on harder tasks without supervision - every vendor will have a version of that within two years. The harder part to copy is what happens when that machinery runs into twenty years of implementations, mistakes, edge cases, and the judgment calls only a room full of senior consultants would know to make.
For a professional services firm, that accumulated experience has always been the asset, even when nobody could put a number on it. It just used to live in people’s heads, in scattered documents, in whoever happened to be staffed on a given project - useful to the people in that room, gone the day they left the company.
Now it doesn’t have to stay there. It can sit underneath every agent, on every engagement, from day one.
Good agents plus knowledge nobody else has. That’s the combination I think actually moves the number on what consulting costs to deliver, not the agents by themselves.