Building applied AI for a better future

stagewise exists because we think agents should be partners that tackle work autonomously, not something you talk to on the side.

We started in software development, where one problem kept showing up again and again: agents were getting more capable, but they still could not see enough of the environment they were supposed to help with. So we built a way to feed live context from the app under development — the running UI, the selected element, the surrounding code — straight into the agent, so it could work from the actual state of the product instead of from a thin prompt.

That shaped how we think about this space. Better models alone do not solve the real problem. If an agent has no context, no memory, no way into the surrounding systems, and no clear limits on what it can do, it will always need you to act as its operator and gateway to the real world instead of doing things on its own.

The future of artificial intelligence is generalized

That is what shaped stagewise: first as a tool for development, then as an open-source platform for professional agents.

Now we are growing out of the software development space and into a broader agent platform. We are doing that because we do not think agents should be boxed in by one hosting setup, one machine, one device, or one narrow class of software. They should be able to connect to whatever people already use: laptops, phones, internal tools, modern agent-ready systems, and older human-native apps that were never designed for agents in the first place. And not just into one of these systems at a time, but doing meaningful work across platforms, databases, and machines in parallel.

Openness, Configurability, Affordability and Simplicity

A platform for autonomous agents has to be open and configurable. Open, because this layer is too important to be trapped inside a closed stack. Configurable, because different users, teams, and companies need different boundaries, permissions, and levels of autonomy.

As a team, we do not believe a future built on a single provider, model stack, or API is good enough. People should be able to choose how their agents are built, what they connect to, and how those systems evolve over time.

We also think the current market is upside down in a way that feels almost unfair. Today's agents are really only accessible to the people who have a significant chunk of money to pay for the currently used models, and who have the knowledge to do the grunt-work of setting the agent up and keeping it running. Everyone else gets a brittle experience: too much configuration, too many moving parts, things breaking for reasons nobody has time to debug. This bothers us massively, and we think the future can look brighter if we build a platform that focuses on fixing these issues.

We do not want AI to be useful only for people who can tolerate constant setup friction. We do not want people to have to learn a whole new operating model just to benefit from these systems. We do not want to gate autonomous and truly helpful AI behind costs that make the unit economics not add up anymore.

Outcome-maxxing, not Token-maxxing

With everything we do, we strive to build products that don't follow hype or vanity metrics. This includes focusing on the right numbers, and working backwards from the outcome our users want to see.

Our goal is not to make our users use as many tokens as possible, or to maximize SOTA model usage. Instead, our target is to build agents that reliably generate a positive outcome for the user over and over, while minimizing the amount of time and energy (and thus cost!) that was spent to reach this outcome.

We want to do so without requiring the user to think extensively about optimizing the agent, just like you would never try to introspect and optimize the brain of a human in your workforce (unless you are very weird. Don't do that, please). Instead, you should expect the agent to learn and optimize itself autonomously.

What if agents are hyper-autonomous?

This is the question we are asking ourselves all the time when we think about the future of work with AI. And it's also how we shape the vision of our products. What would it mean for agents to pick up work directly from GitHub, where issues are discussed and prioritized? How should they participate in Jira or Teams, where product decisions are actually made?

What changes when the system can notice what matters, ask for input, and take the next step within limits the user has set, instead of waiting for a human to initiate everything?

While a future where this is true is certainly not without risk for its users, we are confident that responsible and thoughtful development towards this future unlocks possibilities that are difficult to imagine. And in light of that, doing so in a way that unlocks this power for everyone is more important than ever.

The north star

We are building toward a platform where agents can move across different environments, work with people and other agents, and stay useful as goals, tools, and teams change around them.

Humans decide where agents are used, what they can access, and how much autonomy they get. The agents, in turn, should be present with any modality the user may want to use. In a way that resembles how humans already interact with other humans, and with a level of reliability and intelligence that makes you feel at ease.