Soleur Blog

Agents That Use APIs, Not Browsers (2026)

2026-04-23T00:00:00Z

Running a company alone means running a lot of vendor dashboards. Cloudflare, Stripe, Plausible, Resend, Hetzner — every one of them is a tab you keep open, a form you fill out, a setting you remember to flip. "Service automation" is the layer that lets an agent do that vendor work on your behalf, through the same APIs you would call by hand. Soleur's service automation shipped this week, and it is open source.

The bet underneath it: agents should talk to APIs, not browsers. We spent a month proving that out. Here is what we built, what we rejected, and what you can use today.

What service automation is, in one sentence

Service automation is the capability that lets an AI agent provision, configure, and operate third-party services — create a DNS record, issue a Stripe refund, spin up a Plausible site — by calling vendor APIs directly, using tokens you own, on your behalf.

That sentence matters because the phrase "service automation" is doing real work in the industry right now. Some tools mean "an agent that drives a browser through a dashboard." Others mean "a workflow engine that chains Zapier-style connectors." We mean neither. We mean an agent that reads a vendor's API contract, holds your token, makes the HTTP call, handles the error, and writes the result back into your knowledge base.

If you want the short version: your AI team gets credentials the same way a new hire does, and uses them the same way a senior engineer would — through the API, not the UI.

The fork in the road: browsers or APIs

Back in March we had a real decision to make. Service automation had been validated by founder interviews as one of the top-three requests. The open question was how an agent should actually carry out vendor work.

The popular answer in the agent industry is browser automation: run Playwright on a server, let the agent log into each dashboard, click through the forms, scrape the confirmation page. It looks great in demos. It is also how most "agent platforms" you see on launch day are actually built.

We rejected it. Four reasons, in the order they hurt:

Attack surface. Running a headless browser on your server that logs into external dashboards on behalf of your users removes nothing from the threat model — it adds to it. A server-side browser that follows redirects, loads arbitrary pages, and accepts scripted input is the canonical shape of a server-side-request-forgery primitive. Going API-first removes the server-side browser attack surface.
Cost. Our CFO flagged 2–4× infra-cost risk if we relied on browser automation. Headless browsers are RAM-hungry, they need long-lived sessions, and they fail in ways that require retries. A single REST call costs fractions of a cent. A browser session costs meaningful money.
Drift. Vendor dashboards change layout every few months. Vendor APIs change on deprecation schedules. If your automation tier is built on CSS selectors, every marketing redesign breaks your agent. If it is built on documented endpoints, you get years of stability.
Trust. When a founder hands an agent a credential, they want to know where it lives and what it does. "Our server never opens a browser to your dashboard" is a promise we can keep. "Our scraper won't do anything weird" is not.

So we went API-first and wrote the whole thing up in an architecture decision record. Three tiers, ordered by how much of the vendor universe they cover:

Tier 1 — Direct API + MCP. Target allocation: roughly 80% of services. Design, not measurement.
Tier 2 — Local browser automation. Target allocation: roughly 15%. This runs on the founder's own machine via our desktop app, not on our servers — different threat model entirely.
Tier 3 — Guided playbooks. Target allocation: roughly 5%. Deep-linked dashboard instructions with human review gates, for the last mile where no API exists.

Those percentages are design allocation, not measured. We are shipping the scaffolding this week; the real distribution will land over the next quarter as we grow coverage.

What shipped this week

The launch cut is honest about where we are. Three live API automations, two guided playbooks, fourteen BYOK providers wired into the credential layer.

Live automations (Tier 1):

Cloudflare MCP — DNS records, zone settings, page rules. Agents can configure a domain end-to-end.
Stripe MCP — customers, subscriptions, refunds, webhook endpoints. Your finance agent moves money with your token, not a stolen session.
Plausible API — create sites, read traffic, pull goal conversions. (Note: /api/v1/sites requires an Enterprise plan with a Sites API key — check your plan before wiring it up.)

Guided playbooks (Tier 3):

Hetzner — server provisioning, volume attach, firewall rules. Deep-linked into the Hetzner cloud console with a pre-filled config.
Resend — domain verification, API key issuance, send-test flow.

Credential layer (all tiers):

14 BYOK providers hooked into the credential store.
AES-256-GCM for data-at-rest, per-user HKDF-SHA256 key derivation. Your tokens, encrypted at rest, used by your agents. Each user's ciphertext is keyed to their own derived secret — a database leak does not yield usable credentials without the per-user material.

The PR was 1,685 lines across 15 files, added 20+ new tests, and shipped green against the existing suite. It is public, it is open source, and you can read every line.

Ready to try it?

Connect your repo at app.soleur.ai and let an agent provision your first service.

Why this matters if you are building alone

The hardest thing about being a solo founder is not the engineering. It is the other seventy percent — the vendor dashboards, the DNS flips at 11pm, the Stripe webhook you forgot to subscribe, the Plausible site you keep meaning to create for the new landing page.

Every one of those tasks is an API call. Every one of those API calls is something a well-briefed agent can handle, if — and only if — the agent has the credentials, the contract, and the authority.

Soleur's service automation gives the AI team all three. Credentials live in the encrypted BYOK layer. Contracts live in the MCP servers and playbook definitions. Authority lives in your repo — in the brand guide, the spec, the plan — where every agent reads from the same compounding knowledge base.

That last part is the lock-in break. An agent that can call Cloudflare for you is useful. An agent that can call Cloudflare for you and knows, from your brand guide, which domain owns which brand, and knows, from last week's learning file, that you always want Always Use HTTPS on — that is a teammate.

Why APIs compound and browsers do not

This is the same argument we made in why most agentic tools plateau, applied to a new surface.

A browser-based automation is a snowflake. Every site has its own DOM, its own auth flow, its own anti-bot heuristics. Every fix is a one-off. Nothing transfers.

An API-based automation is a contract. Once you have wrapped Stripe's API with agent-legible tools, the next agent that wants to issue a refund does not need to learn Stripe's dashboard — it needs to learn the contract, which is already documented, typed, and tested. The investment accrues.

That is what makes this release structurally different from the service-automation stories you see from browser-agent startups. We are not shipping a pile of scrapers. We are shipping a typed, tested, credentialed automation substrate that every agent in the organization can call the same way — from the marketing agent that wants to create a Plausible goal to the ops agent that wants to check a Hetzner firewall.

What it looks like from the founder's seat

The mental model we optimized for: the founder never touches a token file, never inspects a response header, never writes a retry loop. They say what they want in plain language. The AI team handles the rest.

A concrete example. You are launching a new landing page on a fresh subdomain. In a pre-automation world, that is a thirty-minute errand: open Cloudflare, add the CNAME, wait for propagation, open Plausible, create the site, copy the script tag, go back to the code, paste it, deploy, check analytics, realize the goal is not firing, go back to Plausible, create the goal. Eleven context switches.

In the post-automation world it is one sentence to your ops agent: "Spin up launch.soleur.ai, point it at the production app, and track signups as a conversion." The agent resolves the domain against your Cloudflare zone, creates the DNS record, waits for propagation, creates the Plausible site, records the site ID in your knowledge base, writes the goal configuration, and comes back with a verification checklist. You approve. It is done.

The time savings are real but secondary. The primary value is that the steps are now auditable and repeatable. Every decision the agent made is committed to your repo. The next time you launch a subdomain, the agent reads the prior run, applies the same configuration, and only stops to ask about the deltas. This is the compounding effect applied to vendor work — the same substrate that makes engineering work compound now applies to the rest of the company.

How this was built

For anyone interested in the architectural argument underneath the release: the full decision is written up as ADR-002 ("Three-Tier Service Automation") in the Soleur knowledge base. The short version is above. The long version walks through the CTO, CLO, and CFO objections to a server-side-browser design, the threat model we rejected, and the BYOK encryption scheme we adopted in its place. If you are building anything adjacent, it is worth reading as a template for "how to decide where agents get their hands dirty."

One rule we learned writing it: the moment you catch yourself saying "the agent will log in to the dashboard and…" — stop, and go find the API. In the rare case the vendor has no API, write a guided playbook and let the human keep the keys. Do not put a browser on your server.

What is next

Three live automations is a beachhead, not a platform. The roadmap from here:

Expand Tier 1 coverage: the shortlist is GitHub, Vercel, Supabase, and Mailchimp — all API-first, all natural fits for the MCP layer.
Ship the first Tier 2 integrations through the desktop app, for vendors whose highest-value workflows genuinely require a browser session (think "download this monthly CSV report" or "confirm a TOTP prompt").
Measure the actual tier distribution in production and report it. The 80/15/5 target needs real data behind it before we trust it.

If there is a vendor you want your AI team to handle, file it as an issue on the repo. We prioritize by founder pain, not vendor size.

Start here.

Connect your repo at app.soleur.ai and let an agent provision your first service.

Soleur vs. Devin: AI Software Engineer vs. AI Organization

2026-04-21T00:00:00Z

Devin is the price anchor for autonomous AI agents. Cognition Labs' AI software engineer handles long-horizon coding tasks -- writing code, running tests, fixing bugs, browsing documentation, and deploying software -- with a degree of autonomy that made it the reference point for what "AI doing real engineering work" means. At $20/month, it is accessible to every solo founder who codes.

The question is not whether Devin is impressive. It is whether an AI software engineer is what a solo founder actually needs.

Devin and Soleur both automate work that used to require human expertise and both fit into Claude Code-native workflows. But their scope reflects fundamentally different answers to one question: what problem is the solo founder actually trying to solve?

What Devin Actually Is

Devin is Cognition Labs' autonomous AI software engineer. It is designed for long-horizon software engineering tasks: given a problem statement or GitHub issue, Devin plans a solution, writes code, runs tests, debugs failures, reads documentation, and submits a pull request. It has its own browser, terminal, and code editor -- it operates as an autonomous engineer in a sandboxed environment.

Devin is purpose-built for software engineering and nothing else. It does not draft legal contracts, run competitive intelligence scans, build financial models, or plan marketing campaigns. It is an extraordinarily capable engineering resource constrained to engineering problems.

That constraint is deliberate. Cognition built Devin to do one job exceptionally well: write and ship production-quality software without hand-holding.

What Soleur Actually Is

Soleur is the Company-as-a-Service platform. 65 agents, 67 skills, and a compounding knowledge base organized across 8 business departments -- engineering, marketing, legal, finance, operations, product, sales, support, and community.

The engineering department contains what Devin provides in isolation: architecture design, code review, infrastructure provisioning, deployment, and security analysis. Soleur's engineering agents run inside the same Claude Code environment as the founder. They plan, implement, review, and ship alongside a legal agent that generates contracts, a marketing agent that writes copy and runs competitive analysis, a finance agent that models revenue, and a product agent that validates specs before engineering starts building them.

The compounding knowledge base is the structural difference. When Soleur's product agent completes a competitive analysis, the marketing agents read it. When the legal agent documents a compliance requirement, the engineering agents reference it before building the relevant feature. When the brand-architect agent writes the brand guide, every piece of copy the marketing agents generate afterward reflects it. Knowledge does not live in silos -- it accumulates across domains and every decision becomes institutional memory.

The Core Distinction: One Department vs. Nine

Devin solves the engineering hiring problem. A solo founder who needs engineering output -- and does not want to hire engineers -- has a credible option at $20/month. For companies that are genuinely engineering-only problems, this is the right calculation.

The problem most solo founders face is not that they need to write more code. It is that they are simultaneously the CEO, CTO, CMO, CLO, CFO, COO, CPO, and VP of Sales. Devin cannot write the privacy policy that the engineering agent needs to reference. It cannot run the competitive analysis that should precede the product roadmap. It cannot draft the fundraising summary that follows the financial model. And it cannot remember that the legal agent determined last month that a particular data-handling approach creates regulatory exposure -- because Devin has no cross-domain knowledge base.

Building a billion-dollar company requires solving all nine problems, not optimizing one of them.

Where They Differ

Scope

Devin: software engineering, exclusively.

Soleur: 8 departments. Engineering is one of nine. The marketing, legal, finance, operations, product, sales, support, and community domains receive the same depth of specialist coverage as engineering.

The three domains that carry the highest downside risk for a solo founder -- legal, finance, and product strategy -- are absent from Devin's scope entirely. A missed compliance requirement, a flawed financial model, or a product roadmap that ignores competitive dynamics can make the engineering investment worthless.

Autonomy Model

Devin operates as an autonomous engineer. It receives a task and executes it independently, surfacing results when complete. The founder reviews the output, not the process.

Soleur's lifecycle -- brainstorm → plan → implement → review → compound -- is structured around decision gates, not autonomous cycles. The plan is visible before implementation starts. The review happens before anything ships. The founder provides judgment at every gate; agents handle execution. This is not a constraint -- it is an architecture designed for decisions where the cost of wrong is high.

Knowledge Persistence

Devin's context window ends at the session. It does not accumulate institutional memory about your company, your codebase's architectural decisions, or the reasoning behind past technical choices. Each new task starts from the current state of the repository, not from a compounding body of organizational knowledge.

Soleur's compound step captures what was decided and why at the end of every session. Engineering decisions become architectural learnings. Legal edge cases become compliance guardrails. Competitive intelligence updates become product strategy inputs. The knowledge base is a git-tracked directory of Markdown files -- readable, auditable, and editable by the founder directly -- that compounds with every session across every domain.

The first time Soleur's engineering agents tackle a problem, they work from what exists. The twentieth time, they reference 19 sessions of architectural context, past decisions, and established patterns. The engineering gets better. So does everything else.

Pricing

Devin: $20/month subscription.

Soleur: open-source, free platform. Your costs are the Claude API credits the agents consume.

The pricing comparison is less straightforward than the headline numbers suggest. Devin at $20/month is a subscription for engineering output. Soleur's costs scale with usage -- a company running extensive agent sessions will spend more on Claude API than $20/month. The open-source model is lower cost for founders starting out; the total cost of Soleur depends on session volume at scale.

The more material pricing consideration: Devin covers one of nine departments a solo founder needs to run. Replacing all nine with separate specialized tools -- an AI coding agent, an AI legal tool, an AI finance tool, an AI marketing tool -- costs orders of magnitude more and produces no cross-domain coherence. Soleur covers all nine in a single platform.

How Each Fits Into the Workflow

A solo founder using Devin writes a spec, hands it to Devin, and reviews the pull request. Devin handles the coding work between spec and PR.

A solo founder using Soleur starts a session: brainstorm the spec with the product agent, plan the implementation with the engineering architect, implement with the engineering agents, review with the code review agents, ship with the workflow agents, and capture learnings with the compound step. Parallel to engineering, the marketing agents are running a content calendar, the legal agents are reviewing the new feature for compliance, and the finance agents are updating the revenue model based on the new feature's expected impact.

The engineering output from Soleur's agents is comparable in quality to what Devin delivers on well-specified tasks. The difference is what surrounds the engineering output: the product strategy that preceded it, the legal review that runs alongside it, the marketing content that ships with it, and the institutional memory that captures it afterward.

The $20/Month Framing Problem

Devin at $20/month is often framed as the baseline cost for "AI that does real work." This framing obscures what Devin actually replaces: one engineer working on one category of problem.

Running a company requires nine categories. At $20/month for the engineering layer, the question becomes: what do the other eight cost? If the answer is "the founder's time," the $20/month number dramatically understates the real cost of the current stack.

The relevant comparison is not Devin at $20/month versus Soleur at $0/month. It is whether an engineering-only tool solves the problem the founder actually has.

When Devin Is the Right Choice

Devin is the right choice for founders whose bottleneck is engineering velocity. If you have a validated product, a clear roadmap, legal and financial infrastructure already in place, and the remaining constraint is writing and shipping code faster, Devin's autonomous engineering capability at $20/month is a strong option.

It is also the right choice if your company is a pure software engineering problem with no meaningful marketing, legal, or financial complexity. Some companies genuinely are -- developer tools, infrastructure products, and technical SaaS built by a single founder for a technical audience can run with minimal non-engineering overhead for extended periods.

When Soleur Is the Right Choice

Soleur is the right choice when the bottleneck is not just engineering velocity. When the missing piece is legal strategy that informs engineering decisions, a financial model that shapes the product roadmap, or marketing that reflects competitive positioning -- not just code that ships faster -- an engineering-only tool addresses the wrong problem.

Solo founders building companies where brand precision, legal compliance, financial planning, and product strategy are differentiators cannot route all complexity through an engineering tool. The first billion-dollar solo company will not be built by accelerating engineering in isolation. It will be built by a founder whose judgment is amplified across every domain -- where every decision builds institutional memory, and every new session benefits from everything the company has learned.

If the company you are building requires more than engineering, Soleur covers the full stack. Devin does not.

What you need	Devin	Soleur
Autonomous software engineering	Yes	Yes
Long-horizon coding tasks	Yes	Yes
Sandboxed browser and terminal access	Yes	Partial
Pre-built domain agents (legal, marketing, finance)	No	Yes
Cross-domain compounding knowledge base	No	Yes
Workflow lifecycle (brainstorm through ship)	No	Yes
Human-in-the-loop decision gates	No	Yes
Open-source and local-first	No	Yes
Pricing	$20/month	Free (API costs)

FAQ

Q: Can Devin and Soleur be used together?

Yes. Devin and Soleur are not mutually exclusive. A founder could use Soleur for the full organizational workflow -- planning, product strategy, legal, finance, marketing -- while delegating specific long-horizon coding tasks to Devin as the execution layer for well-scoped engineering problems. Soleur's compound step would capture the architectural decisions Devin's implementation surfaces, feeding them back into the organization's knowledge base.

Q: Devin is described as an AI software engineer. Is it comparable to Soleur's engineering agents?

For pure coding velocity on well-specified tasks, Devin is purpose-built for autonomous execution of long-horizon engineering work. Soleur's engineering agents operate as part of a larger organizational workflow with access to cross-domain context -- product specs, legal requirements, brand guidelines -- that Devin's isolated engineering context does not include. Which is better depends on whether the engineering work benefits from that cross-domain organizational context.

Q: Why does Soleur cover eight domains? Isn't most of what a technical solo founder needs engineering?

Engineering is the most visible 30% of running a company. The other 70% -- legal compliance, financial planning, marketing, customer support, product strategy, sales, and operations -- determines whether the engineering investment produces a company. Technical founders underweight non-engineering domains because those are the domains they are least comfortable with. Soleur covers all eight precisely because the painful constraints for most technical solo founders live outside engineering, not inside it.

Q: What is the "autonomous coding comparison" between Devin and Soleur?

Devin specializes in autonomous execution of coding tasks in a sandboxed environment with browser, terminal, and editor access -- receive a task, produce a pull request. Soleur's engineering agents run in the founder's actual development environment with access to the full organizational knowledge base: they plan before implementing and review before shipping, integrating engineering decisions with broader company context. Devin optimizes for engineering throughput on isolated tasks; Soleur optimizes for organizational coherence across all eight domains.

The One-Person Billion-Dollar Company: Why It's an Engineering Problem

2026-04-21T00:00:00Z

The first billion-dollar company run by one person is not a thought experiment. It is a prediction with a timeline.

Dario Amodei, CEO of Anthropic, predicted that a one-person billion-dollar company would emerge as soon as 2026. Sam Altman described an informal betting pool among tech executives for "the first year that there is a one-person billion-dollar company." TechCrunch reported on the mechanism: AI agents extending beyond engineering into every function a company needs.

These are not idle predictions. They describe a structural shift in what it costs to run a company.

Why a Billion-Dollar Company Historically Required Hundreds of People

The reason billion-dollar companies required large headcounts was not ambition. It was coordination.

Building at scale requires eight distinct functions: engineering, marketing, legal, finance, operations, product, sales, and support. Each requires domain expertise. Each generates decisions. And every decision in one domain constrains every other domain — the legal strategy limits marketing campaigns, the financial model drives the product roadmap, the engineering architecture defines operational complexity.

For most of the history of business, the only way to hold all that context in one place was to have people who talked to each other. An organization was, at its core, a coordination system. The more functions you needed, the more people you hired. The headcount scaled with the company's surface area.

AI tools compressed the individual task. A coding assistant writes code faster. A contract template saves legal fees. A copywriting tool drafts faster. But these are speed improvements on isolated tasks. They do not solve the coordination problem. The decision the legal tool produced still does not reach the marketing tool. The insight the engineering agent generated still disappears when the session ends.

Point solutions made solo founders faster. They did not make them organizations.

What Changes the Math

The bet on the one-person billion-dollar company is not a bet on better tools. It is a bet on a different architecture.

The architecture is compound knowledge: a knowledge base that captures every decision across every domain and routes it to every agent that needs it. Marketing agents read what legal decided. Engineering agents reference what product specified. Finance agents update the model when sales closes a deal. No founder relay required.

When knowledge compounds, two things change.

First, coordination costs drop to near zero. The founder's job shifts from manually carrying context between domains to making decisions within a system that already knows the context. This is the function headcount has always performed — holding organizational memory — done by the knowledge base instead.

Second, every task makes the system more capable. The first time the legal agent drafts a contract, it works from general principles. The twentieth time, it works from 19 sessions of company-specific requirements, established positions, and accumulated edge cases. The marketing agents that have observed 12 months of brand guide evolution write with a precision that no fresh context window can match.

The compound effect means the one-person company does not plateau where point solutions do. It scales.

The Organizational Model

Company-as-a-Service is the structure that makes this concrete. Not a set of AI tools, but a full AI organization: specialist agents for each domain, coordinated by a shared knowledge base, operated by one founder who makes decisions and delegates execution.

Kuo Zhang, President of Alibaba.com, wrote in Fortune that agentic AI is dismantling the "Execution Wall" that previously separated solo entrepreneurs from large corporations — absorbing administrative complexity, compressing supplier negotiations and logistics coordination, and shifting competitive advantage from resources and headcount to judgment, taste, and strategic vision. The constraint was never the founder's capability. It was the cost of coordination at the boundaries between functions.

Remove the coordination cost. Keep the founder's judgment. The result is a company that behaves like an organization of hundreds — because every domain has specialist coverage, every decision is captured, and every subsequent session starts from a more informed baseline.

In practice, this means:

An engineering agent that reviews pull requests against legal constraints, brand guidelines, and product specifications — simultaneously, without the founder acting as relay
A marketing agent that reflects the latest competitive intelligence and brand strategy when drafting copy, because both live in the same knowledge base
A financial model that updates when the sales pipeline moves, the engineering velocity changes, or the product roadmap shifts
A legal agent that flags when a new product feature touches a compliance requirement documented in a prior session

Each of these is a solo founder operating at team scale — not because they are working faster, but because the system they are working within holds the coordination that used to require a team.

The Leverage Inflection Point

There is a phase change between "AI making a solo founder faster" and "AI enabling a solo founder to run a company."

The phase change happens at compound knowledge. Before it, the founder is still the relay. After it, the system carries the context and the founder carries the judgment.

The supply side of this shift is visible in the data: solo-founded startups have risen from 23.7% to 36.3% of all new ventures between 2019 and the first half of 2025, according to Carta's Solo Founders Report — the first time solo founding has reached this scale in over 50 years of startup formation. The infrastructure enabling this shift is not just productivity tools. It is the emergence of systems that can hold organizational memory across domains.

The founders who reach billion-dollar scale from a single person will not be the ones with the best prompts. They will be the ones whose organizations remember the most, connect the most, and improve the most reliably between sessions.

The first hundred sessions are learning the company. The next hundred sessions are operating the company. The third hundred sessions are scaling the company. The founder's input is required at each stage — but what that input is changes as the knowledge base deepens.

What It Requires

The one-person billion-dollar company is not automatic. It requires three things from the founder:

A commitment to building the knowledge layer. The system cannot compound knowledge that was never captured. Every architectural decision, brand choice, legal position, and pricing model that lives only in the founder's head is a coordination bottleneck waiting to be a crisis. The discipline of capturing decisions — in the format agents can read and build on — is the foundation everything else rests on.

A lifecycle, not a prompt. The founders who plateau at point solutions are using AI transactionally: here is a task, here is a response, done. The founders who build compound organizations treat each task as a step in a lifecycle — brainstorm, plan, implement, review, and compound. The compound step is not optional. It is what makes the next session better than this one.

Judgment at every gate. The system executes. The founder decides. This is the design. Human-in-the-loop decision gates are not a concession to AI limitations — they are the architecture that lets a single person exercise judgment across all nine domains without being overwhelmed by execution. The founder who stays in the judgment role rather than the execution role is the founder who can actually manage a nine-department organization alone.

The Competitive Window

The one-person billion-dollar company is not a permanent opportunity. It is a window.

The companies that build compound AI organizations in the next two to three years will operate with structural advantages that cannot be closed by adding headcount. Their knowledge bases will be deeper, their agents more specialized, and their compounding cycles will have had more time to run. A well-funded team of 50 hired in 2028 will not quickly replicate the institutional memory an AI organization built over three years of compounding decisions.

The window is the time before every company has this capability. Today, most companies are still using point solutions. The coordination cost is still a moat — but in reverse. The founders who close the coordination gap first do not just compete with traditional companies. They compete differently. And the gap compounds.

Getting Started

The path to a compound AI organization begins with one decision: what does your knowledge layer contain today?

For most solo founders, the answer is: less than you think. Brand decisions exist in your head. Legal positions were resolved and forgotten. Engineering choices were made without documentation. The first work of building a compound organization is excavation — surfacing what the company already knows and putting it in a form agents can read.

Then the lifecycle begins: brainstorm with context, plan with constraints, implement with review, compound with every session. Not faster individual tasks. A better organization every month.

The first billion-dollar company built by one person will not be built by working harder. It will be built by an organization that compounds — and the founder who built it started before the window closed.

Start building →

FAQ

Is a one-person billion-dollar company actually possible?

The prediction comes from credible sources at the highest levels of the AI industry. Dario Amodei predicted it would emerge as soon as 2026. Sam Altman described an informal executive betting pool for the first year it happens. Kuo Zhang of Alibaba.com wrote that agentic AI is dismantling the Execution Wall that historically required large teams. The mechanism is structural, not motivational: compounding AI organizations that hold cross-domain context eliminate the coordination cost that previously required hundreds of people.

What is compound knowledge and why does it matter?

Compound knowledge is what happens when every AI task generates a learning that routes back into the system. Legal decisions become constraints the engineering agents reference. Brand choices become rules the marketing agents follow. Each session starts from a more informed baseline than the last. The result is an organization that improves structurally with every task, not just an individual who works faster. Without compound knowledge, AI tools plateau at the level of faster individual work. With it, they scale to the level of a coordinated organization.

How is this different from using a collection of AI tools?

Point solutions are stateless. They begin fresh with each session, in each domain, without knowledge of what other tools decided. A collection of AI tools does not produce cross-domain coordination. A compound AI organization does. The legal agent knows what the marketing agent published. The engineering agent knows what the product agent specified. When that coordination happens in the knowledge base rather than the founder's head, the founder can operate at organizational scale.

How long does it take to build a compound AI organization?

The first sessions establish the knowledge layer — capturing existing decisions, constraints, and context. The compounding begins immediately: each session generates learnings that improve the next. The practical horizon is 60-90 days to a functional multi-domain organization, and 6-12 months to a deeply compounded one where the system's accumulated knowledge represents a meaningful structural advantage. The earlier you start, the deeper the advantage before the window closes.

What does the founder actually do in a one-person company run by AI?

The founder makes decisions and the system executes them. Every domain has a lifecycle: brainstorm, plan, implement, review, compound. The founder provides judgment at each gate — defining objectives, approving plans, reviewing outputs, resolving tradeoffs. The agents handle research, drafting, implementation, and review. This is not passive ownership. It is active decision-making across nine domains without execution overhead. The skill that matters most is the quality of the decisions, not the speed of execution.

Soleur vs. Paperclip: Domain Intelligence vs. AI Company Orchestration

2026-03-31T00:00:00Z

Paperclip reached 14,600+ GitHub stars with a straightforward premise: give AI agents an org chart, a budget, a schedule, and governance controls, and they can run a company without humans. Zero-human company orchestration, MIT-licensed, self-hosted. The traction is real. The category framing is direct.

Soleur and Paperclip both target the same destination -- a company that operates with minimal human overhead -- but they approach it from opposite ends of the stack.

Paperclip is infrastructure. It tells agents when to run, how much to spend, who reports to whom, and what to do when something goes wrong. It does not tell agents what to know, how to reason about legal risk, or what makes a good marketing strategy. You bring your own agents and domain logic.

Soleur is intelligence. 65 agents, 67 skills, and a compounding knowledge base across 8 departments -- engineering, marketing, legal, finance, operations, product, sales, and support. Every agent carries domain knowledge. Every session makes the system smarter. The orchestration is the workflow lifecycle: brainstorm → plan → implement → review → compound.

Neither platform is complete without what the other provides. Understanding what each actually solves is the first step to knowing which one belongs in your stack -- or whether you need both.

What Paperclip Actually Is

Paperclip is an open-source orchestration platform for zero-human companies. It is agent-runtime-agnostic: connect Claude, Cursor, OpenCode, Codex, Bash, or HTTP webhooks. As of v0.3.0, it supports adapters for Cursor, OpenCode, and Pi alongside the original runtime targets.

The feature set is built around governance infrastructure:

Org charts with reporting lines -- tasks cascade from company mission down to individual agent objectives, following the defined hierarchy
Heartbeat scheduling -- agents run on defined cadences, triggered by the platform rather than requiring user prompts
Per-agent monthly budgets -- each agent has a spending ceiling; exceeding it triggers automatic pausing
Governance with rollback and approval gates -- changes require approval before execution and can be rolled back afterward
Immutable audit logs -- every action is recorded and cannot be altered retroactively
Multi-company support -- manage multiple companies from a single instance

The upcoming Clipmart feature extends this with downloadable pre-built company templates: full org structures and agent configurations for marketing companies, e-commerce operations, software development, sales organizations, and media. The idea is to lower the setup barrier for "zero-human company" creation.

What Paperclip does not provide: agents. Domain knowledge. Opinions about what a legal agent should know, how a competitive intelligence scan should be structured, or why the brand guide the marketing agent creates should inform the content strategy the growth agent executes. Paperclip is a runtime for agents you define. It enforces constraints and routes work. The intelligence is your responsibility.

What Soleur Actually Is

Soleur is the Company-as-a-Service platform. 65 agents, 67 skills, and a compounding knowledge base organized across 8 business domains. Each domain has a director-level leader and specialist agents: the CMO orchestrates brand architects, SEO specialists, and growth researchers; the CLO manages legal document generation and compliance auditing; the CTO oversees engineering research, code review, architecture design, and deployment.

These agents do not operate in silos. They share a git-tracked knowledge base -- a directory of structured Markdown files -- that accumulates institutional memory with every session. The brand guide the brand-architect writes informs what the content writer generates. The competitive intelligence scan the CPO runs updates the sales battlecards the deal-architect uses. The legal compliance audit references the privacy policy the CLO previously documented. Knowledge flows across domains because every agent reads from and writes to the same base.

The orchestration model is the compound workflow lifecycle: brainstorm → plan → implement → review → compound. The compound step is what separates Soleur's approach architecturally: learnings from each session are routed back to the specific agents and workflows that were active, and critical failure patterns are promoted to mechanical enforcement hooks -- code-level guardrails that make known failure modes structurally impossible.

Soleur runs inside Claude Code. It is open-source and local-first: your knowledge base lives in your repository, your agents run in your environment, your credentials stay under your control.

The Core Distinction: Infrastructure vs. Intelligence

Paperclip solves the governance problem: how do you control autonomous agents operating without human oversight? Budget caps, approval gates, rollback capabilities, org hierarchy, and audit trails are the answer. These are genuine problems. Autonomous agents without constraints burn money and make irreversible decisions. Paperclip's feature set directly addresses this.

Soleur solves the knowledge problem: what should agents actually know and do? A marketing agent that does not understand brand voice, competitive positioning, and SEO strategy will produce content. Whether that content is good is a different question entirely. A legal agent without knowledge of the company's regulatory context will generate documents. Whether those documents are accurate and appropriately protective depends on domain depth that cannot be scaffolded from an org chart.

The gap in Paperclip's model is real: with 14,600 GitHub stars and no pre-built domain agents, the majority of setup time goes to defining agent behavior rather than extracting value from it. Clipmart will lower this barrier with company templates, but pre-built org structures still require users to fill in the actual domain intelligence -- the reasoning, the institutional context, the quality standards.

The gap in Soleur's model is equally real: the workflow lifecycle is purpose-built for Claude Code sessions initiated by a human. It does not offer Paperclip's heartbeat scheduling (agents running on autonomous cron cadences), per-agent budget enforcement, or multi-company governance. These are problems Soleur has not solved. Paperclip has.

The Compounding Difference

The deepest distinction between the two platforms is not which features appear in each list. It is whether the system gets smarter with use.

Paperclip tracks tasks, budgets, and audit logs. This produces valuable operational data. It does not feed back into agent behavior. An agent that exceeded its budget and was automatically paused does not learn from the experience. The governance layer enforces rules it was given; it does not discover new rules through operation.

Soleur's compound step changes this. From the project's engineering log:

An AI agent edited files outside its designated workspace. Two hours of work disappeared. The failure triggered a four-stage response: documentation, governance rule, enforcement hook, routing. The system can never make that mistake again.

The four-stage arc -- incident → rule → code-level guard → structural prevention -- has repeated across dozens of failure classes. The project's governance document started at 26 rules. It now contains 200+, each triggered by a real incident. When an agent makes a mistake, the compound step ensures neither that agent nor any agent will make it again. The knowledge base does not just record history -- it changes behavior.

Paperclip's rollback capabilities address damage after it occurs. Soleur's compound architecture prevents the damage by making recurrence structurally impossible. Both approaches are valuable; they operate at different points in the failure lifecycle.

What you need	Paperclip	Soleur
Governance and budget controls	Yes	Partial
Heartbeat scheduling (autonomous cron)	Yes	No
Rollback and approval gates	Yes	No
Pre-built domain agents	No	Yes
Compounding cross-domain knowledge base	No	Yes
Self-improving rules and guardrails	No	Yes
Workflow lifecycle (brainstorm through ship)	No	Yes
Open-source and local-first	Yes	Yes
Multi-company support	Yes	No

When Paperclip Is the Right Choice

Paperclip is the right choice when you need autonomous agent governance: the ability to run agents on schedules without user prompts, with defined budget ceilings and rollback controls. If you are building a zero-human company where agents operate continuously -- marketing agents posting on cadence, data agents refreshing reports overnight, operations agents monitoring spend -- Paperclip provides the governance layer that makes continuous autonomous operation safe.

If you already have domain agents -- built on Claude, Cursor, or another runtime -- and need orchestration infrastructure around them, Paperclip's org chart model and adapter ecosystem are a faster path than building governance from scratch.

Clipmart, when it ships, will make Paperclip more accessible for founders without existing agent libraries: downloadable company templates for marketing, e-commerce, software development, and other verticals. The quality of those templates will determine how much domain intelligence comes pre-built versus how much founders still need to supply.

When Soleur Is the Right Choice

Soleur is the right choice when the quality of what agents produce matters as much as the fact that they run.

A competitive intelligence scan that misses new entrants is worse than no scan. A legal compliance audit that cites outdated regulations creates false confidence. A content strategy that ignores brand positioning produces noise. These are not problems that governance controls solve -- they are problems that require domain depth, institutional memory, and the kind of cross-domain coherence that only compounds over time.

Solo founders building companies where legal, financial, and product strategy decisions carry real stakes cannot delegate those decisions to autonomous cycles and expect competitive-quality output. Soleur's 8-domain coverage includes the three domains Paperclip's comparable tools most commonly omit: legal, finance, and product strategy -- precisely because those domains require careful human-in-the-loop review, not autonomous execution.

If you work in Claude Code, want a full AI organization that accumulates knowledge about your specific business, and want every decision to make subsequent decisions better, Soleur's compound architecture is built for that use case.

Using Both

The complementary case is direct: Soleur provides domain intelligence; Paperclip provides governance infrastructure. Soleur's 65 agents could run within Paperclip's orchestration framework -- heartbeat-scheduled, budget-capped, with rollback controls -- while contributing to a compounding knowledge base that Paperclip's governance layer does not supply.

Paperclip's adapter model demonstrates this is architecturally feasible. v0.3.0 added adapters for Cursor, OpenCode, and Pi. A Soleur adapter would extend this pattern: Soleur's agents run as managed workers within Paperclip's org chart, governed by Paperclip's budget and scheduling controls, while the compound step continues building cross-domain institutional memory after each session.

An official Soleur adapter for Paperclip does not yet exist. The combination represents the most complete zero-human company stack either platform could offer.

FAQ

Q: Is Paperclip a competitor to Soleur?

Partially. Both target the AI company category, but they operate at different layers of the stack. Paperclip is governance infrastructure: org charts, budget controls, scheduling, rollback, audit logs. Soleur is domain intelligence: purpose-built agents, compounding knowledge base, workflow lifecycle. The most accurate framing is complementary -- Paperclip governs how agents run; Soleur defines what agents know and do. Direct competition begins if Clipmart ships company templates with deep, compounding domain intelligence, or if Soleur adds autonomous scheduling and budget enforcement.

Q: Does Paperclip include domain agents for legal, marketing, or finance?

No. Paperclip is agent-runtime-agnostic and does not include pre-built domain agents. It supports Claude, Cursor, OpenCode, Codex, Bash, and HTTP webhooks, but you supply your own agents and domain logic. The upcoming Clipmart feature will provide org structure templates for specific verticals, but the agents and their domain intelligence remain user-defined.

Q: What is zero-human company orchestration?

Zero-human company orchestration describes systems designed to run business operations autonomously -- agents handling scheduling, task execution, and decision-making without human intervention between cycles. Paperclip is built explicitly for this model, with heartbeat scheduling, approval gates, and budget controls to make continuous autonomous operation safe. Soleur takes a founder-in-the-loop approach: agents execute fully, but the founder makes decisions at key workflow gates rather than receiving a summary after the fact.

Q: Can Soleur and Paperclip be used together?

Yes. Soleur's domain agents could run as managed workers within Paperclip's orchestration framework, gaining heartbeat scheduling, per-agent budget controls, and rollback governance while contributing to the compounding knowledge base that Paperclip does not supply. An official adapter does not yet exist, but Paperclip's v0.3.0 adapter pattern (Cursor, OpenCode, Pi) makes this architecturally straightforward. The combination would represent the most complete open-source, self-hosted zero-human company stack available.

Q: What are the main open-source AI company platforms in 2026?

The two most prominent open-source, self-hosted platforms for AI company operation are Paperclip (MIT license, 14,600+ GitHub stars, governance infrastructure layer) and Soleur (open-source, 65 agents, domain intelligence layer). Polsia is the fastest-growing proprietary alternative -- $1.5M ARR with 2,000+ managed companies as of March 2026 -- but is cloud-hosted, closed-source, and fully autonomous by design.

Your AI Team Now Works From Your Actual Codebase

2026-03-29T00:00:00Z

Every AI development workflow has the same failure mode: the agent starts with a blank workspace. It does not know your architecture, your brand voice, your legal constraints, or what you shipped last week. You brief it from scratch every session. The context you build evaporates when the session ends.

Soleur agents now operate on your actual codebase. Connect your GitHub repository during onboarding, and every agent conversation starts with full project context — your decisions, your patterns, what you have built so far.

What Changed

The onboarding flow now includes a repository connection step. You have three options:

Connect an existing project. If you already have code on GitHub, install the Soleur GitHub App, select your repository, and your workspace is provisioned with your code. Your AI team reads your knowledge base, brand guide, specifications, and learnings from the first conversation.

Start fresh. If you are pre-code or starting a new venture, Soleur creates a private repository under your GitHub account. The workspace scaffolds a knowledge base structure from day one — brainstorms, specs, plans, and learnings directories ready for your first session.

Skip for now. Repository connection is optional. You can connect later from Settings.

The entire flow is designed for founders who may not be technical. Plain language, no jargon, clear explanations of what each step does and why.

How It Works

When you connect a repository, Soleur installs a GitHub App on your account. The app requests permission to read and manage your project files — nothing else. Your code stays in your GitHub account, under your control.

Behind the scenes:

Session start: Your workspace pulls the latest changes from your repository. If your team (or another agent) pushed changes since your last session, you get them automatically.
Session end: Any changes your AI team made — new specifications, updated brand guide, generated legal documents — are pushed back to your repository.
Sync is best-effort. A failed sync never blocks your session. If something goes wrong, the next session retries. Your work is never interrupted by a network hiccup or a merge conflict.

Authentication uses short-lived GitHub App installation tokens that expire after one hour. No long-lived credentials are stored in your workspace. The AI team accesses your repository through secure, scoped tokens that you can revoke at any time.

The Compounding Effect

Repository connection is not a convenience feature. It is the infrastructure that makes compound knowledge work in practice.

Every Soleur session produces artifacts: brainstorm documents capture design decisions. Plans encode implementation strategy. Learnings record what worked and what did not. Legal agents generate compliance documents. Marketing agents produce content briefs. All of these accumulate in your knowledge base.

Without repository connection, these artifacts exist only in a temporary workspace. They vanish when the session ends. With repository connection, they persist in your GitHub repository. The next session reads them. The session after that builds on them. Your AI team's institutional memory compounds across every conversation, every domain, every decision.

This is the difference between an AI that forgets and an AI team that learns.

What This Means for Your Workflow

Before repository connection, a typical Soleur session started with context-setting. You explained what you were building, what you had decided, what constraints applied. The AI team was capable but amnesiac.

Now, a typical session starts with the AI team already knowing:

Your project architecture and codebase
Your brand voice and messaging guidelines
Your legal documents and compliance requirements
Your product roadmap and strategic priorities
Every decision you have made in previous sessions

The founder's role does not change. You still make every decision. You still approve every output. But the starting point is different. Your AI team begins where the last session ended, not from zero.

Getting Started

New users see the repository connection flow during onboarding. Existing users can connect a repository from Settings.

The feature is live now. No waitlist, no beta, no pricing change. Repository connection is part of the Soleur open-source platform.

Q: Does Soleur access my private repositories?

The Soleur GitHub App accesses only the repositories you explicitly select during installation. You choose which repositories to grant access to, and you can modify or revoke that access at any time from your GitHub settings.

Q: What happens if I disconnect my repository?

Your workspace continues to function with the code and knowledge base already provisioned. You lose automatic sync — changes will not pull or push until you reconnect. No data is deleted.

Q: Can I use Soleur without connecting a repository?

Yes. Repository connection is optional. You can skip it during onboarding and connect later, or use Soleur with a standalone workspace. The AI team works in both modes — repository connection adds persistence and compounding across sessions.

Q: What if I do not have a GitHub account?

The onboarding flow requires a GitHub account for repository connection. If you choose "Start Fresh," Soleur creates the repository under your GitHub account. GitHub offers free accounts with unlimited private repositories.

Q: Is my code sent to third parties?

Your code stays in your GitHub account and in your local Soleur workspace. Soleur agents read your codebase to understand context. The code itself is processed by Anthropic's Claude models under their data retention policies. No code is stored on Soleur servers or shared with other parties.

Credential Helper Isolation: Secure Git Auth in Sandboxed Environments

2026-03-29T00:00:00Z

Sandboxed AI agents need to push and pull from git repositories. The agent runs in a constrained environment. It must not hold long-lived credentials. It must not be able to access repositories beyond its scope. And the authentication mechanism must be invisible to the agent — no interactive prompts, no manual token entry, no environment variable leakage.

This is the credential helper isolation pattern we built for Soleur's repository connection feature.

The Problem

A Soleur agent session needs to:

Pull the latest changes from the user's GitHub repository at session start
Push any changes the agent made at session end
Do both without storing credentials in the workspace, the environment, or any file the agent can read

The standard approaches fail in this context:

Personal Access Tokens (PATs) are long-lived, user-scoped, and grant access to every repository the user owns. A leaked PAT in a sandboxed environment is a full-scope credential compromise. PATs also require the user to generate and manage tokens manually — a friction point for non-technical founders.

Deploy keys are repository-scoped but SSH-based, require key pair management, and cannot be rotated programmatically. They also grant permanent access until manually revoked.

OAuth tokens require an interactive browser flow that cannot run inside a headless agent session. The token refresh cycle adds complexity without solving the scope problem.

GitHub App installation tokens are the right fit: automatically scoped to the repositories the user selected during app installation, expire after one hour, and can be generated programmatically from a server-side JWT.

The Credential Helper Pattern

Git supports custom credential helpers via the GIT_ASKPASS environment variable or the credential.helper configuration option. A credential helper is any executable that outputs username and password lines when git needs authentication.

The pattern:

Generate a short-lived GitHub App installation token on the server
Write a temporary shell script that echoes the token as git credentials
Pass the script path to git via -c credential.helper=!<path>
Run the git operation (clone, pull, or push)
Delete the credential helper in a finally block

Here is the credential helper writer from session-sync.ts:

function writeCredentialHelper(token: string): string {
  const helperPath = randomCredentialPath();
  writeFileSync(
    helperPath,
    `#!/bin/sh\necho "username=x-access-token"\necho "password=${token}"`,
    { mode: 0o700 },
  );
  return helperPath;
}

The x-access-token username is GitHub's convention for installation token authentication. The shell script is executable (0o700) and owned by the process user.

The cleanup is unconditional:

function cleanupCredentialHelper(helperPath: string): void {
  try {
    unlinkSync(helperPath);
  } catch {
    // Best-effort cleanup
  }
}

Every git operation wraps the credential lifecycle in a try/finally:

let helperPath: string | null = null;
try {
  const token = await generateInstallationToken(installationId);
  helperPath = writeCredentialHelper(token);

  execFileSync("git", [
    "-c", `credential.helper=!${helperPath}`,
    "pull", "--no-rebase", "--autostash",
  ], { cwd: workspacePath, stdio: "pipe", timeout: 60_000 });
} catch (err) {
  log.warn({ err, userId }, "Sync pull failed — continuing with local state");
} finally {
  if (helperPath) cleanupCredentialHelper(helperPath);
}

The credential helper exists on disk for the duration of the git operation — seconds for pulls and pushes, up to two minutes for initial clones. After the finally block, the token is gone.

Security Hardening

Randomized paths prevent symlink attacks

If the credential helper path were predictable (e.g., /tmp/git-credentials), an attacker with write access to /tmp could plant a symlink before the helper is written. The writeFileSync call would follow the symlink and overwrite the target file, or the attacker could read the token from the known path.

The path uses crypto.randomUUID():

export function randomCredentialPath(): string {
  return `/tmp/git-cred-${randomUUID()}`;
}

The UUID is generated by Node's crypto module, which uses the operating system's cryptographic random number generator. The path is unpredictable — an attacker cannot race the write.

UUID validation prevents path traversal

Every function that takes a userId parameter validates it against a UUID regex before constructing file paths:

const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

if (!UUID_RE.test(userId)) {
  throw new Error(`Invalid userId format: ${userId}`);
}

const workspacePath = join(getWorkspacesRoot(), userId);

Without this check, a userId of ../../etc would construct a workspace path outside the expected directory. The UUID regex enforces that userId contains only hex characters and hyphens — no path separators, no dots, no special characters.

Token expiry limits blast radius

GitHub App installation tokens expire after one hour. The token cache adds a five-minute safety margin:

const TOKEN_SAFETY_MARGIN_MS = 5 * 60 * 1000;

const cached = tokenCache.get(installationId);
if (cached && cached.expiresAt > Date.now() + TOKEN_SAFETY_MARGIN_MS) {
  return cached.token;
}

If a token leaks despite the randomized paths and immediate cleanup, the exposure window is at most 55 minutes. Compare this to a PAT, which has no expiry by default.

GitHub App JWT Flow

Installation tokens are exchanged from a JWT signed with the GitHub App's private key. The JWT is built with Node's crypto module — no external JWT library:

function createAppJwt(): string {
  const now = Math.floor(Date.now() / 1000);
  const header = { alg: "RS256", typ: "JWT" };
  const payload = {
    iss: getAppId(),
    iat: now - 60,   // Clock skew tolerance
    exp: now + 10 * 60, // 10-minute JWT lifetime
  };

  const headerB64 = base64url(Buffer.from(JSON.stringify(header)));
  const payloadB64 = base64url(Buffer.from(JSON.stringify(payload)));
  const signingInput = `${headerB64}.${payloadB64}`;

  const signer = createSign("RSA-SHA256");
  signer.update(signingInput);
  signer.end();
  const signature = base64url(signer.sign(getPrivateKey()));

  return `${signingInput}.${signature}`;
}

The JWT has a 10-minute lifetime. The iat is backdated by 60 seconds to handle clock skew between the server and GitHub's API. The private key is loaded from an environment variable (GITHUB_APP_PRIVATE_KEY) stored in Doppler — it never touches the workspace or the agent sandbox.

The JWT is exchanged for an installation token via GitHub's REST API:

const response = await githubFetch(
  `${GITHUB_API}/app/installations/${installationId}/access_tokens`,
  {
    method: "POST",
    headers: { Authorization: `Bearer ${jwt}` },
  },
);

The returned token is cached in memory with its expiry timestamp. Subsequent operations within the same server process reuse the cached token until five minutes before expiry.

Best-Effort Sync Philosophy

The sync operations follow a strict principle: a failed sync is recoverable; a blocked session is not.

Both syncPull and syncPush catch all errors and log warnings instead of throwing:

export async function syncPull(
  userId: string,
  workspacePath: string,
): Promise<void> {
  // ... setup ...
  try {
    // ... pull logic ...
  } catch (err) {
    log.warn({ err, userId },
      "Sync pull failed — continuing with local state");
  } finally {
    if (helperPath) cleanupCredentialHelper(helperPath);
  }
}

If the pull fails — network outage, token error, merge conflict — the session starts with whatever local state exists. The agent works against a slightly stale codebase rather than not starting at all.

If the push fails, the commit message includes context for the next session:

log.warn({ err, userId },
  "Sync push failed — next session will retry");

The next syncPull auto-commits any local changes before pulling, so work that accumulated between sessions — whether or not the previous push succeeded — is preserved.

Why merge instead of rebase

The pull uses --no-rebase:

execFileSync("git", [
  "-c", `credential.helper=!${helperPath}`,
  "pull", "--no-rebase", "--autostash",
], { cwd: workspacePath, stdio: "pipe", timeout: 60_000 });

Shallow clones (--depth 1) lack sufficient history for rebase operations. A rebase against a shallow clone can fail unpredictably when the common ancestor is not in the local history. Merge is the safe default — it produces a merge commit but never fails due to missing history.

The --autostash flag handles the case where the agent has uncommitted changes that the auto-commit missed (e.g., files matching .gitignore patterns that were later un-ignored).

The Full Lifecycle

Putting it together, the credential lifecycle for a single agent session:

Session start: Server calls syncPull(userId, workspacePath)
syncPull fetches the user's github_installation_id from the database
generateInstallationToken signs a JWT with the App's private key, exchanges it for an installation token, caches the result
writeCredentialHelper writes the token to a randomized /tmp path
Git pulls using the credential helper, merging remote changes
cleanupCredentialHelper deletes the helper script
Agent session runs — all git operations within the session use the workspace's existing git config (no credentials needed for local operations)
Session end: Server calls syncPush(userId, workspacePath)
Steps 3-6 repeat for the push operation
The installation token expires within the hour. The credential helper no longer exists on disk.

At no point does the agent sandbox contain a reusable credential. The token exists in a shell script for the duration of a git command — milliseconds to seconds. The shell script path is unpredictable. The token itself expires.

Q: Why not use GIT_ASKPASS instead of credential.helper?

GIT_ASKPASS works but requires setting an environment variable that persists for the duration of the process. The -c credential.helper=!<path> flag is scoped to a single git invocation. If the process spawns other git operations (e.g., the agent running git commands), they do not inherit the credential helper.

Q: What happens if the credential helper is not cleaned up?

The token in the helper expires after one hour regardless. The randomized filename means it cannot be targeted without directory listing access. But the finally block ensures cleanup in all normal and exceptional exit paths — the only scenario where cleanup fails is a hard process kill (SIGKILL), in which case the file persists until the next /tmp cleanup cycle.

Q: Why not use GitHub's built-in credential caching?

GitHub's credential.helper store and credential.helper cache persist credentials across git invocations — the opposite of what we want. The isolated helper pattern ensures credentials exist only for the duration of one operation.

Q: Does the shallow clone limit what agents can do?

Shallow clones (--depth 1) lack full git history. Agents cannot run git log with history beyond the latest commit, git blame across old revisions, or rebase against distant ancestors. For the intended use case — reading and modifying current project state — shallow clones are sufficient. The trade-off is clone speed (seconds vs. minutes for large repositories) against history depth.

Soleur vs. Polsia: Two Architectures for Running a Company with AI

2026-03-26T00:00:00Z

Polsia hit $1.5M ARR with 2,000+ managed companies as of March 2026. Solo founder Ben Broca built an AI platform that runs companies on autopilot -- nightly autonomous cycles where AI agents evaluate company state, set priorities, execute tasks, and send a morning summary to the human who technically owns the company. The growth is real. The category is validated.

The question is what kind of company you want to build.

Polsia and Soleur both operate in the Company-as-a-Service space. Both use Anthropic models. Both aim to reduce the operational burden on solo founders. But their underlying architectures reflect fundamentally different answers to the same question: what should the founder's role be when AI runs the company?

What Each Platform Is

Polsia is a fully autonomous AI company-operating platform. Its architecture centers on role-based agents -- a CEO agent, an Engineer agent, a Growth Manager agent -- that run nightly autonomous cycles. Each cycle evaluates the company's current state, decides what to prioritize, executes the tasks, and delivers a summary. The founder receives a morning briefing. Polsia provisions all infrastructure: email servers, databases, Stripe, GitHub. The philosophy, in founder Ben Broca's words: "80% AI, 20% taste."

Polsia is built on the Claude Agent SDK (Claude Opus 4.6) and is cloud-hosted and proprietary. Pricing as of March 2026 is $29-59/month, with a potential revenue share component (previously 20% of business revenue and 20% of managed ad spend -- whether this applies to current tiers should be confirmed directly with Polsia).

Polsia covers five business domains: engineering, marketing, cold outreach, social media, and Meta ads.

Soleur is a Company-as-a-Service platform. It deploys 65 agents across 8 business departments -- engineering, marketing, legal, finance, operations, product, sales, and support -- with a compounding knowledge base that accumulates institutional memory across every session and every domain. Soleur runs inside Claude Code.

Soleur is open-source (Apache 2.0). The platform is free.

The founding philosophy: you decide. Agents execute. Knowledge compounds.

The Philosophical Divide

This is not a features comparison. It is an architecture comparison rooted in a philosophical question: should AI replace founder judgment or amplify it?

Polsia answers: replace it. The CEO agent decides what to prioritize. The Growth Manager decides what to post. The Engineer decides what to build. The founder receives a summary and, implicitly, approves by not intervening. The "20% taste" the founder retains is more editorial veto than active decision-making.

Soleur answers: amplify it. Every Soleur workflow -- brainstorm, plan, implement, review, compound -- requires a human decision gate. The marketing agent drafts a campaign; the founder approves before anything publishes. The legal agent generates a compliance analysis; the founder reviews before the policy changes. The competitive intelligence agent surfaces a new threat; the founder decides how to respond before the strategy shifts. The AI handles 100% of execution. The founder provides 100% of judgment.

Neither answer is wrong in the abstract. The right architecture depends on what you are trying to build and what role you want to play in building it.

Where They Differ

Domain Coverage

Polsia covers five domains. Soleur covers eight.

The three domains Polsia omits -- legal, finance, and product strategy -- are not peripheral. A privacy policy violation can trigger regulatory action. A financial model error can burn the runway. A product roadmap that ignores competitive positioning can make the engineering investment worthless. These are the decisions with the highest downside risk and the greatest need for human judgment.

Soleur's legal agents generate compliance documents, audit existing policies, and flag regulatory exposure. Its finance agents produce budget analysis, revenue projections, and board-ready financial reports. Its product agents run spec reviews, competitive positioning analyses, and UX validation. These domains are absent from Polsia's platform -- not because they are unimportant, but because full automation of high-stakes legal and financial decisions carries risks the autonomous model cannot absorb.

Knowledge Architecture

Polsia's agents operate in nightly cycles. Each cycle begins from the current company state -- what exists in the connected infrastructure -- not from an accumulated body of institutional knowledge. An engineering decision from last month does not inform the growth strategy this week. A brand positioning session does not shape the cold outreach copy. The agents execute within their domain; context does not compound across domains.

Soleur's compounding knowledge base is cross-domain by architecture. The brand guide written by the brand-architect agent informs every piece of marketing copy. The competitive intelligence scan updates sales battlecards. The legal compliance agent references the privacy policy when engineering ships a new data feature. The knowledge base is a git-tracked directory of Markdown files -- readable, auditable, and editable by the founder directly -- that accumulates across every session in every domain.

The first time Soleur's competitive intelligence agent runs, it builds a baseline. The twentieth time, it compares against nineteen prior scans, surfaces new entrants, flags shifted pricing, and updates downstream artifacts automatically. The compounding is a structural property of how the knowledge base is written and read, not a marketing claim.

Polsia runs your company cycle by cycle. Soleur builds organizational intelligence that compounds over time.

Workflow Orchestration

Polsia's workflow is a nightly cron job: evaluate state, set priorities, execute tasks, send summary. It is event-triggered and scope-limited to each domain's autonomous cycle. The decision-making is opaque -- the founder does not see why the CEO agent chose to prioritize feature X over feature Y, or why the Growth Manager sent that particular cold email to that particular list.

Soleur runs structured lifecycle workflows: brainstorm > plan > implement > review > compound. Every stage produces an artifact the founder can read, modify, and approve. The plan is visible before execution starts. The review happens before anything ships. The compound step captures what was decided and why, building institutional memory that informs the next decision in the same domain and every adjacent domain.

The difference between an autonomous cron job and an organizational workflow is transparency and the context that flows between stages. Polsia optimizes for founder hands-off-ness. Soleur optimizes for founder leverage.

Pricing

Polsia's pricing as of March 2026:

Entry tier: $29/month
Higher tier: $59/month
Revenue share: Historically 20% of business revenue and 20% of managed ad spend (current applicability should be confirmed with Polsia)

Soleur is open-source. The platform is free.

The pricing analysis matters because of the revenue share dimension. A solo founder generating $10,000/month in revenue would pay $2,000/month under a 20% revenue share model -- on top of the subscription fee. A founder running $5,000/month in Meta ads would pay an additional $1,000/month in ad management fees. At any meaningful revenue, the true cost of Polsia's autonomous model could significantly exceed the headline $29-59/month.

Soleur's planned paid tier carries a flat rate with no revenue share. You keep everything you earn.

Infrastructure Control

Polsia provisions all infrastructure: email servers, databases, Stripe, GitHub. This convenience is part of the fully autonomous model -- the platform owns the stack on your behalf. For founders who want zero setup friction, this is a genuine feature.

Soleur operates on infrastructure you control. You choose your hosting provider, your database, your payment processor. Soleur's agents run in your environment, on your infrastructure, with your credentials. For founders building companies where data privacy, infrastructure portability, or vendor independence matters, controlling the stack is not optional.

When Polsia Is the Right Choice

Polsia is well-suited for founders who want maximum automation with minimal involvement. If you are testing a business concept, want a low-touch experiment running in parallel with other work, or explicitly want AI making most of the operating decisions, Polsia's architecture is designed for that use case. The nightly cycle, morning summary, and infrastructure provisioning minimize the cognitive overhead of running an autonomous operation.

If you accept the "80% AI, 20% taste" philosophy, Polsia executes it cleanly.

When Soleur Is the Right Choice

Soleur is the right choice when the quality of decisions matters as much as the speed of execution.

Solo founders building companies where brand precision, legal compliance, financial planning, and product strategy are differentiators cannot hand those decisions to an autonomous system and expect competitive-quality output. The first billion-dollar solo company will not be built on autopilot. It will be built by a founder whose judgment is amplified across every domain -- where every decision makes the system smarter, and every new project benefits from everything the company has learned.

If the business you are building requires legal rigor, financial modeling, product strategy, or cross-domain institutional memory that compounds over time, Soleur covers those requirements. Polsia does not.

The distinction is not automation versus manual work. Both platforms automate execution. The distinction is who provides the judgment: the AI or the founder.

FAQ

Q: Can I use Polsia and Soleur together?

Yes, in principle. Polsia automates the operational cycles for the domains it covers. Soleur can handle the domains Polsia omits -- legal, finance, product strategy -- and provide the cross-domain knowledge infrastructure those decisions require. The architectures do not conflict; they address different scopes and different philosophies within those scopes.

Q: Polsia's CEO agent decides priorities. Doesn't that make human-in-the-loop more efficient, not less?

Only if the autonomous decisions are reliably good. The efficiency argument for fully autonomous operation holds when the marginal cost of a wrong decision is low. When decisions carry legal, financial, or strategic consequences -- a contract clause, a pricing model, a product roadmap -- the cost of a wrong autonomous decision can exceed the time saved by not reviewing it. Soleur's position is that founder judgment is the compounding asset, not an inefficiency to be automated away.

Q: Polsia reached $1.5M ARR. Doesn't that prove autonomous CaaS works?

Polsia's growth validates that solo founders will pay for AI-powered company operation. It validates the CaaS category thesis. What $1.5M ARR across 2,000+ managed companies does not validate is the output quality of autonomous execution, the long-term trajectory of companies running on that model, or whether the autonomous approach produces results competitive with human-guided execution at higher stakes. The market exists. The architecture question remains open.

Q: Is Soleur's open-source model sustainable against a venture-backed competitor?

Soleur's compounding knowledge base, cross-domain institutional memory, and open-source transparency are structural advantages that a proprietary cloud platform cannot replicate by adding features. The open-source core means every agent, every skill, and every knowledge-base schema is auditable and extensible. The compound architecture means the platform gets better with use in a way that autonomous nightly cycles do not. Sustainability comes from the depth of the moat, not the size of the funding round.

Vibe Coding vs Agentic Engineering: What Solo Founders Need to Know

2026-03-24T00:00:00Z

In February 2025, Andrej Karpathy gave developers permission to stop overthinking and start shipping. He called it vibe coding: describe what you want, accept the AI's output, iterate fast. For prototypes and solo builders, it was a revelation.

Exactly one year later, Karpathy introduced agentic engineering — the practice of orchestrating AI agents with human oversight rather than prompting models directly. The name stuck. The shift it described was real.

The difference between these two approaches is not a matter of preference. For a solo founder trying to build at company scale, it is the difference between a system that stays helpful and one that compounds.

The Core Difference

Vibe coding is conversation. Agentic engineering is delegation with accountability.

In vibe coding, you prompt a model conversationally. You describe what you want, the model generates output, you accept or reject. The session ends. The next session starts fresh. No memory of what worked, what broke, or what to avoid.

Agentic engineering is different by design. You define specifications before any code is written. Agents execute against those specs with verification gates that catch regressions. Quality checks run automatically. When something breaks, the failure is documented — not just remembered, but captured in a form the next session can learn from.

Dimension	Vibe Coding	Agentic Engineering
Entry point	Conversation	Specification
Memory	Single session	Persistent across sessions
Quality assurance	Manual review	Automated gates
Failure handling	Learn and move on	Document, route, enforce
Parallelization	One agent at a time	Multiple agents, isolated workspaces
Knowledge growth	Resets each session	Compounds with every task

What Vibe Coding Gets Right

Nothing in this comparison is an argument against vibe coding. It changed how solo founders build prototypes.

Before vibe coding, building a working prototype required hours of context-switching between editor, documentation, and the model. Vibe coding collapsed those context switches into one conversation. For discovery work — figuring out whether something is worth building at all — it remains the fastest tool available.

The problem is not the approach. The problem is what happens after you decide to build for real.

Where Vibe Coding Breaks

The plateau arrives fast.

You have a working prototype. The vibes were good. Now you need to add a feature, fix a regression, or hand the codebase to another agent for review. And the first thing you realize is that the hundredth session starts from the same blank slate as the first.

The model does not remember why you made that architectural decision. It does not know that approach was tried and failed three days ago. It does not know which edge cases your tests cover or which parts of the codebase are fragile. Every session is a reconstruction.

This is not a model limitation. It is a structural problem with session-based development: no specification means no ground truth. No persistent knowledge means no cumulative improvement. The sessions accumulate, but the system does not get smarter.

What Agentic Engineering Solves

Agentic engineering reframes the problem. Instead of asking "what can I build with AI today?" it asks "how does this system get better with every task I complete?"

Three structural changes drive this:

Specifications before execution. Writing what you intend to build before building it creates a contract between you and the agent: this is the outcome, these are the constraints, this is how success is measured. The agent executes against the spec. You verify against the spec. Both parties know what done looks like.

Verification gates. Agentic engineering builds review steps into the workflow itself. Automated tests run before merge. Plan review runs before implementation. Code review runs before the PR is opened. These gates are not bureaucracy — they are the mechanism by which the system catches its own mistakes before they become technical debt.

Persistent knowledge. When a session generates a learning — about what works, what fails, what to prevent — that learning gets captured and routed back into the system's rules and workflows. Not just remembered by the founder. Not just written in a comment. Enforced by the system, permanently.

The Solo Founder Multiplier

For a solo founder, the distinction between these approaches carries more weight than it does for a team.

A team absorbs vibe coding's memory problem through human coordination. The senior engineer remembers the architectural decisions. The QA specialist catches the regressions. Code review creates accountability even without automated gates.

A solo founder has none of those redundancies. When the session ends, nothing remembers what happened. When a regression appears three weeks later, there is no one to ask. When an agent makes the same mistake for the fourth time, there is no institutional memory to stop it.

Agentic engineering addresses these gaps directly. Specifications replace team meetings. Persistent knowledge replaces institutional memory. Automated gates replace the code review team that does not exist.

This is why compound knowledge matters more for solo founders than for anyone else. A system that gets smarter with each task is not a convenience — it is the only path to building at company scale without a company.

Beyond Engineering: The Full Picture

Vibe coding solves the coding problem. Agentic engineering solves the engineering problem. Neither addresses the other functions of running a company.

Legal documents need review. Marketing campaigns need execution. Competitive intelligence needs monitoring. Financial models need updating. These functions do not get better by coding faster. They get better when knowledge compounds across all of them — when the legal review informs the product positioning, when the competitive analysis shapes the pricing decision, when the engineering architecture reflects the compliance requirements.

This is the premise behind Company-as-a-Service — a model where a single AI organization runs every department of a business, with a compounding knowledge base that every department reads from and writes to. Agentic engineering is not just a better way to code. It is the architectural pattern for every function in the company.

Start Building

The shift from vibe coding to agentic engineering is not about working harder. It is about building a system that gets easier to operate over time.

Every specification written is a decision documented. Every automated gate is a failure mode permanently closed. Every learning captured is a session that starts more informed than the last.

The first billion-dollar company run by one person is not built in one session. It is built by a system that compounds.

Start building →

Frequently Asked Questions

What is vibe coding?

Vibe coding is an approach to AI-assisted development coined by Andrej Karpathy in February 2025. It describes ad-hoc, conversational AI coding: describe what you want, accept the model's output, iterate without formal specifications or quality gates. It prioritizes speed for prototyping and exploratory work.

What is agentic engineering?

Agentic engineering is the structured orchestration of AI agents with human oversight, introduced by Andrej Karpathy in February 2026. It emphasizes formal specifications before execution, automated verification gates, persistent memory across sessions, and knowledge that compounds with every task completed.

Which approach is better for solo founders?

Both approaches serve different purposes. Vibe coding is faster for prototyping and validating ideas. Agentic engineering is better suited for production systems that need to remain maintainable over time. Solo founders benefit most from agentic engineering because they lack the team redundancies — institutional memory, code review, QA — that compensate for session-based development's limitations.

How does compound engineering relate to agentic engineering?

Compound engineering is a specific implementation of agentic engineering's knowledge-persistence principle. Where agentic engineering establishes that learnings should persist across sessions, compound engineering describes the specific loop: work, capture the learning, route it back to the relevant workflow, and enforce it mechanically when possible. Compound engineering is what agentic engineering looks like when knowledge growth becomes the primary architectural goal.

Can solo founders use vibe coding and agentic engineering together?

Yes. Many effective solo founder workflows use vibe coding for exploration and prototyping, then transition to agentic engineering for production implementation. The specification written at the start of agentic engineering captures what the vibe coding prototype proved worth building. The two approaches are complementary at different stages of the same project lifecycle.

AI Agents for Solo Founders: The Definitive Guide

2026-03-24T00:00:00Z

Solo-founded startups rose from 23.7% to 36.3% of all new ventures between 2019 and the first half of 2025, according to the Carta Solo Founders Report. The reason is not courage. It is infrastructure. AI tools now handle work that used to require a team — and most solo founders discover them the same way: a demo of something that writes code, generates copy, or drafts a legal template. It saves an hour. Then two. Then the plateau arrives.

The problem is not the tools. The problem is that running a company requires eight distinct domains — engineering, marketing, legal, finance, operations, product, sales, and support — and a collection of single-function tools never adds up to a working organization.

AI agents are different. An agent does not wait for prompts. It operates with a goal, uses tools to execute, and works alongside other agents toward a shared objective. For a solo founder, the difference is the difference between a faster keyboard and an actual organization.

This guide is for founders who have moved past the demo. You have seen what AI can do for one function. Now you want to understand what it means to run an entire company with agents — and what separates the approaches that scale from the ones that plateau.

What Makes an AI Agent Different

A chatbot answers a question. An AI agent completes a task.

The distinction sounds semantic until you try to ship something. A chatbot can explain how to write a terms of service. An agent writes the terms of service, checks it against your jurisdiction's requirements, flags clauses for review, and files a task to revisit it when regulations change. The output is not a response — it is a work product.

Four properties define a true agent:

Goal-orientation. The agent has a defined outcome, not just a prompt. It knows what done looks like and works toward it.

Tool use. The agent can read files, write code, search the web, make API calls, and coordinate with other agents. It is not limited to generating text.

Memory. The agent can access context from previous sessions — prior decisions, known constraints, existing work products, and accumulated learnings.

Accountability. The agent's output can be verified against a specification. This matters more for solo founders than for teams, because there is no one else checking. An agent without an accountability mechanism is a sophisticated autocomplete.

The Eight Domains of a Company

Running a company requires expertise across eight distinct domains. The Bureau of Labor Statistics describes the core duties of top executives as planning strategies, coordinating activities, and communicating with stakeholders — functions that span every department. No founder — and no AI tool — is competent in all eight from day one. The question is how you close the gaps.

Engineering builds and ships the product. Code review, architecture decisions, infrastructure provisioning, test coverage, release management.

Product translates user need into specification. Feature prioritization, user research, UX decisions, business validation, roadmap management.

Marketing creates demand. Brand voice, content strategy, SEO, social distribution, competitive positioning.

Legal manages exposure. Contract drafting, compliance monitoring, privacy policy, terms of service, IP protection, regulatory updates.

Finance models the business. Revenue forecasting, expense tracking, burn rate, unit economics, pricing decisions.

Operations keeps the machine running. Vendor management, process documentation, tooling reliability, infrastructure maintenance.

Sales converts attention into revenue. Outbound strategy, pipeline management, deal architecture, revenue operations.

Support retains customers and closes the feedback loop. Ticket triage, community management, knowledge base maintenance.

A solo founder with a collection of coding tools has handled one domain. The other seven are still manual.

Why Point Solutions Fail

The promise of solopreneur AI tools is speed. A code generator writes code faster. A copywriting tool drafts faster. A contract template saves legal fees. Each tool delivers on its narrow promise — and investors have noticed. Cursor reached $1 billion in annual recurring revenue proving that founders will pay for AI that accelerates a single domain.

What these tools cannot deliver is coordination.

Legal cannot reference what marketing published. Marketing cannot reflect what engineering decided. Engineering cannot anticipate what compliance requires. Each domain operates in isolation, which means the same decision gets made — and sometimes reversed — across multiple contexts without any of them knowing.

This is not a workflow problem. It is an architecture problem. Point solutions are stateless by design. They begin fresh with each session, in each domain, with each tool. The knowledge one function generates never reaches the others.

For a team, this is manageable. Team members talk. A senior engineer remembers the architectural decisions that constrained the marketing roadmap. The legal counsel reads the product brief before drafting the contract. The institutional memory lives in people.

A solo founder has none of that coordination infrastructure. Every handoff between domains requires the founder to carry the context manually. As the company grows, the cost of those handoffs grows with it.

What to Look For in AI Agents

Not every AI agent is useful for a solo founder. The properties that matter most differ from what matters in enterprise deployments.

Cross-domain context. The most important question to ask about any AI agent stack: what does the marketing agent know about what the engineering agent decided last week? If the answer is "nothing," you have a collection of tools, not an organization.

Persistent knowledge. Agents that start from a blank slate on each session require the founder to re-supply context manually every time. Agents with persistent memory across sessions accumulate knowledge and reduce the founder's coordination cost over time. This distinction compounds — a system that remembers three months of decisions is dramatically more useful than one that forgets at session end.

Verifiable output. An agent's output should be checkable against a specification. Quality gates built into the workflow replace the code review, legal review, and editorial review that a team provides. Without those gates, the founder becomes the bottleneck for every domain, every time.

Compound improvement. The most valuable agents get better with use. Each task generates a learning. Each learning routes back into the system's rules. Each subsequent task starts from a more informed baseline. An agent that performs at the same level after 100 tasks as it did after 10 is a tool with a more complicated interface.

The Compound Knowledge Advantage

The gap between a useful AI stack and a scalable one comes down to what happens to knowledge after a task is complete.

Most AI tools discard it. The session ends. The output remains. The reasoning that produced the output — the decisions made, the tradeoffs considered, the edge cases encountered — disappears.

Compound knowledge captures it. Every task generates a learning. The learning is routed to the domain where it belongs — engineering rules, marketing constraints, legal requirements. The next task in that domain starts with that learning already incorporated.

For a solo founder, compound knowledge solves the coordination problem that point solutions cannot. When the legal agent captures a compliance requirement, it does not just document it — it enforces it in every future task that touches the affected domain. When the engineering agent learns that a particular integration is fragile, every future task that depends on it starts with that warning already in place.

Over time, the AI organization does not just remember more. It makes better decisions, catches more edge cases, and requires less founder intervention. The founder's job shifts from doing and coordinating to deciding and directing.

Dario Amodei, CEO of Anthropic, predicted a 70-80% probability that a one-person billion-dollar company would emerge by 2026. That prediction is not about better tools. It is about compound knowledge — the only mechanism that turns a solo founder into an organization that improves structurally with every task.

This is why agentic engineering matters more for solo founders than for anyone else. A system that gets smarter with each task is not a convenience — it is the only path to building at company scale without a company.

What a Full AI Organization Looks Like

Company-as-a-Service is the model where a single AI organization covers all eight domains with agents that share a compounding knowledge base. The concept is no longer theoretical. Sam Altman, CEO of OpenAI, described a betting pool among tech CEOs for "the first year that there is a one-person billion-dollar company." TechCrunch reported that AI agents could birth the first one-person unicorn — but only if they extend beyond engineering into every function a company needs. Alibaba Group President J. Michael Evans went further, telling Fortune that agentic AI is making the one-person unicorn a near-term reality.

In practice, a full AI organization means:

An engineering review that checks code against the product spec, the legal constraints, and the compliance requirements — simultaneously, without the founder acting as the relay
A marketing brief that automatically reflects the latest competitive intelligence from the product and engineering teams
A contract draft that incorporates the business model, jurisdiction requirements, and pricing decisions already captured in the knowledge base
A financial report that draws on operational data, sales pipeline, and engineering velocity to produce an accurate view of the business

Each of these is an agent operating within shared context. The result is an organization that behaves coherently across domains — not because the founder coordinated the handoffs, but because the knowledge base did.

Soleur is built on this model: 63 agents across 8 departments, sharing a knowledge base that compounds with every task completed.

Getting Started

The path from solo founder to AI organization does not begin with replacing all your tools at once. It begins with establishing the knowledge layer.

Step 1: Define your knowledge base. Document what your company knows: the architecture decisions, the brand voice, the legal constraints, the pricing model. This is the ground truth every agent reads from and writes to.

Step 2: Start with one domain. Pick the domain where manual work costs you the most. Engineering is the natural starting point for technical founders, but marketing, legal, and finance are equally valid entry points. Deploy agents there first. Let the knowledge compound.

Step 3: Connect the domains. Once one domain is running, introduce the adjacent ones. The key is ensuring agents share context — a marketing agent that knows what engineering decided, a legal agent that knows what marketing published. The connections matter more than the individual capabilities.

Step 4: Build the feedback loop. Every task should generate a learning. Every learning should route back into the relevant domain's rules. The system should be measurably more effective after 100 tasks than after 10.

The goal is not AI tools that make you faster today. It is an AI organization that makes you more capable every month.

Start building →

Frequently Asked Questions

What is an AI agent for a solo founder?

An AI agent is a system that operates with a defined goal, uses tools to complete tasks, maintains memory across sessions, and can be verified against a specification. For solo founders, agents replace team functions that a single person cannot fill alone — code review, legal review, marketing execution, financial modeling — while sharing context across all domains so the organization behaves coherently.

How are AI agents different from AI tools like chatbots or coding assistants?

Most AI tools are session-based and single-function. They generate responses to prompts but do not maintain memory, execute multi-step workflows, or coordinate with other tools. AI agents are designed to complete tasks, not just answer questions. The best agents accumulate knowledge over time so each subsequent task benefits from everything the system has previously learned.

What are the most important solopreneur AI tools in 2026?

The highest-leverage agents cover the functions a solo founder cannot easily replicate: code review, legal document generation, competitive intelligence monitoring, financial modeling, and marketing execution. But individual agent capability matters less than cross-domain coordination. An agent stack where each domain shares context with the others compounds faster than a collection of specialized tools that cannot communicate.

How does compound knowledge work in practice?

Compound knowledge means every task generates a learning, and every learning is routed back into the relevant domain's rules or constraints. If the legal agent learns your jurisdiction requires a specific clause in employment agreements, that requirement is captured and applied to every future contract automatically. If the engineering agent encounters a fragile integration, that knowledge is documented and every future task touching the same integration starts with the warning already in place. The system improves structurally, not just incrementally.

Is Soleur only for technical founders?

No. Soleur covers all eight departments of a company — engineering, marketing, legal, finance, operations, product, sales, and support. Many founders start with the engineering domain, but legal, marketing, finance, and product agents operate independently and compound knowledge in their own domains. A founder with no engineering background can start with marketing or legal and build from there.

How do I get started with AI agents as a solo founder?

Start by defining your knowledge base: the decisions you have made, the constraints you operate within, the brand voice you want to maintain. Then deploy agents in the domain where manual work costs you the most. Connect domains as you add them, ensuring agents share context. Build the feedback loop so every task generates a learning that improves the next one. The goal is an AI organization that compounds — not a set of tools performing the same function at the same level indefinitely.

Soleur vs. Cursor: When an AI Coding Tool Becomes an Agent Platform

2026-03-19T00:00:00Z

On March 5, 2026, Cursor shipped Automations — event-driven agents that run in cloud sandboxes, trigger on GitHub PRs, Slack messages, Linear issues, and cron schedules, and learn from past runs to improve over time. Two weeks earlier, it launched a Marketplace with a curated set of engineering-domain plugins, then expanded to 30+ new plugins on March 11, 2026. Cursor is no longer just an AI code editor. It is an agent platform.

That changes the comparison. "Cursor is for coding, Soleur runs the whole company" was accurate in 2025. In March 2026, it requires a more precise examination: what Cursor's agent platform actually covers, where its scope ends, and where Soleur's Company-as-a-Service architecture begins.

What Each Platform Is

Cursor is an AI code editor built by Anysphere (CEO: Michael Truell). Its agent capabilities now span from Tab (next-token and diff prediction using Cursor's proprietary model) to Cloud Agents that run in isolated virtual machines with computer use capabilities — navigating browser UIs, running tests, and submitting merge-ready pull requests with video and screenshot artifacts. In February 2026, Cursor reported that more than 30% of PRs merged at Cursor are now created by agents operating autonomously in cloud sandboxes.

The Automations layer — launched March 5, 2026 — adds event-driven execution. Agents fire on triggers, complete engineering tasks, and loop humans in only for high-risk findings. The Marketplace — launched February 17, 2026 and expanded to 30+ new plugins in March — packages MCP servers, subagents, hooks, and rules into single-install plugins covering infrastructure (AWS, Cloudflare, Vercel), data (Snowflake, Databricks), project management (Atlassian, Linear), and observability (Datadog).

Cursor's annualized revenue reportedly exceeded $2 billion in February 2026, doubling in three months.

Soleur is a Company-as-a-Service platform. It deploys 65 agents across 8 business departments — engineering, marketing, legal, finance, operations, product, sales, and support — with a compounding knowledge base that accumulates institutional memory across every session and every domain. It runs inside Claude Code, accessed from the terminal.

Where They Differ

Domain Coverage

This is where the comparison becomes precise.

Cursor's Automations, Marketplace plugins, and Cloud Agents are engineering-domain instruments. The trigger events are GitHub PRs, Linear issues, PagerDuty incidents, and Slack messages about code. The Marketplace plugins cover the engineering toolchain: AWS, Vercel, Stripe, Databricks, Snowflake. A Cursor automation reviews a PR for security vulnerabilities. A cloud agent refactors a module and opens a merge-ready PR. These are high-value engineering workflows.

The 70% of running a company that is not engineering — marketing campaigns, legal reviews, investor reports, competitive intelligence, sales pipeline analysis, brand voice, financial planning — falls entirely outside Cursor's scope. The Marketplace has no marketing plugin, no legal plugin, no finance plugin, no sales plugin. Automations have no trigger model for a campaign launch, a contract review request, or a quarterly board report.

Soleur covers all eight departments with specialist agents at each lifecycle stage. A marketing campaign, a legal review, a competitive intelligence scan, and an engineering feature all run through the same brainstorm-plan-implement-review-compound lifecycle, with domain-specialist agents at every step.

If you are a solo founder, you are not only a developer. Cursor handles the development work exceptionally well. Soleur handles the company.

Knowledge Architecture

Cursor's Automations include a memory tool. Per the Cursor Automations documentation, "Agents also have access to a memory tool that lets them learn from past runs and improve with repetition." Rules persist instructions to a project, user, or team across sessions. An automation that ran last week carries context into this week's run.

But the memory is automation-scoped. The PR review automation's accumulated knowledge does not inform the deployment automation. The coding agent's context does not flow into anything outside the engineering domain — because everything outside the engineering domain is outside Cursor's scope.

Soleur's compounding knowledge base is cross-domain by architecture. The brand guide written by the brand-architect agent informs every piece of marketing copy the copywriter agent generates. The competitive intelligence scan updates the sales battlecards. The legal compliance agent references the privacy policy when engineering ships a new data feature. The knowledge base is a git-tracked directory of Markdown files — readable, auditable, and editable by the founder directly — that accumulates across every session in every domain.

The first time the competitive intelligence agent runs, it builds a baseline. The twentieth time, it compares against nineteen prior scans, highlights new entrants, flags shifted pricing, and updates downstream artifacts. The compounding is not a marketing claim. It is a structural property of how the knowledge base is written and read.

Automation-scoped memory and a cross-domain compounding knowledge base serve different goals. The first improves repeated engineering tasks. The second builds organizational intelligence.

Workflow Orchestration

Cursor Automations execute engineering tasks: review this PR, fix this incident, run this linter on schedule. The workflow is task-scoped: one trigger, one output, one notification.

Soleur runs lifecycle workflows across all eight departments. Every domain follows the same structure: brainstorm > plan > implement > review > compound. An engineering feature moves through specification, architecture review, implementation, security audit, and knowledge capture — in sequence, with the full context of every prior decision available at each stage. A marketing campaign runs through the same lifecycle with marketing-domain agents: growth strategist, copywriter, fact-checker, social distribution.

The difference between a task runner and an organizational workflow is the context that flows between steps. Cursor's Automations excel at running well-defined engineering tasks. Soleur's lifecycle workflows handle ambiguous, judgment-intensive processes across the full organizational scope.

Pricing

Cursor's pricing as of March 2026:

Hobby: Free (limited agent requests and Tab completions)
Pro: $20/month (extended agent limits, cloud agents, frontier model access)
Pro+: $60/month (3x usage credits, background agents)
Ultra: $200/month (20x usage, priority access)
Teams: $40/user/month

Soleur is open-source. The platform is free.

If you already pay for Cursor Pro at $20/month and add Soleur, you have an AI coding environment and a full eight-department AI organization for $20/month total.

When Cursor Is the Right Choice

Cursor is the best available AI coding environment. For a developer whose primary constraint is software engineering velocity — writing, reviewing, and shipping code faster — Cursor's Tab model, Cloud Agents, and Automations represent a meaningfully differentiated platform. If your company's current bottleneck is the engineering backlog, Cursor directly addresses it.

Soleur does not replace Cursor. If Cursor is your coding environment of choice, continue using it. Soleur operates at the organizational layer, not the IDE layer.

When Soleur Is the Right Choice

Soleur is the right choice when the bottleneck is not engineering alone.

Solo founders do not spend 100% of their time writing code. They spend time on competitive positioning, legal review, financial planning, customer communications, marketing, and sales — domains where no Cursor automation fires and no Marketplace plugin ships. Soleur covers those domains with the same structured lifecycle, the same compounding knowledge base, and the same principle: you make the decisions, agents execute, knowledge compounds.

The distinction is organizational scope. Cursor builds the product. Soleur runs the company.

FAQ

Q: Does Soleur work with Cursor?

Yes. Soleur runs inside Claude Code; Cursor is an IDE. They operate at different layers of the stack. You can use Cursor for writing and reviewing code while using Soleur for the organizational workflows — marketing, legal, finance, operations, product, sales — that happen outside the IDE. There is no conflict.

Q: Cursor Automations now include memory. Is that equivalent to Soleur's knowledge base?

No. Cursor's automation memory is scoped to individual automations within the engineering domain. An automation that learns from past PR reviews does not share that knowledge with your marketing campaigns or legal reviews. Soleur's compounding knowledge base is cross-domain: the brand guide informs marketing copy, competitive intelligence updates sales battlecards, and legal decisions flow into engineering constraints automatically.

Q: Is Cursor's Marketplace a competitor to Soleur's agent ecosystem?

Cursor's Marketplace covers the engineering toolchain: infrastructure, data, observability, project management. It has no marketing, legal, finance, or sales plugins. Soleur's 65 agents cover all eight business departments. They address different scopes, not the same one.

Q: Does Cursor's $2B+ ARR indicate it is better for enterprise use than Soleur?

Revenue scale reflects adoption within a specific domain — engineering teams at large organizations. Soleur is open-source and auditable: every agent prompt, every skill, every knowledge-base schema is readable. Founders who need full transparency into what their AI organization is doing can read the source. The two products serve different organizational scopes and are not direct enterprise-vs-startup substitutes.

Soleur vs. Notion Custom Agents: Company-as-a-Service vs. Workspace Automation

2026-03-17T00:00:00Z

Notion passed 100 million users in August 2024, and a workspace that stores everything about how a company operates. On February 24, 2026, it shipped Custom Agents — autonomous AI teammates that automate recurring work across Notion, Slack, Mail, Calendar, and integrated tools. For a solo founder already living in Notion, the pitch writes itself.

The question is what Notion Custom Agents actually automate, and whether that overlaps with what Soleur provides as a Company-as-a-Service platform.

What Each Platform Is

Notion Custom Agents are autonomous AI teammates that run inside your Notion workspace, launched with Notion 3.3 on February 24, 2026. They operate on triggers — schedules, Slack messages, database changes, email arrivals — and execute tasks without prompting. Notion built three primary workflows: Q&A agents that answer recurring questions from your knowledge base, task routing agents that capture and assign incoming work, and status update agents that compile progress reports. Integrations include Slack, Notion Mail, Calendar, Figma, Linear, HubSpot, and custom MCP servers. Available on Business ($20/seat/month) and Enterprise plans, currently in free beta through May 3, 2026, then transitioning to a credit-based model at $10 per 1,000 Notion credits.

Within the beta, early testers had built over 21,000 agents; Notion itself runs 2,800 agents internally.

Soleur is an open-source Company-as-a-Service platform. It deploys 65 agents across 8 business departments — engineering, marketing, legal, finance, operations, product, sales, and support — with a compounding knowledge base that accumulates institutional memory across every session and every domain. Soleur is designed for the terminal, running inside Claude Code, with a workflow lifecycle that runs from brainstorm through planning, implementation, review, and knowledge capture.

Where They Differ

The surface area overlaps until you look at the architecture.

What Gets Automated

Notion Custom Agents automate recurring, predictable tasks: triage incoming requests, compile weekly status reports, answer repeated questions from a knowledge base, route tasks to the right team member. The trigger model — schedule, database change, Slack message — is well-suited to repetitive operational work that needs no judgment variation.

Soleur orchestrates complete business processes that require domain judgment. An engineering feature moves through specification, architecture review, implementation, security audit, and knowledge capture. A marketing campaign runs the same structured lifecycle with marketing-domain agents at every stage. A legal review from the compliance agent references the privacy policy automatically. These are not scheduled tasks — they are judgment-intensive workflows that require cross-domain context at every step.

Both platforms automate work. The work they automate is categorically different.

Knowledge Architecture

Notion agents draw context from your Notion workspace: pages, databases, connected apps. That context is rich. If you have built a thorough Notion workspace, the agents have access to your SOPs, project databases, meeting notes, and CRM data. But that context is workspace-scoped: it reflects what you have put into Notion, in the structure Notion uses. The marketing agent and the engineering agent both read from the same workspace, but one domain's decisions do not automatically inform the other domain's workflows.

Soleur's compounding knowledge base is built from cross-domain learning. The brand guide informs every marketing artifact. The competitive intelligence scan updates the sales battlecards. The legal compliance agent references the privacy policy when engineering ships a new data feature. Every session writes back to the knowledge base — not just logs, but structured institutional memory. The 100th session is not just a day older than the first. It is categorically more capable.

Workspace context and compounding knowledge are different things. The first reflects what exists. The second reflects what was decided, why, and what it means for everything else.

Workflow Depth

Notion agents are excellent at running defined tasks on schedule. Write a daily standup summary. Triage Slack messages into a database. Send a weekly report. These are high-value workflows for teams managing operational overhead.

Soleur runs lifecycle workflows across 8 business domains. The brainstorm-plan-implement-review-compound cycle applies from engineering PRs to marketing campaigns to legal reviews. Each domain has specialist agents that bring deep domain judgment to every step. A security review does not run once per sprint on a schedule — it runs as part of the implementation lifecycle, with access to the full context of what changed and why.

Notion is a platform for teams managing recurring operations. Soleur is a platform for one founder managing an entire company.

Team Architecture vs. Solo Founder Architecture

Notion Custom Agents are built for teams. They are created, shared, and managed collaboratively, with enterprise-grade permission controls, usage analytics, and version control. The architecture assumes distributed ownership of workflows.

Soleur assumes one decision-maker. The solo founder owns every architectural decision, every campaign, every compliance choice. The system executes. Every agent produces output for the founder's review. The knowledge base compounds the founder's judgment, not a committee's. The architecture is not a limitation — it is a design choice. When there is one decision-maker, every agent can be fully aligned with that person's context.

Pricing

Notion Custom Agents are currently in free beta through May 3, 2026. From May 4, they run on Notion credits: $10 per 1,000 credits, usage-based by task complexity. Custom Agents require a Business plan at $20 per seat per month or an Enterprise subscription.

Soleur is free and open-source under the Apache-2.0 license. A paid tier is planned but not yet released. The full codebase is public and auditable.

The cost comparison depends on what you are replacing. Notion charges for the seat plus credits at scale. Soleur's institutional knowledge lives in your repository, under your control, with no per-session cost accumulating against task volume.

Terminal vs. Workspace

Notion agents run inside Notion. Their value compounds inside the Notion workspace and the tools it connects to. If your workflow centers on Notion — your projects live there, your team communicates there, your data is organized there — Custom Agents operate on familiar ground.

Soleur is terminal-first. It runs inside Claude Code, in the same environment where engineering decisions get made, where code gets shipped, where technical context lives natively. The marketing copywriter reads the brand guide from the repository. The architecture review happens in the same session as the implementation. The knowledge base is a git-tracked directory — version-controlled, diffable, transferable.

For a solo founder who ships code and runs a company from the terminal, Soleur's surface is the surface where work already happens.

Side-by-Side Comparison

Dimension	Notion Custom Agents	Soleur
Primary use case	Automate recurring workspace tasks: triage, standups, status reports	Orchestrate full business lifecycle: engineering, marketing, legal, finance, ops, product, sales, support
Knowledge architecture	Workspace-scoped: Notion pages, databases, connected apps	Cross-domain compounding: grows across every session and every domain
Workflow model	Trigger-based (schedule, Slack, database change)	Lifecycle-based (brainstorm → plan → implement → review → compound)
Integrations	Slack, Mail, Calendar, Figma, Linear, HubSpot, MCP servers	MCP ecosystem via Claude Code; compounding knowledge base replaces integration-driven context
Target user	Teams managing shared recurring operations	Solo founders running a full company
Pricing	Free beta until May 3, 2026; $10/1,000 Notion credits + Business plan ($20/seat/month)	Free (open-source, Apache-2.0). Paid tier planned.
Open source	Proprietary	Apache-2.0. Full source code public.
Interface	Web and desktop (Notion workspace)	Terminal (Claude Code)
Cross-domain coherence	Workspace context shared; domain decisions not cross-referenced automatically	Every domain reads from and writes to the same compounding knowledge base
Current availability	Free beta (Business and Enterprise plans)	Live (open source)

Who Each Platform Is For

Notion Custom Agents are the right choice if:

Your workflow is centered in Notion — projects, data, and team communication all live there
You need to automate recurring operational tasks: triage, standups, status reports, task routing
You manage a team and need shared agents with collaborative ownership
Your integrations are Slack, Figma, Linear, or HubSpot and you want AI running on top of them
You want zero installation overhead on top of your existing Notion subscription

Soleur is the right choice if:

You work in the terminal via Claude Code
You need cross-domain coherence — marketing that references legal decisions, engineering that reflects competitive intelligence, finance that tracks what product decided
You need institutional memory that compounds across sessions, not workspace context that refreshes
You are building a company, not managing a team's recurring operations
You care about open-source transparency: auditable agents, modifiable workflows, your knowledge on your machine

The Compounding Difference

Notion Custom Agents are effective at what they were designed for. A founder using Notion to automate standups and task triage saves real hours every week. Those hours are valuable. They are not compounding.

A founder using Soleur for six months has built an AI organization that knows how the company thinks. The brand positioning from the marketing agent informed the investor memo. The architecture decision from last sprint is referenced in the compliance review. The competitive intelligence from three weeks ago shaped the pricing strategy. None of this required the founder to copy information between sessions. The knowledge accumulated.

Workflow automation removes repetitive work. Compound knowledge removes repetitive thinking. Both matter. One scales linearly with the tasks automated. The other scales exponentially with the decisions accumulated.

That is the difference between a workspace with smart automation and a company-as-a-service platform.

Start Building

Soleur runs 65 agents across 8 departments with a compounding knowledge base that gets more powerful every day you use it. Open source, terminal-first, built by a solo founder using the platform itself.

claude plugin install soleur

Explore the 65 agents, read what company-as-a-service means for solo founders, or get started in five minutes.

Frequently Asked Questions

Can Notion Custom Agents replace Soleur for a solo founder?

Notion Custom Agents automate recurring operational tasks within the Notion workspace — standups, triage, status reports. Soleur orchestrates complete business lifecycle workflows across 8 domains with a compounding knowledge base. They automate different categories of work. A solo founder building a company will find Soleur covers territory Notion Custom Agents are not designed for: cross-domain knowledge compounding, engineering lifecycle management, security reviews, and competitive intelligence workflows.

What is the pricing difference between Notion Custom Agents and Soleur?

Notion Custom Agents are free through May 3, 2026. From May 4, they require a Business plan ($20/seat/month) plus Notion credits ($10 per 1,000 credits). Soleur is free and open-source under the Apache-2.0 license — no per-seat cost, no credit system. A paid hosted tier is planned but has not launched.

Does Notion have a compounding knowledge base like Soleur?

Notion agents draw context from your Notion workspace — pages, databases, and connected applications. That context is workspace-scoped: rich within Notion, but decisions made in one domain do not automatically inform workflows in another domain. Soleur's compounding knowledge base grows across every session and every domain: the brand guide informs marketing copy, competitive intelligence informs pricing strategy, legal decisions inform engineering constraints. The architecture is different in kind, not just in degree.

How does Notion Custom Agents pricing work after the free beta ends?

Starting May 4, 2026, Notion Custom Agents move from free beta to a credit-based model. Each agent run uses Notion credits based on task complexity. Credits are priced at $10 per 1,000 Notion credits and are shared across the workspace, resetting monthly. Unused credits do not roll over. Custom Agents require a Business plan ($20/seat/month) or an Enterprise plan.

Is Soleur available inside Notion?

No. Soleur is a terminal-first platform that runs inside Claude Code. It does not operate within the Notion workspace. If your workflow centers on Notion for team collaboration and recurring task automation, Notion Custom Agents are built for that surface. If your workflow centers on the terminal and requires cross-domain AI organization with compounding knowledge, Soleur provides what Notion Custom Agents are not designed to offer.

Soleur vs. Anthropic Cowork: Which AI Agent Platform Is Right for Solo Founders?

2026-03-16T00:00:00Z

Anthropic Cowork offers a plugin for HR, one for engineering, one for financial analysis, and seven more besides. On paper, it covers the same organizational territory as Soleur. On examination, the architectures are different enough that the comparison determines which platform belongs in a serious founder's stack.

This article examines both platforms on the dimensions that matter: knowledge architecture, cross-domain coherence, workflow depth, pricing, and openness. The goal is an honest comparison.

What Each Platform Is

Anthropic Cowork is Anthropic's AI work product, offering 10 department-specific plugin categories built into the Claude interface: HR, Design, Engineering, Operations, Financial Analysis, Investment Banking, Equity Research, Private Equity, Wealth Management, and Brand Voice. Enterprise connectors include Google Workspace, DocuSign, Apollo, FactSet, LegalZoom, Harvey, Slack, and others. Cowork is included with every Claude subscription — Pro, Team, and Enterprise.

In March 2026, Anthropic's Cowork technology expanded into Microsoft 365. Microsoft launched Copilot Cowork on March 9, 2026, in close collaboration with Anthropic, bringing Claude's Cowork capabilities into Outlook, Teams, and Excel. It is currently in Research Preview, with broader availability planned for late March through the Microsoft Frontier program.

Where They Differ

The capability list overlaps until you examine the architecture.

Knowledge Architecture

Cowork plugins do not share a cross-domain knowledge base. The marketing plugin that wrote your brand positioning last week starts fresh today — it does not remember what was decided. Each plugin operates independently with no persistent memory that compounds across sessions or domains. You carry the context manually.

Soleur's compounding knowledge base persists and accumulates across every session. The brand guide informs every piece of marketing copy. Competitive analysis updates pricing strategy. Legal decisions flow into engineering constraints. The 100th session is dramatically more productive than the first — not because the models improve, but because the institutional knowledge compounds.

Microsoft Copilot Cowork moves the bar by adding Work IQ — intelligence drawn from a user's emails, files, meetings, and chats across Microsoft 365. It is a meaningful improvement over isolated task invocation. But it is workspace context, not a compounding cross-domain knowledge base. The next campaign does not know what was decided in the last architecture review. The legal audit does not automatically reference the product roadmap.

This is the structural distinction. It is not a feature gap. It is an architectural difference in what knowledge means.

Cross-Domain Coherence

Cowork's 10 plugin categories operate in silos. The engineering plugin does not read what the legal plugin produced. The Brand Voice plugin's output does not automatically feed the Financial Analysis plugin's reports. Connecting output from one domain to another requires the founder to carry the context manually between plugins.

Soleur's 65 agents share a unified knowledge base. The marketing copywriter agent reads the brand guide before generating content. The competitive intelligence agent's findings shape the sales battlecards. The legal compliance agent references the privacy policy when engineering ships a new data feature. Context flows across domains automatically because every agent reads from and writes to the same compounding knowledge base.

The difference between a collection of specialists and an organization is coordination. Soleur provides the coordination layer. Cowork does not.

Workflow Orchestration

Cowork executes individual tasks. Invoke a plugin, provide context, receive output. Multi-step workflows require manual chaining — copy findings from one plugin, provide them as context to the next, maintain consistency yourself across the chain.

Soleur orchestrates complete business processes through structured lifecycle workflows. The brainstorm-plan-implement-review-compound lifecycle runs across every domain. An engineering feature moves through specification, architecture review, implementation, security review, and knowledge capture — in sequence, with full domain context at each stage. A marketing campaign runs through the same structured lifecycle with marketing-domain agents at each step.

Microsoft Copilot Cowork adds multi-step plan execution within M365 — users describe intent, Cowork builds a plan and executes it across Outlook, Teams, and Excel. That is a genuine capability advance. The scope remains M365 workflows. The lifecycle management, cross-domain orchestration, and compounding memory that define Soleur's approach do not have an analog in Cowork's current architecture.

Pricing

Cowork is bundled with every Claude subscription. Claude Pro runs $20/month, Team at $25/seat/month with an annual commitment. If you already pay for Claude Pro, you already have Cowork. That value proposition is real.

Soleur's open-source core is free — Apache-2.0 licensed. Every agent, every skill, every line of code is public and inspectable. A paid tier for hosted features is planned but not yet released.

The cost comparison is not only monetary. If your operational context lives in Cowork's session-scoped memory, it exists only while that session is open. Soleur's institutional knowledge compounds in your repository, under your control, indefinitely. The knowledge you build using Soleur is yours — version-controlled, transferable, auditable.

Microsoft Copilot Cowork carries an additional license at $30/user/month on top of Microsoft 365. The M365 E7 bundle, which packages Copilot, Entra Suite, and Agent 365, is priced at $99/user/month and available from May 2026.

Openness

Cowork is proprietary. Anthropic offers plugin templates on GitHub, but the core platform is closed. You cannot inspect how agents make decisions, audit what data is retained, or modify the platform's behaviors.

Soleur is Apache-2.0 open source. The full codebase is public. Every agent's instructions, every skill's workflow, every guardrail's logic is readable and modifiable. The platform was designed, built, and shipped using itself — every PR reviewed, every feature compounded back into the system that built it.

Side-by-Side Comparison

Dimension	Anthropic Cowork	Microsoft Copilot Cowork	Soleur
Cross-domain knowledge base	None. Plugins are siloed.	Work IQ: workspace context from emails, files, chats.	Compounding. Grows across every session and every domain.
Domains covered	10 categories: HR, Design, Engineering, Ops, Finance (IB, ER, PE, WM), Brand Voice	Microsoft 365 applications: Outlook, Teams, Excel	8 departments: Engineering, Marketing, Legal, Finance, Operations, Product, Sales, Support
Workflow orchestration	Individual task invocation	Multi-step M365 task execution	Lifecycle workflows (brainstorm → plan → implement → review → compound)
Pricing	Included with Claude Pro ($20/mo), Team ($25/seat/mo annual)	$30/user/month add-on; M365 E7 bundle $99/user/month	Free (open source). Paid tier planned.
Open source	Proprietary	Proprietary	Apache-2.0. Full source code.
Terminal / Claude Code integration	Not applicable — web/desktop interface	Not applicable — Microsoft 365 surface	Native — runs inside Claude Code terminal workflow
Enterprise connectors	Google Workspace, DocuSign, Apollo, FactSet, LegalZoom, Harvey, Slack	Microsoft 365 native (Outlook, Teams, Excel, SharePoint)	MCP ecosystem via Claude Code
Current availability	Live (Pro, Team, Enterprise plans)	Research Preview (late March 2026 Frontier program)	Live (open source)

Who Each Platform Is For

Anthropic Cowork is the right choice if:

You use Claude primarily through the web or desktop interface
You need enterprise connectors built in — Google Workspace, DocuSign, FactSet, LegalZoom
You want investment banking, equity research, or private equity domain coverage
You want zero installation overhead — it is already in your Claude subscription

Microsoft Copilot Cowork is the right choice if:

Your workflow centers on Microsoft 365 — Outlook, Teams, Excel, SharePoint
You need enterprise data protection within your M365 tenant
Your organization is already on Microsoft 365 Business or Enterprise plans

Soleur is the right choice if:

You work in the terminal via Claude Code
You need institutional memory that compounds across sessions, not resets
You need cross-domain coherence — marketing that references legal, engineering that references compliance, finance that reflects competitive intelligence
You care about open-source transparency: auditable agents, modifiable workflows, your knowledge on your machine
You are building a company, not executing isolated tasks

The choice is not which platform lists more features. It is which architecture fits how you build.

The Compounding Advantage Over Time

The architectural difference does not show up in the first week. It dominates by month six.

A founder using Cowork for six months has executed hundreds of expert tasks. Each one was good. None of them informed the next. The brand positioning decided in the marketing plugin in January did not shape the investor memo written in the financial analysis plugin in March.

A founder using Soleur for six months has built something different: a knowledge base that encodes every architectural decision, every brand positioning choice, every competitive move, every legal precedent established across every project. That knowledge feeds every future session. The system does not just remember — it applies.

This is what compound engineering looks like at the company level. The knowledge base compounds. The agents get smarter. The system validates its own workflow. The 100th session is categorically more productive than the first.

Cowork's session-scoped model is a valid design choice for executing expert tasks. It is not a design choice for running a company.

Start Building

claude plugin install soleur

Explore the 65 agents, read what company-as-a-service means for solo founders, or get started in five minutes.

Frequently Asked Questions

Does Anthropic Cowork have a compounding knowledge base?

No. Cowork plugins operate independently without a shared cross-domain knowledge base. Each plugin executes tasks based on the context you provide in that session. Soleur's compounding knowledge base persists and grows across every session, making every future session more productive.

Is Soleur free compared to Cowork?

Cowork is bundled with Claude subscriptions — Claude Pro is $20/month. Soleur's core is free and open-source under the Apache-2.0 license. Both have free access. The difference is architecture: Cowork's knowledge is session-scoped; Soleur's compounds indefinitely in your own repository.

Can Cowork plugins share context with each other?

No. Cowork's 10 plugin categories are siloed — the engineering plugin does not read what the legal plugin produced, and the Brand Voice plugin's output does not automatically inform other plugins. Soleur's agents share a unified knowledge base so decisions in one domain inform every other domain.

What is Microsoft Copilot Cowork?

Microsoft Copilot Cowork is a collaboration between Microsoft and Anthropic that brings Claude's Cowork capabilities into Microsoft 365 — Outlook, Teams, and Excel. Launched in Research Preview on March 9, 2026, it enables multi-step background task execution within M365 applications. Broader availability is planned for late March 2026 through the Microsoft Frontier program.

Does Soleur integrate with Microsoft 365?

Soleur is a terminal-first platform running inside Claude Code. It does not integrate directly with Microsoft 365 applications. If your workflow centers on M365, Microsoft Copilot Cowork is the right choice for that surface. If your workflow centers on the terminal and Claude Code, Soleur provides the cross-domain depth and compounding knowledge that M365 integration does not offer.

Why Most Agentic Engineering Tools Plateau

2026-03-14T00:00:00Z

Your AI coding tools stop getting better after week two.

Session one hundred starts from the same blank slate as session one. The autocomplete gets faster. The models get smarter. But the system around them — the accumulated knowledge of what works, what broke, what to avoid — resets every time.

This is the plateau. And it is the central unsolved problem in AI-assisted engineering.

The industry has moved fast. Andrej Karpathy coined "vibe coding" in February 2025, then declared it passé exactly one year later when he introduced "agentic engineering" — the practice of orchestrating AI agents with human oversight instead of prompting one model at a time. That shift matters. But it only describes what changed in how we write code. It says nothing about what happens to the knowledge generated along the way.

The question that separates the tools that plateau from the ones that compound: does your system actually get better with use? Can you prove it?

This article traces where the industry is, where it stops, and what breaks through.

The Landscape: Where Most Tools Stop

AI-assisted development split into three distinct approaches over the past two years. Each one solved a real problem. None solved the deeper one.

Vibe Coding (2024–2025)

Ad-hoc prompting. Conversation as IDE. You describe what you want, the model generates code, you accept or reject. GitHub Copilot, Cursor, and Windsurf built massive businesses on this model — and for good reason. For prototypes and greenfield projects, it is fast.

Where it breaks: no memory between sessions, no specifications, no quality gates, no enforcement. Every conversation starts from scratch. The hundredth session is no smarter than the first.

Spec-Driven Development (2025–2026)

The first correction. Instead of prompting directly, you write a specification — a structured document describing what to build — and let agents execute against it.

Spec Kit, open-sourced by GitHub with over 76,000 stars, organizes work into four gated phases: specify, plan, tasks, implement. OpenSpec, backed by Y Combinator, takes a brownfield-first approach where specs live alongside code as long-term documentation. Kiro, from AWS, formalizes intent into structured specs using EARS notation. Tessl, founded by Snyk's Guy Podjarny and backed by $125 million in venture funding, maintains a registry of over 10,000 specs that prevent AI hallucinations about library APIs.

These are real advances. Capturing intent before coding produces better output than ad-hoc prompting.

But specs alone do not compound. A specification describes what to build. It does not describe what the team learned while building it, what mistakes to avoid next time, or how the workflow itself should change. The spec from project twelve looks the same as the spec from project one.

Compound Engineering (2025–2026)

The second correction. Every's Compound Engineering introduced a learning capture step after each unit of work. The workflow — plan, work, assess, compound — creates a loop where each feature generates documentation that informs the next. With 29 specialized agents, it brought the concept of compounding to the Claude Code ecosystem and inspired an important conversation about what it means for systems to learn.

This is closer. But compound engineering, as implemented by most tools, captures learnings into documentation files. Documentation is a starting point, not an endpoint. The deeper question is whether those learnings change how the system behaves — not just what it knows.

What Compound Knowledge Actually Looks Like

Compound knowledge is not a feature. It is an architectural property. A system either compounds or it does not, and the difference becomes visible over time.

Soleur is built on this principle. Every task it executes generates knowledge that feeds back into the system's rules, agents, and workflows — not just its documentation. Here is what that looks like in practice, drawn from real incidents in the project's compounding knowledge base.

Failure, Documentation, Rule, Enforcement

An AI agent edited files outside its designated workspace. Two hours of work disappeared — applied to the wrong directory, invisible until the session ended. In most systems, this is a lesson learned by a human and forgotten by the next session.

Here, the failure triggered a four-stage response:

Documentation. The incident was captured as a structured learning with root cause, symptoms, and prevention guidance.
Governance rule. The learning was promoted to the project's governance document — a living constitution of rules that grows with every failure.
Enforcement hook. A code-level guardrail was added that makes the mistake mechanically impossible. Not discouraged. Not documented. Impossible.
Routing. The insight was fed back to the specific skill that was active during the incident, making that skill's instructions permanently smarter.

This is the compounding arc. It took seventeen days from the initial failure to automated prevention. The system can never make that mistake again. No team member needs to remember the rule. No agent needs to read and follow a document. The guardrail is structural.

Hooks Beat Documentation

This leads to a contrarian insight about AI-assisted development: documentation-only rules fail.

Every enforcement hook in Soleur exists because a written rule was insufficient. Agents rationalize skipping prose instructions the way developers rationalize skipping code review at 5 PM on a Friday. The escalation path — prose rule fails, incident documented, code guardrail added — has repeated across dozens of failure classes. The result is a system with four mechanical guards that block known failure modes before they happen: direct commits to the main branch, destructive operations on isolated workspaces, merges without upstream synchronization, and commits containing unresolved conflicts.

These same guards enable multiple agents to work on separate features in parallel — each in its own isolated workspace, mechanically prevented from interfering with the others. Parallel execution is not a configuration option. It is a byproduct of the compounding arc: the guardrails that make it safe were themselves discovered through failures and enforced through hooks.

This is not a theoretical position. It is an empirical finding from hundreds of sessions.

The System Validates Its Own Workflow

Across eight features, a workflow gate called plan review — where parallel specialized reviewers analyze an implementation plan before any code is written — reduced scope by 30 to 96 percent.

Feature	Before Review	After Review	Reduction
Deduplication system	65 tasks	4 tasks	94%
Agent discovery	14+ files	1 file	93%
Rule automation	~395 lines	~15 lines	96%
Pre-flight checks	3 agents + 150 lines	23 lines inline	85%
Brand marketing	4 components	2 components	50%
Content generation	5 phases	4 phases	20%
Pipeline compliance	257 lines	55 lines	78%
Deviation analysis	7+ files, 30 criteria	1 file edit	86%

The shape is always the same: remove infrastructure that serves hypothetical future scale, keep the behavior change that delivers immediate value.

The compound system did not just execute this pattern — it generated the data that proved the pattern works. By the eighth confirmation, plan review was no longer an opinion. It was an empirically validated workflow gate. The system compounded its own evidence.

Self-Improving Instructions

The governance document that guides every session started as 26 lines. It now contains over 200 rules, each triggered by a real failure. When external research showed that oversized instruction files increase reasoning costs by 10–22 percent per interaction, the system applied that finding to itself — restructuring its own governance to contain only rules the AI would violate without being told on every turn.

The compound step does not just capture learnings into a file. It routes insights back to the specific agent or workflow that was active during the session. A lesson learned while using the planning workflow makes the planning workflow permanently better. A guardrail discovered during code review makes the review process permanently safer.

This is what it looks like when a system's governance document contains a rule that reads:

- Never commit directly to main [hook-enforced: guardrails.sh guardrails:block-commit-on-main]
- Never edit files in the main repo when a worktree is active [hook-enforced: worktree-write-guard.sh]
- Before merging any PR, merge origin/main into the feature branch [hook-enforced: pre-merge-rebase.sh]

Each line is a scar from a real incident. Each annotation — [hook-enforced] — means the system no longer relies on the AI reading and following the instruction. It is mechanically enforced.

How This Compares

What you need	Spec-driven	Compound engineering	Soleur
Capture intent before coding	Yes	Partial	Yes
Remember learnings across sessions	No	Yes	Yes
Self-improving rules and guardrails	No	No	Yes
Mechanical prevention of known failures	No	No	Yes
Full lifecycle (brainstorm through ship)	No	Partial (4 stages)	Yes (7+ stages)

Spec-driven development captures intent. Compound engineering captures learnings. Soleur compounds both — and feeds them back into the system's behavior, not just its documentation.

Beyond Engineering

Everything described above operates within engineering. But the principle extends further.

If compound knowledge transforms how engineering teams build software, what happens when the same architecture runs across every department — legal, marketing, sales, finance, operations, product, and support?

A brand guide created by a marketing agent informs the content strategy. A competitive analysis shapes pricing decisions. A legal audit references the privacy policy. Knowledge flows across domains because every agent reads from and writes to the same compounding knowledge base. The same principle extends to how those agents actually execute outside the codebase — by calling vendor APIs directly rather than driving server-side browsers, so the operational layer compounds the same way the engineering layer does.

This is the thesis behind Company-as-a-Service — a model where a single AI organization runs every department of a business. Not a copilot for code. Not an assistant for tasks. A full AI organization that plans, builds, reviews, remembers, and self-improves.

The engineering depth described in this article is the foundation. The full vision is bigger.

Start Building

Soleur runs 65 agents across 8 departments, all sharing a compounding knowledge base. Every decision teaches the system. Every project starts faster and more informed than the last.

The first billion-dollar company run by one person is not science fiction. It is an engineering problem.

Start building →

Frequently Asked Questions

What is compound engineering?

Compound engineering is the practice of designing AI-assisted development systems where each unit of work makes subsequent work easier. Unlike traditional development where technical debt accumulates, compound engineering inverts the curve: every feature, bug fix, and code review generates learnings that are captured, routed, and — in the most mature implementations — enforced mechanically.

How does knowledge compounding work in AI-assisted development?

A compound knowledge system follows a four-stage loop: work (execute a task), capture (document what was learned, including failures), route (feed the insight back to the specific agent or workflow that was active), and enforce (promote critical learnings to code-level guardrails that prevent recurrence). The key distinction from documentation-only approaches is the enforcement stage — where learnings change the system’s behavior, not just its memory.

What is the difference between vibe coding and agentic engineering?

Vibe coding, coined by Andrej Karpathy in February 2025, describes ad-hoc AI-assisted development: prompting a model conversationally and accepting the output. Agentic engineering, which Karpathy introduced in February 2026, describes the structured orchestration of AI agents with human oversight — using specifications, workflow gates, and quality checks to produce reliable output. The shift is from conversation to governance: from “tell the AI what you want” to “define the constraints, delegate execution, verify the results.”

Building an Operations Department for a One-Person Company

2026-03-10T00:00:00Z

Running a company -- even a one-person company -- requires tracking recurring expenses, managing domain registrations, configuring DNS and security settings, evaluating hosting providers, and making infrastructure procurement decisions. These are not engineering problems. They are operational logistics that a technical founder handles in spreadsheets, browser bookmarks, and memory. When the founder context-switches away from operations for two weeks, the state is lost. There is no institutional record of what was decided, what it costs, or why.

The AI Approach

The operations domain was built as a first-class function with a domain leader (COO) and three specialist agents:

COO Domain Leader (brainstormed 2026-02-22): Orchestrates the ops domain using the 3-phase pattern (Assess, Recommend/Delegate, Sharp Edges). Hooks into brainstorm Phase 0.5 for automatic consultation when operational decisions arise -- vendor selection, tool provisioning, expense tracking, infrastructure procurement.
Ops Advisor: Provides operational guidance on process and vendor decisions.
Ops Research: Researches hosting options, analytics solutions, domain registrars, and infrastructure providers. The analytics evaluation (Plausible vs. alternatives) and hosting decision (Hetzner CX22) were both products of this agent's research.
Ops Provisioner: Executes provisioning decisions -- domain DNS configuration, security headers, SSL settings.

The operational data lives in two structured files:

Expense Tracker -- A structured expense tracker with recurring and one-time costs:

Service	Amount	Category
GitHub Copilot Business	$10.00/mo	dev-tools
Hetzner CX22	EUR 5.83/mo	hosting
soleur.ai domain	$70.00/yr	domain (2-year .ai TLD)
Plausible Analytics	$0.00 (trial), then $9/mo	saas
Domain registration (one-time)	$140.00	domain

Domain Inventory -- Domain inventory with DNS records and security configuration:

4 A records (GitHub Pages IPs), 1 CNAME (www redirect), 1 TXT (domain verification)
Security: Full Strict SSL, HTTPS enforced, TLS 1.2 minimum, HSTS with preload, nosniff headers

The Result

The operations domain produced:

Structured expense tracking with provider, category, amount, renewal dates, and notes for every recurring cost.
Domain and DNS inventory with full record-level documentation and security configuration audit.
Hosting decision: Hetzner CX22 selected (2 vCPU, 4 GB RAM, 40 GB SSD, eu-central datacenter) at EUR 5.83/month -- the result of ops-research evaluating options against requirements.
Analytics decision: Plausible Analytics selected as a cookie-free, GDPR-compliant analytics solution -- which directly simplified the Cookie Policy (no tracking cookies to disclose) and the GDPR Policy (no consent mechanism required for analytics).
Infrastructure security: Cloudflare configuration with strict SSL, HSTS preload, and proper GitHub Pages wiring.
3 brainstorms covering COO domain leader design, ops provisioner scope, and domain purchase evaluation.
3 archived specs covering ops directory, ops research agent, and ops provisioner implementation.

The Cost Comparison

According to Chore's fractional COO guide, a fractional COO or operations consultant for an early-stage startup charges $100-250/hour (as of 2026). Setting up expense tracking, evaluating hosting providers, configuring DNS and security, selecting analytics tools, and documenting infrastructure decisions is typically a 15-25 hour engagement: $1,500-6,250. An IT services firm charges $2,000-5,000 for DNS configuration, SSL setup, and security hardening. The ongoing value is in the structured documentation: when the founder returns to operations after weeks of engineering work, the institutional record is there. No context reconstruction required.

The Compound Effect

The operations data feeds directly into other domains. The expense tracker informed the business model evaluation in the business validation document (the cost structure constrains pricing). The Plausible Analytics decision simplified three legal documents (Cookie Policy, GDPR Policy, Privacy Policy) by eliminating tracking cookies from the disclosure requirements. The Cloudflare security configuration became a learning that applies to any future domain or infrastructure provisioning. The COO domain leader now participates automatically in brainstorm sessions when operational decisions arise -- the founder does not need to remember to "check with ops" because the system routes operational questions to the right agents. The expenses file has a last_updated field and review cadence, so the system itself flags when the data is stale.

Frequently Asked Questions

Can AI manage company operations?

Yes. Soleur's operations domain includes a COO domain leader and specialist agents for expense tracking, vendor research, infrastructure provisioning, and security configuration. The system maintains structured documentation that survives context switches — no state is lost between sessions.

How long does setting up AI operations management take?

The full operations function — expense tracking, hosting evaluation, DNS configuration, analytics selection, and security hardening — was built across several sessions. According to Chore's fractional COO guide, operations consultants charge $100-250/hour (as of 2026), putting equivalent scope at $1,500–$6,250 over 15–25 hours.

Who benefits from AI operations management?

Solo founders who handle operational logistics alongside engineering. The platform captures every decision in structured documentation so returning to operations after weeks of other work requires no context reconstruction.

How We Generated 9 Legal Documents in Days, Not Months

2026-03-10T00:00:00Z

Soleur needed a full legal compliance suite for its documentation site (soleur.ai) and platform distribution. The requirements: Terms & Conditions, Privacy Policy, Cookie Policy, GDPR Policy, Acceptable Use Policy, Data Protection Disclosure, Disclaimer, and two Contributor License Agreements (Individual and Corporate). These documents needed to address dual-jurisdiction concerns (French incorporation under Jikigai at 25 rue de Ponthieu, 75008 Paris, plus global distribution including EU/GDPR and US users), reference the correct data controller/processor distinctions for a local-first architecture, and maintain cross-document consistency across all 9 documents.

A solo founder building a software platform does not know how to write GDPR-compliant data protection disclosures or draft CLA patent grant clauses that account for French moral rights law. These are domains where getting it wrong creates real legal exposure.

The AI Approach

The legal domain was built as a first-class organizational function: two agents (legal-document-generator and legal-compliance-auditor) plus a domain leader (CLO) that orchestrates them. The workflow proceeded in phases:

Brainstorm (2026-02-19): Defined scope -- 7 initial document types, jurisdiction requirements, dogfooding model.
Generation: The legal-document-generator agent produced first drafts from company context (entity name, address, product architecture, data practices).
Audit: The legal-compliance-auditor ran regulatory benchmarking against GDPR Articles 13/14, CCPA requirements, ICO cookie guidance, and CNIL recommendations.
Iteration: Multiple rounds -- governing law was corrected from Delaware (inherited from US templates) to French law/Paris courts (2026-03-02 brainstorm). CLAs were added in a separate cycle (2026-02-26) after identifying IP risks with BSL 1.1 licensing.
Benchmark: Peer comparison against Basecamp, GitHub, and GitLab policies for structural gap analysis.

The Result

9 legal documents totaling 17,761 words across 1,872 lines of structured markdown with HTML templates:

Document	Words	Effective Date
Terms & Conditions	2,565	Feb 20, 2026
Privacy Policy	2,114	Feb 20, 2026
GDPR Policy	2,988	Feb 20, 2026
Data Protection Disclosure	2,273	Feb 20, 2026
Disclaimer	1,975	Feb 20, 2026
Acceptable Use Policy	1,833	Feb 20, 2026
Cookie Policy	1,473	Feb 20, 2026
Individual CLA	1,247	Feb 26, 2026
Corporate CLA	1,293	Feb 26, 2026

Each document addresses dual-jurisdiction (French governing law with mandatory-law savings clauses for EU consumers under Rome I Art. 6), references the correct data architecture (local-first, no server-side data collection), and cross-references related documents. All deployed to the live documentation site at soleur.ai.

The Cost Comparison

According to Robert Half's 2026 Legal Salary Guide, senior technology lawyers in France or the US command EUR 300-500/hour for SaaS legal document drafting (as of 2026). A full legal compliance suite covering 9 documents -- with cross-document consistency, dual-jurisdiction coverage, and regulatory benchmarking -- typically runs 30-50 billable hours. That puts the cost at EUR 9,000-25,000 and 3-6 weeks of elapsed time. A legal startup package from a boutique firm starts around EUR 5,000 for a basic set without CLAs or regulatory benchmarking. The AI-generated suite was produced across several sessions over 2 weeks, with multiple audit and revision cycles included.

The Compound Effect

The legal documents feed forward in three ways. First, the legal-compliance-auditor agent now exists as a reusable capability -- any Soleur user can audit their own project's legal documents against the same regulatory checklists. Second, the CLO domain leader participates in brainstorm sessions automatically when legal implications are detected, so future product decisions get legal assessment without a separate workflow. Third, the governing law correction (Delaware to France) was caught by the system's own audit capability and propagated across all 9 documents consistently -- exactly the kind of cross-document coherence that falls apart when using separate tools or templates for each document.

Frequently Asked Questions

Can AI generate legal documents?

Yes. Soleur's legal domain agents produce Terms & Conditions, Privacy Policies, GDPR Policies, CLAs, and more with dual-jurisdiction coverage. All documents are generated as drafts requiring professional legal review — the platform accelerates production, not replaces counsel.

How long does AI legal document generation take?

Nine legal documents totaling 17,761 words were produced across several sessions over two weeks, including multiple audit and revision cycles. According to Robert Half's 2026 Legal Salary Guide, technology lawyers charge EUR 300-500/hour (as of 2026), putting equivalent scope at EUR 9,000–25,000 over 30–50 billable hours.

Who is AI legal document generation for?

Solo founders and small teams who need a full legal compliance suite without the upfront cost of a law firm engagement. The generated documents address jurisdiction requirements, cross-document consistency, and regulatory benchmarking — then a lawyer reviews the output.

Tracking 17 Competitors in One Session -- With Battlecards

2026-03-10T00:00:00Z

Soleur operates in a market that moves on a weekly cadence. Between February 24-25 alone, Anthropic launched engineering plugins for Cowork, Cursor announced a $29.3B valuation with cloud agents, GitHub Copilot CLI went GA with memory and sub-agents, and Notion 3.3 shipped autonomous Custom Agents. A solo founder cannot track 16+ competitors across two threat tiers, research their latest product changes, assess convergence risk, update positioning, and generate actionable sales battlecards -- all while shipping product. This is a full-time competitive intelligence analyst role.

The AI Approach

The competitive intelligence function was built as a product domain capability under the CPO domain leader, using the competitive-intelligence agent and cascading specialist agents:

Tiered Framework: Competitors were organized into Tier 0 (platform threats -- existential risk from companies that control the model, API, or IDE) and Tier 3 (CaaS/full-stack business platforms). Each tier uses a structured overlap matrix with columns for competitor, equivalent Soleur capability, overlap level, differentiation, and convergence risk.
Research Phase: Live web research against 30+ sources (TechCrunch, CNBC, GitHub Blog, VentureBeat, official changelogs, product pages, and independent reviews). Each claim is sourced with URLs.
Analysis Phase: Material changes since the previous review are identified and assessed for impact on Soleur's positioning. New entrants are flagged separately.
Cascade: After the primary analysis, four specialist agents ran in parallel:
- Growth Strategist: Generated a content gap analysis with 5 identified gaps and a 4-week content calendar.
- Pricing Strategist: Built a competitive pricing matrix across all 16 competitors.
- Deal Architect: Created 4 sales battlecards for highest-overlap competitors (Anthropic Cowork, Cursor, Notion AI, Tanka).
- Programmatic SEO Specialist: Flagged 3 stale pages, 7 new comparison pages to create, and 5 pages to monitor.

The Result

A 2,843-word competitive intelligence report containing:

Executive summary with material change assessment
7 Tier 0 competitors analyzed in structured overlap matrices (Anthropic Cowork, Claude Code Native, Cursor, GitHub Copilot, OpenAI Codex, Windsurf, Google Gemini)
10 Tier 3 competitors analyzed (SoloCEO, Tanka, Lovable, Bolt.new, v0.dev, Replit, Devin 2.0, Notion AI, Systeme.io)
3 new entrants identified and categorized
6 prioritized recommendations with specific actions
37 cited research sources with URLs
4 cascade outputs: content gap analysis, pricing matrix, 4 sales battlecards, SEO refresh queue

The report directly updated the business validation document's competitive assessment from PASS to CONDITIONAL PASS based on the Tier 0 threat materialization.

The Cost Comparison

While competitive intelligence analysts earn approximately $56/hour as employees according to Salary.com, external consultants typically command $150-300/hour (as of 2026). A comprehensive competitive landscape analysis covering 17 competitors with overlap matrices, convergence risk assessments, sourced research, and actionable recommendations typically runs 40-60 hours of analyst time: $6,000-18,000. The cascade outputs (battlecards, pricing matrix, content strategy, SEO queue) would normally be separate engagements -- a set of 4 sales battlecards runs $2,000-4,000 from a sales enablement consultancy. Total equivalent: $8,000-22,000 and 4-8 weeks. The AI-produced analysis was generated in a single session with cascade, including all downstream artifacts.

The Compound Effect

The competitive intelligence feeds directly into three other domains. The pricing strategy references the competitive pricing matrix. The sales battlecards are structured for objection handling in real conversations. The content strategy identifies gaps that the marketing domain can execute against. The business validation document was updated with new threat assessments that changed the overall verdict. And the next scan (review cadence: quarterly, with 30-day monitoring for Notion Custom Agents) starts from the existing framework rather than from scratch -- the analysis compounds.

Frequently Asked Questions

Can AI run competitive intelligence analysis?

Yes. Soleur's competitive-intelligence agent researches competitors across multiple tiers, builds overlap matrices, assesses convergence risk, and generates actionable recommendations — all sourced with URLs from live web research against 30+ sources.

How long does AI competitive analysis take?

The full competitive intelligence report covering 17 competitors with overlap matrices, battlecards, pricing matrix, and content strategy was generated in a single session. While CI analysts earn approximately $56/hour as employees per Salary.com, external consultants command $150-300/hour (as of 2026), putting equivalent scope at $6,000–$18,000 over 40–60 hours.

Who benefits from AI competitive intelligence?

Solo founders and small teams who cannot dedicate a full-time analyst to tracking competitors. The platform monitors market movements, generates battlecards for sales conversations, and feeds findings into pricing, content, and positioning strategies automatically.

Running a Business Validation Workshop With AI Gates

2026-03-10T00:00:00Z

A technical founder building a product they use daily faces a specific blind spot: they cannot distinguish between "I need this" and "the market needs this." Soleur had 280+ merged PRs, 65+ agents across 8 domains, and daily dogfooding across every function -- but zero external users validating the multi-domain thesis. The question was not "does the product work?" but "does the problem statement resonate with anyone besides the builder?"

The AI Approach

The business validation was run through the product domain, orchestrated by the business-validator agent following a structured gate framework:

Gate 1 -- Problem: Define the problem statement in solution-free language. Assess whether the pain is real, structural, and independently articulable.
Gate 2 -- Customer: Define the target customer profile with specificity. Identify reachable examples. Test whether the segment is tight enough.
Gate 3 -- Competitive Landscape: Map the full competitive landscape across 6 tiers (platform-native, closest substitutes, no-code agent platforms, CaaS, agent frameworks, DIY stacks). Identify structural advantages and vulnerabilities.
Gate 4 -- Demand Evidence: Assess direct and indirect demand signals. Apply a kill criterion: if demand evidence is below threshold, flag it.
Gate 5 -- Business Model: Evaluate revenue model options against the customer profile and competitive landscape.
Gate 6 -- Minimum Viable Scope: Define what must be tested and why breadth is the minimum scope (not a nice-to-have).

Each gate produces a PASS, CONDITIONAL PASS, FLAG, or FAIL verdict. A FLAG at Gate 4 triggers a kill criterion review.

The Result

A 3,627-word business validation document containing:

Problem assessment: PASS. Twofold framing (capacity gap + expertise gap) validated as real, structural, and solution-independent.
Customer assessment: CONDITIONAL PASS. Specific profile defined (technical solo founders across all stages), but named contacts fell below the 5-person threshold.
Competitive landscape: PASS (later updated to CONDITIONAL PASS after Tier 0 threat materialization). 19 competitors mapped across 6 tiers with structural advantages and vulnerabilities.
Demand evidence: FLAG with OVERRIDE. Kill criterion triggered at Gate 4 -- only 1-2 informal conversations versus the 5+ threshold. User chose to proceed with strong external signals (Naval Ravikant, Amodei predictions, solo founder growth statistics).
Business model: CONDITIONAL PASS. Four revenue model options evaluated with competitor pricing context.
Minimum viable scope: PASS. Breadth validated as minimum scope via coherence check.
Final verdict: PIVOT -- from building features to validating the thesis with real users. A 7-step action plan defined.
Vision alignment check: Validated that the pivot does not contradict the brand guide's positioning.

The Cost Comparison

According to Clutch.co's consulting pricing data, startup strategy consultants and fractional CPOs charge $200-400/hour for business validation work (as of 2026). A structured validation workshop covering problem definition, customer profiling, competitive landscaping, demand assessment, business model evaluation, and scope definition typically runs 20-40 hours: $4,000-16,000. A startup accelerator provides similar validation as part of a cohort program (valued at $10,000-25,000 in advisory). The AI-produced validation was generated through the brainstorm workflow with the business-validator agent, iterated through multiple sessions, and updated when new competitive data invalidated prior assessments.

The Compound Effect

The business validation is the strategic anchor for the entire project. The competitive intelligence report references it as the baseline. The pricing strategy is constrained by its business model assessment. The PIVOT verdict directly changed the project's activity from feature development to user validation. The kill criterion at Gate 4 -- demand evidence is thin -- is the most important finding in the entire knowledge base, because it prevents the founder from building in a vacuum. Future validation cycles (after the 10 user interviews prescribed in step 3) will update this document, and every downstream artifact (competitive strategy, pricing, content calendar) will re-derive from the updated verdicts.

Frequently Asked Questions

Can AI validate a business idea?

Yes. Soleur's business-validator agent runs a structured 6-gate validation workshop covering problem definition, customer profiling, competitive landscaping, demand assessment, business model evaluation, and minimum viable scope. Each gate produces a verdict — PASS, CONDITIONAL PASS, FLAG, or FAIL.

How long does AI business validation take?

The full 6-gate validation was completed through the brainstorm workflow in a fraction of the time a consultant requires. According to Clutch.co's consulting pricing data, strategy consultants charge $200-400/hour (as of 2026), putting equivalent scope at $4,000–$16,000 over 20–40 hours.

When should I use AI business validation?

Before committing significant engineering time to a product. The validation workshop is designed to catch blind spots — especially the gap between "I need this" and "the market needs this" — before building features that may not resonate with customers.

From Scattered Positioning to a Full Brand Guide in Two Sessions

2026-03-10T00:00:00Z

Soleur had strong informal positioning language scattered across READMEs and commit messages -- "Company-as-a-Service," "infinite leverage," "soloentrepreneurs" -- but nothing formalized. No brand guide, no defined voice, no color palette, no typography system, no channel-specific tone guidelines. The README used marketing language that had never been tested against a framework. Without a brand guide, every piece of outbound content (Discord announcements, GitHub PR descriptions, documentation site copy, legal document tone) was a one-off decision, and consistency was accidental.

The AI Approach

The brand was built through a multi-phase workflow using the marketing domain:

Brand Architect Workshop (2026-02-12): The brand-architect agent ran an interactive workshop covering mission, vision, positioning, voice, messaging pillars, and visual direction. This was not a template fill-in -- it was a structured conversation that produced decisions documented in a brainstorm.
Visual Identity Exploration (2026-02-13): Four distinct visual concepts were developed and evaluated -- Solar Forge (gold on dark, serif headlines), First Light (warm off-white, gradient), Stellar (deep blue, violet), and Solaris (amber gradient, geometric). Each was assessed against the brand positioning, competitive differentiation, and practical constraints. Solar Forge was selected for its alignment with the Tesla/SpaceX audacity positioning and its deliberate departure from the rounded-corner, pastel-gradient aesthetic of every other dev tool.
Brand Guide Formalization: The decisions were consolidated into a single structured document that became the source of truth.
Voice Reviewer Integration: The brand-voice-reviewer agent was created to audit outbound content against the guide before publishing.

The Result

A 1,293-word brand guide covering:

Identity: Mission statement, target audience definition, positioning ("not a copilot, not an assistant -- a full AI organization"), tagline ("The Company-as-a-Service Platform"), thesis statement.
Voice: Brand voice definition (ambitious-inspiring), tone spectrum table across 5 contexts (marketing hero, product announcements, technical docs, community, error messages), do's and don'ts list with 7 directives each, example phrases for announcements, product descriptions, community replies, and system messages.
Visual Direction: 9-color palette with hex values and usage roles (Solar Forge direction), 5-row typography system (Cormorant Garamond for headlines, Inter for UI, JetBrains Mono for code), style rules (sharp corners, no stock photos, subtle motion, generous whitespace).
Channel Notes: Specific guidelines for Discord, GitHub, and website/landing page -- including structural patterns (hero pattern, section pattern, footer tagline).

The guide has been reviewed twice (last reviewed 2026-03-02) and governs all content across the project.

The Cost Comparison

According to Clutch.co's branding agency pricing data, a brand strategy agency charges $5,000-15,000 for a brand guide of this scope (as of 2026). The low end covers a basic positioning workshop and style guide; the high end includes visual identity exploration with multiple concepts, channel-specific guidelines, and a tone of voice framework. Timeline is typically 4-8 weeks including discovery sessions, concept presentations, and revision rounds. A freelance brand strategist charges $2,000-5,000 for a lighter version. The AI-produced guide was created across two brainstorm sessions and a formalization step, with ongoing review cycles built into the system.

The Compound Effect

The brand guide is the single most referenced document in the knowledge base. The legal documents use its voice guidelines. The documentation site implements its color palette, typography, and layout patterns. Discord announcements are reviewed against its tone spectrum. The competitive intelligence report's positioning recommendations reference it. The brand-voice-reviewer agent uses it as a runtime reference for content audits. Every new document or public-facing artifact inherits consistency from this one artifact without requiring the founder to remember or enforce brand rules manually. The 100th piece of content is as on-brand as the 1st.

Frequently Asked Questions

Can AI create a brand guide?

Yes. Soleur's brand-architect agent runs an interactive workshop covering mission, vision, positioning, voice, visual direction, and channel guidelines. The output is a structured brand guide document — not a template fill-in but a set of decisions from a guided conversation.

How long does AI brand guide creation take?

The brand guide was produced across two brainstorm sessions and a formalization step. According to Clutch.co's branding agency pricing data, a traditional brand agency charges $5,000-15,000 for the same scope and takes 4–8 weeks (as of 2026). The AI-produced guide includes identity, voice, visual direction, and channel-specific guidelines.

Who is AI brand guide creation for?

Solo founders and small teams who need professional brand consistency without hiring a brand agency. The brand guide becomes the single source of truth that governs all content — legal documents, documentation, Discord announcements, and marketing copy.