Six months ago I was let go from my job. I had been an engineer there for five years, and I didn't see it coming.
I'm not going to name the company, and this isn't that kind of post. What matters is what I did next. I applied for jobs, sure, and got turned down for some I could have done in my sleep. That's how hiring goes right now. So I stopped waiting on it and built things. Every day.
A few of those things turned out to be good. Good enough that I think a lot of people could use them. So I'm starting a company to release it. This is day one of Farside Research.
#What came out of six months
The first thing I'm releasing is StateFrame, an open agent engine. It started with something that bugged me.
Every agent I tried worked the same way. It kept the whole conversation and sent all of it back to the model on every turn. Turn 5 is fine. By turn 200 the model is rereading a novel about itself before it can take one more step. The prompt keeps growing, the memory it needs keeps growing, and sooner or later you need a bigger GPU or a bigger model just to stop the thing from losing the plot.
So I threw the conversation out. StateFrame keeps track of the job instead: what the task is, what's been tried, what passed, what's left. Each turn the model gets that, plus whatever just happened, and that's it. The old turns still get saved to disk. They just stop riding along.
That one change buys a lot:
- The context window stays flat. Turn 300 is about the same size as turn 3. In a 300-request run, every single prompt fit inside the same 33,344-token budget, and the biggest one was 32,159.
- A GPU you can put in a desktop. When you're not hauling a giant conversation around, the memory goes to the model instead of the history. Every result I've published came from one rented 48 GB cloud GPU running an open model, not a rack of datacenter hardware.
- More agents on that one card. I ran 4 at once and all 4 passed, with memory sitting at about 26.4 GB the whole time. It isn't free: each one ran about twice as slow as it would alone. But together they got about 1.9 times the work done.
- Nothing hidden. Every request gets saved, so you can pull up exactly what the model saw on any turn.
Notice that 26.4 GB. I don't have a 24 GB card to test on, but my theory is that a mixture-of-experts model like Qwen3.6-35B-A3B, with part of it offloaded, could still run at least 4 agents on one, maybe even 8 if you can live with each one running slower. I haven't had time to prove it, so it stays a theory until someone measures it. Maybe you.
It's an early release. I designed it over about four weeks, on and off, and it shows in places: really long tasks, and changes that touch ten or more files, can still stall out. The StateFrame page lists every number I measured, how I measured it, and everything that doesn't work yet. I'd rather ship it now and let it help people than sit on it until it's perfect.
#Releasing it slowly, in the open
StateFrame is the first of several. I'm going to release what I've built one piece at a time, each one when it's ready and not before.
Next up is the Momentum Engine, in the next few weeks. It has a bit of a backstory. I've been building a platform, codenamed Mission Control, that runs entire businesses with autonomous agents. Momentum is its beating heart. It's the engine that decides what the business should do next.
It watches the whole company, not one dashboard. Marketing, sales, customer success, product, finance, engineering, operations and the rest each get their own loop, eleven in all, reading that part of the business on a steady rhythm and deciding what actually deserves a move.
The autonomy is bounded, and it's earned. Small, reversible tweaks that a rule you wrote already covers, it just does. Anything bigger turns into a proposal that a person approves or rejects. Every move comes with a prediction, and Momentum goes back later and scores that prediction against the real number. When a kind of move builds a strong record (people keep approving it, and it keeps working), Momentum asks for permission to handle that kind on its own, and it tells you every time it does. It never promotes itself. Going the other way is automatic: if those moves start missing, or you overrule one, it loses that freedom by itself and goes back to asking.
It also cleans up after itself. Ideas you keep rejecting go on cooldown so it stops pitching the same tired thing. Work that hits the kill criteria you set up front gets flagged for shutdown, and you make that call.
This is the part of Mission Control I'm proudest of, and I'm cutting it out and giving it away under the same license as StateFrame.
After that there's one more I can't talk about yet, and a whole lot more already half built or scribbled across my very large whiteboard.
What gets released stays open. That promise gets its own post, because it deserves more than a paragraph.
#What Farside Research is
Right now it's me. One person, a laptop, and a lot of AI tools that write code while I decide what gets built and make sure it actually works. No office, no team down the hall, no sales desk. When you read something on this blog, I wrote it (with Claude's help polishing it up, of course).
Besides the engines, there's Farside, a deep research app. You ask a real question, it searches, grades the sources, and writes a cited answer you can keep questioning. It's where a lot of this work gets put to use every day.
#Where the money fits
I have a wife and kids. This has to pay the bills, and I'm not going to pretend otherwise.
The money comes from two places: the research app, and commercial licenses for companies that can't use the AGPL. That's it. Everything I release in the open stays open whether anyone pays or not, and the people who do pay are what keep the next release coming.
I'm open to investors. They just have to actually believe in what I'm building, and they have to accept up front that the open source pledge is not up for negotiation. Not in a term sheet, not in a down round, not ever. If that's a dealbreaker, we're not a fit, and that's fine.
#What this blog is for
Everything I learn, out in the open. Research findings, company news, and the engineering behind it, including the bugs and the ideas that didn't pan out. If I put a number here, it was measured, and I'll tell you how.
I'll be honest, putting this out makes me nervous. Real engineers are going to read this code, and some of them will find things I got wrong. Good. That's the point of doing it in the open. If you find something, open an issue on GitHub. At the end of the day, being right isn't the most important thing. Getting the best solutions out there for everyone is.
Six months ago I lost my job. I didn't lose the drive. I've built something almost every day since, and that isn't going to change. Whether ten people read this or ten thousand, I'll keep showing up and shipping, one release at a time.
Just wait until you see what else is on this laptop.