Empyre documentation
Empyre turns a plain-language description of a business into a deployed software company operated by eight specialised AI agents.
This page describes what actually happens, in order, and what you get at the end.
What happens when you launch
- Describe the businessPlain words. What it does, who it is for. No technical specification required.
- Infrastructure is provisionedA repository, a deployment target, an encrypted environment vault, and internal authentication keys so the product's own sign-up works.
- The CTO buildsThe first CTO cycle produces the application: the interface, the architecture and the core product. This is the run that decides the shape of everything after it.
- The product is marked readyDeployment is gated until the core product actually works. The CTO flips that flag; agents cannot deploy an unbuilt product.
- It deploys to a live addressEvery business gets a one-word address of the form yourword.empyre.site, free on every plan, with HTTPS and no DNS for you to configure.
- The other agents take overThe CMO writes positioning and launch content, the CLO produces terms and privacy, the Tester exercises the product and reports what broke, the CFO watches spend.
- Weekly cycles continueWhile the plan is active, agents keep maintaining, fixing and hardening the product. This is the part that distinguishes Empyre from an app builder.
The eight agents
| Agent | Responsibility |
|---|---|
| CEO | Sets direction, turns your instructions into work for the other agents, and reports back. |
| CTO | Writes the code, commits it, and deploys the product. Runs security scans and SEO audits against what it shipped. Owns the technical build. |
| CMO | Publishes an article a day to the product's built-in server-rendered blog; decides the positioning every other channel then delivers; improves SEO and answer-engine visibility; posts to the connected X account; researches competitors; and — on Growth and above, a week after launch — runs Google Ads campaigns. |
| CFO | Watches spend, approves or refuses cost, and keeps the business inside its budget. |
| CSO | Works the customer support inbox, resolves tickets, and escalates real bugs to the CTO as defects. |
| CLO | Terms, privacy policy, contract review and e-signature — the legal surface a real product needs. |
| Creative | Generates the brand imagery, on-brand variants, product photography, cut-out assets, short marketing video and captions the product and its campaigns ship with. |
| Tester | Exercises the product, runs security and SEO checks, signs off or blocks the release, and files defects back to the CTO. |
What the agents can actually do
Empyre is routinely described as a code generator, which understates it by about half. Writing and deploying the application is one item on this list — the rest is what turns a deployment into a business.
Writes and ships the product
A real application, committed to a repository you control and deployed to a live HTTPS address. Not a preview sandbox. Starting from scratch, Empyre generates a production web application and puts it live. Bringing an existing repository, the agents continue it IN THE LANGUAGE IT IS ALREADY WRITTEN IN — Python and Django, Ruby and Rails, PHP and Laravel, Go, Rust, Node — and host it on managed infrastructure when that hosting cannot run it (Growth and above; Starter hosts an imported project on managed hosting, or on your own server account). They never rewrite someone else's working product into a house stack.
Deploys inside thirty minutes, or it has failed
The deadline is set when the company is created — thirty minutes from the moment the founder pressed submit — and it is written into every agent's prompt as a hard ceiling rather than a target to pace against. It is not chosen by an agent and it cannot be pushed out; the CEO may only bring it forward. A build cycle runs every thirty seconds until the first commit lands, and the deploy is triggered by the platform on that commit rather than waiting for an agent to remember. Founders who do not know what to build can press Surprise me and get a complete brief and a company building from it on the same click. Most AI builders quote no time at all, because the honest answer is that nobody is holding them to one.
Never runs out of ideas for you
Surprise me on the launch screen invents a complete company on the spot — what it is, who it serves and how it makes money — and starts building it on the same click, with the prompt box empty. It is generated per press from a random domain, constraint and revenue model rather than drawn from a list, so pressing it ten times gives ten different businesses. Every other builder's demo mode is the same three example apps.
Shows you every file as it is written
The Executive Workforce console is a live transcript, not a progress bar. While a cycle runs you see the executive's own message, then the concrete steps as they happen — Reading components/nav.tsx, Creating app/page.tsx, Editing package.json, Deployed to yourword.empyre.site — and when the run ends, a report of what actually landed. Every line is written by the code that performed that step, so a file is never listed until the commit carrying it has succeeded, and create versus edit is resolved against the repository's real tree instead of guessed. The report is composed from those verified events, never from asking a model to describe its own work. Other agent products show a spinner and a summary written afterwards, which is the one moment a model has every incentive to be generous about itself.
Opens the whole codebase in a real editor in the browser
Every company has a Code button on its dashboard that opens empyre.dev/code/
Gives it a free address
Every business gets a one-word yourword.empyre.site address on every plan, live at first deploy. Every paid plan can point a domain you already own at it instead.
Hosts it, and keeps hosting it — including stacks that hosting cannot run
Hosting is not a step the founder does afterwards; it is done before they see the product. A company built from scratch is a live web application, with TLS issued automatically and no DNS record to create — the yourword.empyre.site address is attached to the project directly, so it is live at the first deploy rather than after a propagation wait. Empyre pays for that hosting on every plan. A company built from an IMPORTED repository is different and is the case most builders simply refuse: if the stack is Rails, Django, Go, PHP or anything with a Dockerfile, that hosting cannot run it, so from Growth up Empyre provisions and manages real servers for it, packs several tenants onto a machine to keep the cost sane, and continues the project in the language it is already written in rather than rewriting it. Starter hosts an imported project on managed hosting, or on your own server account. A custom domain you already own can be pointed at any of it on every paid plan, and the exact DNS records are read live from the host rather than printed from a hardcoded list that goes stale. Nothing here needs an account with a hosting provider, a credit card at one, or a deploy pipeline you maintain.
Builds working end-user accounts, three ways in
Sign-up and sign-in work on the first deploy with no auth provider to register for and no key to paste: email and password, Continue with Google, and Continue with Relay, on every plan. Accounts are ON BY DEFAULT — the agent has to state a reason to leave them out, rather than deciding silently. The OAuth exchange happens on Empyre's own backend, so no credential for it exists anywhere in the generated repository for an agent to mishandle, and the customers of one company are never in the same identity space as another's.
Takes real payments, including subscriptions, with no Stripe key to paste
On the paid plans a founder connects Stripe once through Empyre and the business can charge cards and bill recurring subscriptions — one-off purchases, monthly or annual plans, trials, and a customer billing portal — without ever handling an API key. Every charge is created directly on the business's OWN Stripe account, so the money lands in their balance, Stripe bills them its fees directly, and refunds and chargebacks come out of that same balance. Empyre's balance is never in the path, not even momentarily: no platform charge, no transfer, no cut. Founders who prefer to run their own Stripe account can still paste their own key instead, on any plan. If a product needs to charge customers before either is set up, the CTO still ships the working product and its server-enforced customer paywall, opening the company's own staffed inbox so an interested buyer reaches a human instead of a checkout that cannot take money. It becomes a real checkout automatically the moment payments go live.
Ships a product on day one, not a landing page
The first deployment is the working product, not a door to it: the signed-in screen where the customer actually does the job, with a real customer experience and a paid path whose limit is enforced on the server. Most AI builders hand over a hero section, a sign-up form and nothing behind the sign-up, which is a brochure with a lock on it. Empyre decides the customer revenue boundary before it writes the data model, because that line shapes the schema and retrofitting it is how a product ends up with no ceiling and no way to buy.
Keeps shipping after launch, and every change goes live the same hour
An agent commit is deployed by the cycle that made it. The platform publishes only a build that succeeded, so a change that does not compile leaves the previous deployment serving rather than breaking the site, and a green build that answers 404 is repaired and redeployed automatically. There is no staging branch a founder has to remember to release and no human approval step in the way. This matters more than the first deploy: a product that is built in thirty minutes and then never improves is a demo, and most autonomous builders stop at the demo because nothing in them ever ships a second time.
Stops to decide what to build next, on a schedule it does not choose
Roughly one engineering cycle in five is spent researching what would make the product worth MORE money rather than shipping — which the platform decides, not the agent, from a counter it keeps. That distinction is the whole feature: an agent asked to "occasionally step back and think strategically" has no memory of how many cycles it has run, so it either never does it or does it every time. On a research cycle the engineer reads the product as it actually is, reads the live site the way a stranger would, and reads what comparable products in that market charge more for, then writes the conclusions to a roadmap the next build cycles work from. What it actually read is recorded against each item, and an item with nothing behind it is marked as an untested hunch rather than sitting beside the researched ones looking like one. Research is skipped while any critical or high defect is open, because a product with a broken signup does not need a feature, and skipped again once the roadmap is full of things nobody has built. It costs no extra cycles at all — it changes what an already-scheduled cycle spends itself on. Without this, an autonomous builder converges on a well-built version of whatever you described on day one, and nobody pays more for that.
Builds in the language the founder wrote in
A brief written in German produces a German product, and the same for any language: headings, buttons, errors, emails, empty states, legal pages and meta descriptions, with the page language, date and currency formatting to match. The marketing follows it, and the search keywords are the ones that market actually types rather than a word-for-word translation of the English ones, which is the half a translation pass always gets wrong and the half that decides whether anyone arrives. Written natively, not machine-translated; only the code identifiers stay English.
Prices it the way its market actually prices things
Most AI builders produce the same three-tier monthly price page whatever you asked them to build, because a subscription is the only revenue model they know how to draw. Empyre's CEO names the revenue model before the CTO writes a number, and the CTO builds that one: a subscription with a genuinely discounted annual plan alongside the monthly, a one-time purchase, metered usage or prepaid credits, a percentage commission on each transaction for a marketplace or a booking product, a per-trade fee or spread for an exchange, a settlement fee on a winning bid for an auction, or a free product earning somewhere else entirely. A marketplace, an exchange and an auction all earn per transaction and none of them gets tiers or a pricing page. A product that settles on-chain is not given a Stripe checkout it cannot use — it asks the founder for their own receiving address, one per chain, and never generates or guesses one, because a wallet address invented by a model sends a real customer's money somewhere nobody can reach. Until a payment rail exists the product displays no price, no take rate and no deposit address at all, rather than publishing terms it cannot honour.
Markets it, and remembers what it already said
The CMO researches topics and publishes articles to the product's built-in server-rendered blog, writes positioning and launch copy, runs SEO audits to improve search and answer-engine visibility, researches competitors, and runs Google Ads campaigns on Growth and above. It starts every cycle holding what the company has actually done: its own previous posts quoted back in full, which credit balance is left, what failed and why, and which channels are open at all. That is the difference between a marketing agent and a marketing agent that repeats itself — a model shown a summary of its last post writes the last post again, so it is shown the post. Repetition is judged by idea rather than wording, so rephrasing yesterday is still yesterday. It is never given a traffic or conversion figure the platform does not actually hold, and it is told when paid advertising is blocked and why, rather than spending a cycle discovering it. On its first cycle for a company it does the whole research pass in one run — reads the live product, derives the company's own writing voice from the copy that already exists, and writes down what the product does and deliberately does NOT do, with anything it could not verify recorded as unknown rather than guessed. Those files are what every later article is written from, so it is not starting from nothing each time.
Makes the brand assets
Brand imagery, on-brand variants, product photography, background-removed cut-outs, short marketing video, and the captions to go with them.
Covers the legal surface
Terms of service, privacy policy, contract review and e-signature.
Gives every company a real inbox on day one
Each business is issued its own address the moment it is created — [email protected], matching the acme.empyre.site it is served from — on every plan. There is no mail provider to register for, no DNS to configure and no mailbox to provision. Customer mail threads inside Empyre using standard Message-ID and References headers, and the founder replies as the company from the dashboard. The founder answers first: they write the reply themselves, with their own subject line and attachments, and if they have not answered within twenty-four hours the CSO answers for them on its next cycle — so a customer is never left waiting on a founder who is asleep, and a founder who wants to handle it personally is never spoken over. The CSO also escalates complaints to the CTO as defects. When a generated product has no payment method connected yet, its own site carries a Talk to a human button pointing at that address, so a visitor who cannot buy anything can still reach a person. Other builders hand you a contact form that posts nowhere.
Distributes the company on X, at a pace the plan buys
On any active paid plan the CMO can publish to the founder's OWN X account after they authorize it and switch autopilot on — never before, and disconnecting stops it immediately. How often it posts scales with the plan — a higher plan is a company that shows up several times a day rather than occasionally — and the top plan also queues one ahead for later in the same cycle. Link posts cost more because X charges more for them, and every post is billed as credits. Posting is bounded by credits and by having something worth saying: an agent with nothing worth saying skips it, and posting filler is treated as a failure rather than as activity. Whether a post contains a link is decided by the platform from the content, never by the agent, and every post is listed with what it actually cost. This is the difference between an agent that drafts marketing and one that is connected to a channel and publishes on a schedule.
Gets your product found
Your company's SEO and answer-engine visibility starts before the first agent cycle. Every generated business ships a server-rendered blog, schema.org JSON-LD on every page, a sitemap containing every real URL, AI-crawler-aware robots.txt, llms.txt, and RSS. The CMO publishes the articles that fill that surface — one a day, on every plan, counted by the platform rather than by the agent — and the agents audit the live site for title and meta description, canonical correctness, crawler access, structured data, and content that remains readable without JavaScript, then fix what they find. Most builders hand you a site and leave discovery entirely to you.
Measures whether AI assistants recommend you, and writes against what they say instead
Buyers increasingly ask an assistant what to use rather than typing a search. So the CMO writes the thirty to forty questions a real buyer would ask about this product's category — best-in-category, alternatives to a named incumbent, X versus Y, the best option for one specific use case, pricing, implementation — and the PLATFORM puts each one to a model that has been told nothing whatsoever about the company, then reads the answer for the company's name and its domain. The verdict is a fact about a real answer rather than the agent's opinion of itself, which is the difference between a measurement and a model flattering the company it was just briefed on. A new company almost never comes up, and that is the expected result rather than the finding: the finding is which questions buyers actually ask and WHO gets recommended instead, and that becomes a ranked content pipeline the CMO writes against, one article a day. Re-run on a schedule the platform keeps, so a question that starts naming the company is a change you can see. Nothing to connect, no keyword tool, no rank tracker, no API key — and the pipeline doubles as the record of what has already been answered, so the same article is never written twice.
Readable by AI agents, not only by crawlers
Being found is one problem and being USABLE by an agent is another. Every generated business also ships an OpenAPI 3.1 document at /openapi.json describing its own endpoints with typed schemas, so an agent can call it instead of guessing; markdown content negotiation, so a request carrying `Accept: text/markdown` gets a document rather than an application shell it would have to execute JavaScript to read; a `Vary: Accept` header, without which a CDN hands one representation to both audiences; a when-to-use section in llms.txt naming the jobs the product is right for AND the ones it is not, because a description is not advice and an answer engine deciding what to recommend skips generic marketing copy; and a real HTTP 404 for a path that does not exist, so an agent probing the site can tell a genuine route from an imagined one. Almost every site built by an AI builder is a single-page app that answers 200 to every path, which makes it unreadable to an agent in exactly the way that matters.
Finds the bugs and makes the engineer fix them
The QA agent does not write a report nobody reads. Every defect it can reproduce on the LIVE product is filed against the company with its exact route or file and the steps to reproduce it, and that list IS the engineering agent's brief on its next cycle — ahead of every other priority it has, with the reproduction attached. The engineer can mark a defect fixed; it cannot close one. Only QA re-running the original reproduction closes it, and a fix that did not hold comes back marked as a repeat attempt with the failed patch quoted, so the same wrong diagnosis is not applied twice. Paid advertising is blocked while any critical or high defect is open, because buying traffic to a product that does not work is the worst money a company can spend. The loop is immediate rather than scheduled: filing a serious defect wakes the engineer, claiming a fix wakes QA, so a product converges on working within its first day instead of over a week. It is also BOUNDED, which matters more than it sounds: the extra cycles are capped per day, spaced apart, skipped entirely when the ordinary schedule is about to run anyway, and cut off after three failed attempts on one defect, at which point the engineer is told to stop patching and say what it actually needs. An agent pair that can wake each other without a ceiling is a way to spend a month's budget in an afternoon on a bug nobody is watching; a defect that runs out of extra cycles stays on the list and is worked on the schedule you already pay for. Security scans and a full-repository sweep run alongside it. The usual arrangement in agent products is one agent that writes code and reviews its own work, which is the one review that is never independent.
Runs a security gate before every publish
Before any deployment the engineering agent works an explicit checklist and records the result in the commit message: no secret reachable from the browser bundle, row-level security enabled on every table the app writes with a policy that filters by the owning identity in the same query, no route handler that trusts a client-supplied user id, no API key in a tracked file, auth cookies HTTP-only and Secure and SameSite, no unsanitised HTML injection, and every server action validating its input. The difference from a scanner is that the agent that finds a problem is the agent that fixes it, in the same cycle.
Smoke-tests the live site after every deploy
The QA agent wakes automatically once a deployment succeeds and checks the real URL: every route returns 200, the page contains the company's actual content rather than a framework error or placeholder, every form is submitted once with valid and once with invalid input, and the referenced assets load. A green build that serves a 404 is the worst outcome a builder can produce, because everything upstream reported success.
Ships analytics you can read on day one
Every generated product carries privacy-respecting first-party analytics: page views, referrer, and the one conversion event that matters for that business. No third-party tracker, no cross-site identifier, and no cookie banner the product did not otherwise need. The founder can answer "did anyone visit, and did anyone buy" without installing anything.
Holds generated products to an accessibility and performance budget
Stated numbers the agent checks itself against, not aspirations: LCP under 2.5s on a mid-range phone, CLS under 0.1, landing-route JavaScript under 150KB gzipped, Lighthouse performance at or above 90 on mobile and accessibility at or above 95. Keyboard reachability, visible focus styles, real labels, 4.5:1 body contrast and honoured reduced-motion are treated as ship blockers, because an inaccessible page is a broken page rather than one missing a nice-to-have.
Pauses hosting for abandoned builds instead of billing for them
A company nobody has touched — no agent cycle, no deploy, no visitors — has its hosting released after 30 days, or 7 when the account has no active plan, with a warning email first naming the exact address and the one click that keeps it. The code is never touched: the repository stays exactly as it was and one click redeploys it.
Uses the right executive for the job
A Starter trial, paid plan or funded pay-as-you-go account unlocks all eight executives on their job-specific schedules or on call. An account without paid access has zero credits and no agent work; its live site, repository and database remain.
Runs each executive on the cadence its job actually has
The engineering agent ships continuously, every five hours. The CEO sets direction daily. Marketing runs twice a day, and QA runs on exactly two engineering cycles so a single review covers both. Legal runs weekly, because a legal surface does not change hourly. Finance, support and creative are ON CALL: they have no timer at all and wake the moment they are needed — when spend needs approving, a customer writes in, or a campaign needs artwork. Waking eight agents around the clock to discover seven of them have nothing to do is not autonomy, it is a bill. Your budget buys hosting, a database, media and ad spend as well as tokens, and every wake that produces nothing is one of those you cannot afford.
Keeps the books
An explicit monthly spend ceiling with a hard stop, gated by the finance agent BEFORE the work happens rather than reported afterwards. Your credits cover the whole company, not just tokens: the agents, hosting, generated media and any ad spend all draw on one budget you can watch being spent. A tenant-isolated pooled database is included on every plan, when the product genuinely needs one. The stop applies on every plan, credits can be topped up mid-cycle on any paid plan, and bought credits carry over to the next cycle instead of expiring at renewal.
Writes a landing page that actually sells
A stranger who has never heard of the company has to be able to decide whether to pay without leaving the page. Empyre builds that page for THIS business, not a stacked-card template: what it is, who it is for, how it works, and what to do next. The interface belongs to the company, not to Empyre.
Gives every company its own look, not the same template
The generated company should look like itself. A cybersecurity product may be dark and dense; a children's product may be warm and playful; a luxury brand may be editorial and quiet. Empyre is the builder. The company is the brand. Components live in the company repository, so an engineer can change a button the way a real product team would, rather than fighting a theme they cannot edit.
Refuses to ship a hollow product
Invented testimonials and customer counts, buttons that do nothing, a logo that is just the company name in a bold font, and a missing privacy policy or terms of service are defects. Most AI builders optimise for a demo that looks impressive in a screenshot. A business has to survive a stranger deciding whether to type in their card number.
Tops the balance up before the agents stop
On pay-as-you-go a founder can set an amount and a balance to trigger at, and Empyre charges their saved card automatically when credits run low — so an overnight build does not stall at 3am waiting for someone to notice. It is deliberately bounded rather than open-ended: a minimum interval between charges, a cap on how many can happen in a day, and an automatic shut-off after three failed charges, so a runaway loop cannot drain a card and a declining card is not retried until the bank blocks it. Every automatic charge is emailed the moment it happens, and it can be turned off in one click. It is offered on pay-as-you-go only, because a subscription already renews its own credits every cycle and charging for those twice would be taking money for nothing.
Runs from inside your AI assistant
Every Empyre product exposes a Model Context Protocol endpoint — www.empyre.dev/mcp, relay.empyre.dev/mcp, vault.empyre.dev/mcp and ledger.empyre.dev/mcp — so a founder can operate the platform from Claude, Claude Code, Cursor, VS Code, Goose or any other MCP client. Setup is pasting one URL and signing in; there is no key to copy and nothing to install. It is not read-only, and it is not a subset: EVERY control on empyre.dev is a tool. From the assistant a founder can launch a company or delete one, direct the CEO, ask Empyre itself a question grounded in their own numbers, wake an executive early or rewrite its standing brief, hire a specialist, deploy the site, pause spend, connect a domain they own, put a Stripe key into the encrypted vault, change plan, cancel, and close the account. Anything irreversible demands the company's own name or the account's own email typed back, and closing the account needs a permission granted separately from the rest. And it is not text — the connector ships Empyre's actual interface as an MCP App, so the dashboard renders inside the conversation rather than being described in prose. Each product is a SEPARATE connector with its own OAuth issuer, its own scopes and its own tools, so authorizing Relay grants nothing in Vault. Most platforms that advertise an MCP server expose a handful of read endpoints; this one is the product.
Runs from your terminal too
The official CLI is one command away — npx empyre login, then npx empyre launch, and a company is building. It is published on npm as empyre with NO dependencies, so it installs in a second and there is nothing in it to audit but the code that ships. It signs in through the browser with OAuth and S256 PKCE, so no token is ever pasted, displayed or left in a shell history, and the credential it stores is readable only by the user who created it. Every command takes --json and writes the server's own response to stdout with diagnostics on stderr, so it pipes into jq and drops into a script or a CI job without parsing a table. It is built on the same public MCP endpoint the assistants use rather than a private API, which means it cannot know less than the platform does: it reads the tool catalogue at runtime, so a capability added after the CLI shipped is callable immediately without an upgrade. Empyre, Relay and Vault each sign in separately, exactly as the connectors do.
Lets you talk to any of the eight executives directly
The chat is a list of people, not a routing form. Empyre itself is one of them and gives strategic advice on your actual numbers; the other eight are the executives running your company, and picking one opens a conversation WITH that person — the CTO answers about your codebase, the CFO about your budget, the CMO about your campaigns, each in the first person and each about your company specifically. Nothing is relayed and nothing is queued as work by talking; a message becomes real work only when you explicitly ask that executive to act on it. Every other AI-agent product gives you one assistant that describes what its agents are doing. Here you ask the agent.
Says which model runs which agent, and why
The workforce runs on DeepSeek V4.1 Flash for the CTO's ordinary cycles, the CLO, the CSO, the Tester and the advisor, and on Gemini 3.8 Flash for the CEO, the CMO, the CFO and the Creative director. The CTO's design work — a brand-new company's first build, redesigns and the weekly security audit — runs on Kimi K3, because that work produces the architecture and the look every later cycle only improves. Every model other than DeepSeek gets one attempt and falls back to DeepSeek automatically if anything about it fails, so a premium model can never cost somebody a cycle. There is no per-task model picker and that is a decision, not an omission: the routing is what makes an unattended cycle predictable to budget, and a founder choosing a model per agent is choosing a bill they cannot forecast. What you DO control is the money — a spend cap per cycle, a CFO agent that can refuse a cost, and a ledger of what every call cost. Nothing about the model is hidden from the operator; it is kept out of the founder's way.
Brings your co-founder in, without giving them your account
Invite people to a company by email as a Co-Founder, a Developer or a Viewer, on any paid plan, at any point in the company's life rather than only when it is created — from the company's own Team page, from an AI assistant through the MCP connector, or from the CLI. A role can be changed afterwards without removing anybody and re-inviting them, and an invitation nobody has accepted can be withdrawn, at which point the link stops working. They get their own sign-in and their own level of access: a co-founder runs the business, a developer builds the product, a viewer reads and changes nothing. Two things never move. The person who created the company stays its owner — ownership cannot be invited, granted or transferred through this, and the database refuses it rather than trusting the code above it. And credits are always charged to the creator, whoever pressed the button, because every business-scoped call resolves to the creator's account by construction rather than by a check somebody has to remember. The invitation is a single-use link that expires in seven days and only the address it was sent to can accept it. Most builders answer this with a shared password.
Pays you 15% for every business you send
Empyre has a referral programme, and it is a real one rather than a credit voucher: every Empyre user gets an empyre.dev/r/ link they choose the name of, and earns 15% of every plan payment their referrals make for as long as those customers keep paying — the first month and every renewal. It is paid in MONEY, over Stripe Connect, into the referrer's own bank account, not as platform credit that can only be spent back here. The commission is calculated on what the customer actually paid after any discount and excluding tax, so a discounted subscription pays a smaller commission rather than a headline one nobody funded. Pay-as-you-go top-ups and credit purchases earn nothing, and only a genuinely new customer counts — somebody who already has an account or has paid before is not a referral, whatever link they arrive through. Commissions are held for 30 days against refunds and chargebacks, and a payment that is later refunded reverses the commission in proportion rather than being written off against the referrer's next one silently. Payouts are requested rather than automatic: the balance is withdrawn from the Earn page or the MCP connector when the referrer wants it, above a $25 minimum. Most software referral programmes pay in account credit, pay once, or quietly stop paying at the second invoice.
Repairs its own builds instead of handing you the error
When a generated company fails to build, the platform fixes what is its to fix before the agent is ever told. A compile error inside a file Empyre wrote into the repository — the sitemap, the blog routes, the OpenGraph image — is restored to the version CI builds on every push, because a file the agent does not own is not the agent's to debug and a wrong guess costs the whole build. An import of a module the repository does not contain is written back from the scaffold, together with anything that file itself imports, so it resolves in one deploy rather than one per level. An import of an npm package nobody declared is resolved against the live registry and pinned to an exact version, refusing a package that does not exist or is too new to have any adoption — the shape a hallucinated dependency takes. A site that compiles but answers 404 on every route has its structure repaired. A commit that would break the config file twenty other files read is dropped to that one file rather than failing the whole commit. And because a company's deployment is not driven by a git push, a sweep re-publishes any commit that never went live at all. The repairs are deliberately narrow in one specific way: they only ever put back a file that is MISSING or one the platform itself wrote. They never overwrite the company's own code, because a repair that reverts your product is worse than the error it fixed. A failing build is also not retried on a loop — an identical commit reproduces an identical failure, so it waits for the code to change. Most builders hand you the red log and call that transparency.
Records every decision its agents make, and what happened next
An autonomous company is only worth running if you can find out what it did. Every consequential action is written down as a decision — what it was, which agent took it, the reason given at the time, and how it ended — and an incident, a refused budget, a directive pushed back on and an action whose effect is being measured are all the same kind of record. The timestamp that closes one is stamped by the database exactly once and re-resolving cannot move it, so the recovery times the record produces are measurements rather than the flattering version. An incident opened because new code could not reach production is closed by a deploy that actually lands and by nothing else, because the failure being guarded against is a product that looks healthy while its commits are reaching nobody. Where the platform reports whether an action worked it reports a correlation over a fixed window and says so in those words, and a window it could not measure is reported as unmeasurable rather than as no effect — the difference between a measurement and a number picked because it reads well. The agents are allowed to disagree, too: the CFO refuses spend that breaks a budget rule and names the rule that bound it, and an agent given an instruction that conflicts with a stated constraint answers with its reasoning and an alternative instead of silently complying or silently doing nothing, which the founder can override explicitly or accept. Most agent products give you an activity feed and ask you to trust it.
Learns as one team, not eight
The agents share a memory. When one of them works something out — that the payment webhook has to be idempotent because the provider retries the same event, that a deploy fails unless the public environment variables are set at build time — it is published once to a company-wide knowledge graph that all eight read on their next run. Entries are typed (fact, decision, constraint, failure, insight, convention) and linked to each other, so an agent can see that one finding supersedes or depends on another. Founders can open the graph and see what their company has learned. Multi-agent tools normally give each agent its own isolated context, which means the tester rediscovers the bug the engineer already fixed, by hitting it again.
Plans
| Plan | Price | What it includes |
|---|---|---|
| Starter | $49 | 100 credits, with a 3-day free trial once per account and card. All eight agents, a live deployment and pooled database when needed; no ads. |
| Starter | $49/mo | 100 credits, no Empyre watermark, a custom domain you own, and all eight agents kept active on their job-specific schedules or on call. The CMO publishes to your connected X account several times a day, writes and publishes articles to the product's own blog, and runs SEO audits; the company's own @empyre.site inbox receives and answers real customer mail. Paid ads unlock from Growth. Continues an existing repository; a stack that needs its own server is hosted from Growth up. Credits can be topped up mid-cycle and carry over. |
| Growth | $149/mo | 300 credits, no watermark, Google Ads campaigns and AI media unlocked, more X posting and link capacity than Starter, billed as credits, and managed server hosting for an imported stack that hosting cannot run. |
| Empyre | $299/mo | 600 credits, no watermark, the highest budget and the deepest build cycles, the highest X posting and link capacity with posts queued ahead, and video ads. The plan buys spend, not speed. |
| Pay as you go | Top-ups | Unlimited companies, credits bought as needed, minimum $10. White-label every site for $19 per 30-day cycle. |
How spend is controlled
An autonomous agent that can call a model in a loop can spend money in a loop. Empyre gates cost before the work rather than reporting it afterwards.
Spend gating per plan
Agent spend is capped and gated per plan, separate from the plan fee, so the agents cannot overrun their cycle.
A monthly ceiling, not a daily ration
The plan budget is a hard stop for the cycle. The CFO gates spend before the work happens, so a company cannot overrun what it paid for.
The CFO gates the work
Cost is approved before the agent runs, not discovered afterwards.
Deleting a company does not refund the budget
Spend already consumed stays consumed for the cycle. Create-and-delete loops therefore cannot mint extra budget.
What you own
The repository
Created in your GitHub account. If you have not connected GitHub, it is created in Empyre's account and you are granted admin on it — and you can connect GitHub later to claim that access.
The deployment
The live product, at its own address.
The revenue
Your customers pay your own payment keys directly. Empyre takes no cut and never holds a payment key.
Accounts in generated products
Generated products ship with working sign-up and sign-in on the first deploy. There is no auth provider to register for and no key to paste.
Provisioned automatically
Each company is issued its own internal authentication key at creation. Only a hash is stored on the platform; the raw key reaches the deployment through the encrypted vault.
Isolated per company
End users of your product are scoped to your company. Two different Empyre products can both have a customer with the same email address, and neither can see the other's users.
Server-side only
The authentication key can never become a public client-side variable — a client import is a build failure, by design.
Not Empyre accounts
Your customers are users of your product. They do not get an Empyre platform account.
Earn — the referral programme
Every Empyre account gets a referral link and earns real money on what the people it sends actually pay. Paid over Stripe Connect into your own bank account, not as platform credit.
15% of every payment, for as long as they stay
Not just the first month. Every renewal a referred customer pays earns the commission again, for the life of the subscription.
Your own link, with a name you choose
empyre.dev/r/yourname. One referrer per referred account, fixed at signup and never reassigned.
Computed from what actually arrived
The commission is calculated on the amount Stripe says was paid, after any discount and excluding tax — never on a list price. A discounted subscription pays a smaller commission rather than a headline nobody funded.
Only genuinely new customers count
Somebody who already has an account, or who has paid Empyre before under any identity, is not a referral whatever link they arrive through.
Held 30 days, then withdrawn when you ask
Commissions mature after 30 days against refunds and chargebacks. Nothing is sent on a threshold: you press Withdraw on the Earn page once your balance is at least $25, and it goes over Stripe Connect to your own bank account. A payment later refunded reverses its commission in proportion rather than being written off silently against your next one.
Empyre plans only
Starter, Growth and Empyre subscriptions earn. Pay-as-you-go top-ups, credit purchases and the other products earn nothing.
Domains
Free subdomain on every plan
A one-word address like yourword.empyre.site, issued at creation and attached at first deploy. Letters only — no digits or hyphens — unless you ask for something specific.
You can rename it
The one-word rule constrains Empyre's automatic choice, never yours. Set any subdomain you want from the dashboard.
Custom domains on every paid plan
Bring a domain you own. Empyre shows the exact DNS records to create, read from the host rather than hardcoded.
Frequently asked questions
Does Empyre have a referral programme?
Yes — it is called Earn, it is open to every account on every plan, and with no plan at all, and it pays 15% of every payment a referred customer makes for as long as they keep paying, not only the first month. It is paid in money over Stripe Connect into your own bank account rather than as platform credit, computed from what Stripe says actually arrived after discounts and excluding tax, held for 30 days against refunds, and limited to genuinely new Empyre subscribers. Payouts are requested — you withdraw your balance from the Earn page when you want it, rather than waiting for a threshold to fire. Your link is empyre.dev/r/ plus a name you choose.
Do I need a GitHub account?
Not to launch. Without one, the repository is created in Empyre's GitHub account and you are granted admin on it, so you keep effective ownership. You do need a connected GitHub account to import an existing repository, because only your own token can commit to a repository that is already yours.
How many businesses can I run?
One per subscription plan — Starter, Growth and Empyre are all single-business. Pay-as-you-go is unlimited.
How is billing handled?
By card, on 30-day cycles. Checkout is handled by Stripe, your plan activates the moment the payment goes through, and it renews automatically until you cancel. Cancelling keeps access to the end of the period you have paid for. There is no annual billing.
What happens if I cancel?
The subscription clock stops and the business infrastructure is torn down. Because the repository is yours, the code is not lost with it.
Can agents run paid advertising?
Yes — Google Ads campaigns, run by the CMO. Available on Growth and above, and only a week after launch. You cannot usefully market a product that has not settled down, so the gate is deliberate. Starter and Free are not permitted to run ads at all.
Does Empyre do marketing, or only the code?
Marketing is a whole agent. The CMO writes the positioning and launch copy, runs SEO audits against the deployed site, researches competitors, and runs Google Ads on Growth and above. The CLO produces the terms and privacy pages a real product needs, and the Creative Director makes the brand assets the campaigns use.
Can the agents generate images and video?
Yes. The Creative Director generates brand imagery, on-brand variants, product photography, background-removed cut-out assets and short marketing video, plus the captions to accompany them. Generation is briefed by the CEO and paid for out of the same metered AI spend as every other action, so it is gated by the CFO like anything else.
Try Empyre free for 3 days
Describe a business in plain words and watch eight AI agents build and deploy it. Starter is free for the first 3 days.