Our founder and CTO, Oskar Boëthius Lissheim, just published a piece on the bet he's making six months into building the new Multiply: that the next frontier in agentic engineering isn't prompts, it's shared context — the reasoning your team's agent sessions generate and then throw away. We've adapted it below. Read the original on LinkedIn.
Six months into building the new Multiply, here's the bet I'm making: the next frontier in agentic engineering isn't prompts. It's shared context. Part of an ongoing series; earlier I covered Figma to Claude to Spec to Prod, and why critiquing is key.
Once upon a time prompt engineering was king, and a new job title sprung up (with ridiculous salaries worthy of a bubble). Then the models grew insanely smart, and that crown got a lot lighter.
What rules now is context. Not the prompt you type, but everything the model sees: how detailed and deep you make it, how hard you prune it, how crisp and unpolluted you keep it. And increasingly, how you bring it together across a whole team, preferably a whole org. If you've read the earlier posts in this series you'll recognize the shape: the durable value keeps landing in the scaffolding around the model, not in the model itself.
The watershed
I started paying attention to this over the last year and a half, while falling in love (the terrified kind, at first) with agentic coding: first Aider, then Claude Code. When Opus 4.5 landed in late November, Claude Code finally stopped feeling like an ever-improving "fancy autocomplete", and started feeling like a colleague.
I'll admit I was too swamped with heads-down coding and infra to clock the watershed as it happened. But it lodged in my backmind, and during the "hammock time" around New Year's I read what others had written about it. A new "ChatGPT moment", almost exactly three years after the first one.
The most mind-altering reading came in relation to "software factories" (thanks Steve Yegge, for Gas Town and beads and the blog posts) and "shared team context". While I cringe a bit thinking about the first (at least the naming), the other two won't leave me alone.
The reasoning evaporates
Here's where it stopped being abstract for me. Right around the winter holidays I started saving a transcript of every Claude session I run: a dated markdown file in a git repo, with the decisions made and the dead ends hit noted at the top, all of it greppable. Nothing clever about it. The payoff comes weeks later, when you're staring at a choice nobody can explain anymore, and the reasoning is just... there. (Case in point: this very post was finalized over a month after drafting, and it was an old session transcript that remembered an open fact-check I'd forgotten about.)
Because that's the real failure mode: when a session closes, the decision survives (in git or in the spec or in prod) but the reasoning behind it evaporates. Everything downstream is re-derivation. The next engineer, or the next agent, either re-discovers the why or quietly contradicts it.
Worth keeping the layers straight, since the words get used interchangeably: transcripts are the raw record, memory is what you distill and keep, context is the slice an agent loads into a session. "Shared context" is the middle layer going team-wide.
And team-wide is where it bites. A feature at Multiply is often built by a pair of engineers plus a designer (the standard composition of Shape Up core teams), and each person's agent sessions are full of decisions and dead ends the others never see. My personal transcript habit helps me; it does nothing for them. Private memory doesn't scale to a team.
Two teams, same primitive
Making that memory automatic and shared is the interesting work right now. SageOx is the implementation I've been following most closely. Going by their writing (we've experimented with it but haven't run it in anger yet), it's a layer on top of the coding agents engineers already use every day, simply a CLI plus MCP, with everyone's sessions feeding a common pool that gets mined in real time. The pool is the shared context. And Momental arrives at the same primitive from the product side (shout out to my old friend Mathias Kleverud from Göteborg, now doing his Silicon Valley journey): shared team context first, agents on top of it.
Two data points is not proof; startups converge on doomed ideas all the time. What makes me weight this convergence is that both teams are solving a problem I'd already hit on my own, before reading either pitch. The pull comes from the work, not the deck.
It's also such an obvious capability, once you've felt the lack of it, that some version will likely get built into the harnesses themselves before too long (i.e. Claude Code and its siblings). The open question is whether a pooled context can stay crisp. Pooling scales the pollution just as easily as the signal, and whoever solves that gets to keep the crown for a while.
Hats off, and onward
There are lots of teams circling this. SageOx sticks top of mind for me, much due to their prolific sharing in their blog and their energetic output, while all being very senior people (case in point that this new era is definitely not just a young person's game). I wish them all the best, and many thanks for the inspiration 🙏🏻 (And congrats on the $15M seed round.)
A wild ride, these last eight months. I'll keep writing as we go: what we're using, where we're getting it wrong, what surprises us. And if you've found a way to make session reasoning shared across a team without it rotting, I genuinely want to hear it — I'm still mostly hand-rolling mine.
SageOx is the Seattle team building a hivemind for agentic engineering; Momental is the product-side take on the same primitive; the Yegge essays are linked at your own risk, and his beads tracker is along these lines and something I'm using personally with my agents, as well as integrating into our team workflow.
This is part of an ongoing series on how we build Multiply. Read Oskar's full essay on LinkedIn.