Venture-Backed B2B SaaS Built an AI Chief-of-Staff Agent

Solarpunk is a 24/7 AI chief-of-staff for founders and leadership teams. Its buyers are people whose week is built out of recurring rituals — the 1:1 prep, the Monday pipeline review, the board update — each of which crosses email, calendar, documents, spreadsheets, CRM and ERP before it is finished.

Take the Monday pipeline review. Someone opens the CRM and pulls the deals that moved. They cross-check those numbers against a spreadsheet that lives somewhere else. They read back through the email threads on the two deals that slipped. They write the summary and send it. On Thursday they do a version of the same thing again for the board update, from mostly the same sources.

No single step there is hard. What makes the work expensive is that a person has to hold the sequence: remember what comes next, carry context out of the system they just left and into the one they just opened, check each result, and start over when a step fails without saying so. A typical leader is doing this across six to eight tools that share no memory with each other, so context is dropped at every handoff.

The assistants already on the market did not touch this. They could answer a question about the work. They could not own it — set a goal, take the steps, and follow through — and the moment a task needed more than one system, they came apart.

There was a harder constraint underneath. A great deal of a leader's week happens inside systems that have nothing but a login screen: single sign-on, MFA, no clean way in for software. Any product that can only reach the systems with a public API can only ever finish part of the routine. And a routine that is 70% finished still has a person holding the sequence, which means it has saved almost nothing.

• Finish the whole routine, not the subset of steps that happen to have an API

• Work inside login-only systems without anyone handing a password to a vendor

• Get sharper with use, instead of needing the same context re-explained every week

• Do real analysis on spreadsheets, and show work an analyst can check

We built Solarpunk as a desktop product that takes an outcome rather than a command. The leader says what they want to be true — the pipeline review is drafted, the board update is ready — and the agent works out the sequence, carries it out, reviews its own output, and comes back either with the finished work or with the single thing it could not resolve.

Two decisions are why it holds up across a real week instead of a demo.

The first is that it runs on the leader's own machine, with credentials held in an encrypted local vault. That is what lets it operate inside the systems that only have a login screen — where much of the week actually lives — without a password ever leaving the device or entering a model's context.

The second sounds like an implementation detail and is really a commercial guarantee. Every system the agent touches sits behind one common interface instead of being wired in one at a time. So when a vendor changes something, the fix is one contained change rather than a break that ripples through the product. That is the difference between an integration count that keeps growing and one that quietly stops at thirty because nobody can afford to maintain the thirty-first.

That interface is also where we got ahead of the field. Past about a hundred connected systems, the standard way of letting a model pick a tool stops working, so we had the agent look up the right one before calling it. The major labs shipped that same pattern as a documented standard months after we put it into production. It is the clearest evidence we can offer that the team was solving the real problem rather than following a recipe — there was no recipe yet.

Design decision: the agent reviews its own output before handing it back, and escalates what it cannot resolve rather than guessing. A leader who has to supervise every step is spending more time than the automation returns.

The leader states an outcome

Not a command and not a prompt chain — the state they want to exist. Drafting the plan is the agent's job, not theirs.

The agent works the sequence

It carries the plan out step by step across email, calendar, documents, spreadsheets, CRM, ERP and the login-only web apps, holding context between them so nothing is dropped at a handoff.

It checks itself before handing back

Each result is tested against what was actually asked. Work that looks wrong is retried; work it cannot complete safely comes back as a flagged exception rather than a confident, false "done".

Analysis arrives as work you can inspect

For spreadsheet and CSV work the agent writes and runs real code, then hands back a notebook an analyst can re-run and check — not a paragraph describing a number.

It gets sharper the longer it runs

The agent grounds itself in the leader's own workspace and reuses what it learned on the last run, so the plans improve with use instead of restarting from zero every Monday.

Who can do what

The agent can only act through systems that have been explicitly registered, and only in the ways those registrations allow. It cannot invent access it was not given. Credentials stay in the local vault and are supplied only when an approved action needs them.

What runs, in what order

A goal becomes a sequence of steps. Each step is attempted, observed and reviewed before the next one starts. That ordering is what turns more than a hundred connected systems into one predictable routine rather than a hundred independent chances to fail.

What you can see afterwards

Every run leaves a record of what was asked, what the agent planned, what it did, what came back, what it decided at each check, what it retried, and what it escalated. When something goes wrong, that record separates a planning mistake from a vendor outage, an expired login, or a system that simply does not support the action — which is the difference between a fix and a guess.

Solarpunk moved from answering questions to finishing routines. With the agent able to reason across every connected system, including the login-protected ones, it began carrying a real share of recurring executive work — and the gains compounded as it accumulated context about the workspace it was running in.

Because every integration sits behind one interface, the product also stayed maintainable as it grew. A vendor change is contained to a single integration instead of rippling outward.

• 40–60% of the steps in recurring exec rituals automated, including 1:1 prep, pipeline reviews and board updates

• Spreadsheet analysis pulled from hours to under fifteen minutes, returned as notebooks an analyst can re-run

• Plans completed with no human intervention rose from roughly 55% to 80% once the agent was grounded in the user's own workspace

We would rather you discount these correctly than take them on faith.

What is directly demonstrable in the product: more than a hundred connected systems, credentials held on-device, code-based spreadsheet analysis, action inside login-only web apps, and the self-check step before hand-back.

The three headline figures — 55% to 80% completion, 40–60% of recurring steps, hours down to about fifteen minutes — are internal measurements taken during the build. They are real numbers from real runs, and they have not yet been re-confirmed with the client on current production traffic. We have not restated them as a client-verified result, because they are not one yet.

For your own estimate, the model is workflow runs per month × current handling time × loaded hourly cost, minus the time still spent reviewing output and handling exceptions. One leader recovering 30 hours a month is 360 hours a year; against a $250,000 loaded cost that is roughly $43,000 of returned capacity. That is a capacity model, not booked savings, and it is worth running with your own numbers rather than ours.