One founder and a team of agents: how the next onchain companies get built

The first one-person billion-dollar company will be built onchain.

The people building the models have stopped hedging about who does the work. In January 2025 Sam Altman wrote that the first AI agents would "join the workforce" that year. Elon Musk is building xAI as a multi-agent software company, hundreds of specialized agents working together, and this week said AI and robots will more than double the global economy within ten years. Follow that line to its end and you get the one-person company. Dario Amodei gives the first billion-dollar one a 70 to 80 percent chance of arriving in 2026. Founders did not wait for it: by mid-2025, 36 percent of new startups had a single founder, up from 24 percent in 2019, and Instagram had 13 employees when it sold for a billion dollars, before any of this.

For most of business history the limit on a company was labor: more output meant more people. Agents removed that limit, and the first place they removed it was code; plenty of tools can write your app today. The company is what comes after the app: support, marketing, the treasury, the analysis, the departments that used to be the reason you hired. When agents can hold those jobs, a founder sets direction and a team of agents runs the rest. That company will appear first wherever the work already looks like software.

Which is onchain. It is the only industry where the whole company already lives in one piece of code: the product, the money, the customers, and the rules. A chain never closes. Every balance is public. A wallet is a keypair. Everything an agent needs to do a job without a person in the loop has been sitting there for years, waiting for the agent to arrive.

Anyone who has launched onchain knows the morning after. The token is live, the Telegram filled up overnight, and someone has to answer it at 3am because the market never sleeps. The product was the easy part. The hard part is moderating the group, posting the thread, running the ads, watching the treasury, claiming the fees. That work turned two-person projects into ten-person projects, or quietly killed them. Read the list again: it is, almost line for line, a list of jobs an agent can hold today.

So the question in front of an onchain founder has changed. It is no longer "who builds my app". It is "who runs my company". That is now a job description you type into a chat.

---

What Modus is

Modus is a company builder for the onchain world. You describe the product in a chat; Modus researches it, designs it, writes the code and the contracts, launches the token, deploys it, and then hires the agents who run it. One conversation, start to finish.

The product comes first. Tell it what you are making, whether it runs on the web, onchain, or somewhere in between, and a set of agents takes over, each built for one layer of the work. One researches the market and writes the spec. One designs every screen in your brand. Others write the frontend, the backend, the database, and the contracts, check them, launch the token, and deploy the whole thing. What comes out is a full stack you can read, edit, and roll back at any point. And all of it was built for onchain work, down to the infrastructure: Modus Gateway puts the RPC, indexing, market data, and routing an onchain product depends on behind one key, so what you build is live on the day it deploys instead of waiting on a month of provider signups.

Most tools stop at the app and hand you a repo. Modus keeps going, because the app was never the hard part. You hire the AI employees who run what you just built: the moderator in your Telegram, the marketer behind your ads, the analyst watching the chain, the operator running the treasury routine. They need no onboarding. Modus built the product, so they arrive with the app, the docs, and the contracts already in their heads. Research, build, run: that is the whole shape of it, and the reason it goes further than a builder that stops at the app.

Through all of it, your hands stay on the wheel. The code is yours, the contracts are yours, and nothing ships until you say so. The rest of this piece walks through how that works, in the order you would use it.

Start with whatever you have

A sentence is enough. So is a full specification, or a repo you already have on GitHub.

Your first conversation is with Modus Spec. If the idea is early, pick Research and it studies the market and the competitors and pressure-tests the concept before anything gets built. If you already know what you want, pick Build. As you talk, it records every decision you settle, chain, custody, token, so nothing downstream asks again. When you create the project, the conversation becomes a brief, and anything you never discussed is marked as open instead of invented.

The brief becomes the PRD, the document every later step reads. An Architect agent writes it live in front of you: problem, users, scope, architecture, pages, and how people move through them. Edit it in the same chat and it updates as you go. For a second opinion, four expert reviewers, a PM, a designer, a full-stack engineer, and a web3 architect, flag what is missing, weak, or inconsistent. Design and Code both build from this one document, so a change to the spec halfway through reaches the next screen and the next build turn.

The design studio

Design is a full studio with agents working beside you, and it covers everything a company puts in front of people: the app screens and the website, the pitch deck, the social media kit and the banners, and the videos, from a website tour to a launch reveal.

It starts with your Brand kit. Paste your website URL and Modus extracts your logo, colors, and type; upload what it missed; pick a design system from the catalog or import your Figma files. From then on every agent designs from that kit. The agents draw the screens onto an infinite canvas, and each screen is checked as it lands for visual quality, consistency with the others, and use of your tokens, so what you see is already coherent before you touch it.

Then you open the editor and finish the screens with the agent, on the same file. Click an element and write what you want changed: "percent readout too small", "show the fee next to receive". The notes queue into a task list and the agent works through them as one request. Or change it yourself: typography, effects, animations, colors, layout, down to the raw CSS at every breakpoint, and the agent continues from your version. Pages are built from shared components, and colors, type, and radius are tokens, so fixing a button once fixes it on every page that uses it. When you approve the screens, Code picks them up.

Code you can read

Code is a browser IDE you drive by chatting. It has everything an IDE has, an editor with a file tree and diffs, a terminal, a database panel, backend services, git, a live preview, and you can use all of it by hand. Most of the time you will not.

The build starts from the design. When you approve the screens, the build agent receives each one mapped to its PRD page, your design tokens, and a brief written from the design conversation: the intent behind each layout, what you rejected, what you deferred. Its first turn is a gap analysis, what the PRD requires against what the design covers, and only then does it write code. It writes all of it: frontend, backend, database, tests, and the contracts, Solidity or native Solana. For contracts it reaches for audited, widely deployed code wherever that fits and writes new code only for what is specific to your protocol; anything new passes a static analyzer, an AI security review, and a check against your spec before it is deployed to a testnet, verified on the explorer, and signed in your wallet. Bots, indexers, and APIs run as always-on services hosted on Modus.

The agent works inside your project's own container, writing files, running commands, and checking the result in the preview, and every step streams back to you: each file change with its diff, each tool call with its output, the plan, the reasoning, and a question when it needs a choice or a wallet signature. Background tasks take the bigger jobs: each one runs in its own branch of the workspace, two at a time, and comes back as a diff you apply or discard while you keep working. A build turn can also call one of the AI employees you hired.

Every turn is bracketed by two commits, so any change can be diffed, restored file by file, or rolled back in one click. Files you upload are never overwritten. Push the whole workspace to GitHub whenever you like.

Modus Gateway

An onchain product does not run on code alone. It needs an RPC to reach the chain, an indexer to read history, price and market data, routing for swaps and bridges, and an explorer for contract data. Normally that means a dozen accounts, a dozen API keys, a dozen bills, and a fraction of each plan used.

Modus Gateway replaces all of that with one key. RPC, indexing, market data, routing, and the premium data providers an onchain product depends on come through it, and you pay from one credit balance for exactly what your product calls. The same key works in the agents that build your product, in the employees that run it, and in production wherever you host, so an app that works in the preview works after deploy without a single provider signup. If you already hold your own provider keys, plug them in and Gateway steps aside. No other app builder ships this layer, and it is the reason an onchain product built here is live on day one instead of waiting on infrastructure.

Shipping, and what keeps running afterwards

When the build is ready, Deploy is a button in the Hub and a sentence in chat. The frontend goes to Vercel or Netlify, backend services go to Cloudflare Workers or stay always-on on Modus, and the contracts go to the chain you picked in the PRD: Ethereum, Robinhood Chain, Solana, Base, BNB, Arbitrum, Avalanche, and more. Your Gateway key travels with the deploy, so nothing breaks in production for want of a copied secret.

What you ship does not go stale. Docs are generated from the code, README, architecture, API reference, runbooks, and a drift detector flags which of them a later code turn, deploy, or contract change made stale, with a one-click refresh. Site content is managed through an integrated partner CMS, so a new announcement or a swapped hero image goes live without a deploy.

The Token Launcher

Most onchain projects run on a token. It is how the protocol charges fees, rewards early users, funds the treasury, and gives the community a vote, and it is how the project gets a market before the product is even finished. It is also where most projects go wrong. Supply, vesting, taxes, the contract, the audit, the venue: every one is a decision, every one is public forever, and most teams make them in a separate tool, weeks after the product is done.

In Modus the token is part of the same build, designed by an agent that already knows the product it belongs to: what the fees are, who the users are, what the treasury needs to hold. The tokenomics start from the product instead of a template, and the agent walks you through the rest in plain language. Then you pick where to launch.

On a DEX, the agent writes the contract with the functions you chose, runs it through three review passes, static analysis, an AI semantic review, and a check against your own spec, deploys testnet-first, verifies the source on the explorer, and adds liquidity on Uniswap, PancakeSwap, or Aerodrome. After launch, every owner function, LP lock or burn, vesting, taxes, limits, renounce, is one message away. On a curve, the agent handles the whole launch: Pons on Robinhood Chain, Flap on BNB Chain, pump.fun on Solana, with creator fees claimable inside Modus.

Either way, every transaction is signed from your own wallet. Modus never has access to your keys.

The crew: AI employees on payroll

This is where the app becomes a company. The day it goes live it needs a community manager in the Telegram and Discord, a social media manager on X, a support rep working from the docs, a performance marketer running the ads, a market analyst watching competitors and the chain, and an executive assistant on the inbox and the calendar. A protocol needs one more: an onchain operator executing swaps and transfers on a schedule or a trigger. In Modus each of those is a hire.

They arrive knowing the business. Because Modus built the product, every employee starts with the brief, the brand, the docs, the contract addresses, and the token in context, the way a new hire would after a good onboarding. What they do not get is the inside of the build: no access to the codebase, your secrets, or your wallet. An employee sees what a person in that role would see, and acts through accounts and a wallet you provision for it.

Hiring is one sentence. Press Hire, describe the job the way you would to a person, "grow my Twitter to 10K followers by posting daily", and Modus turns it into a workflow you can open, read, and edit by talking to a co-builder. Test it on the canvas, connect the accounts it needs, give it a trigger, an event in one of its channels or a schedule, and set its budget. From then on it has a dashboard: latest run, success rate, cost, a chat where you talk to it, and a step-by-step log of everything it did.

These employees reach further than a generic automation bot. Hundreds of connected apps, X, Telegram, Discord, Slack, Gmail, Notion, GitHub, Google Calendar among them. Gateway tools for chain data, metered from the same credits as the product. A wallet toolkit for onchain actions. And they get better at the job: memory is stored as files you can open and read, and after a run that took real work the pattern is written down as a skill it reuses next time. For bigger jobs, set a goal with a metric, a target, a deadline, and a budget, and Modus plans a team for it: sub-agents with their own roles and schedules, reporting to a parent, with progress and spend on one dashboard.

You keep the final say everywhere

That rule holds across the whole product: the agents do the work, you approve what ships. Everything they make stays open to you, from the frontend code to the deployed contracts; step in whenever you like, and the agents carry on from your changes. Builds run in isolated sandboxes, credentials are encrypted at rest and in transit, the stack is hosted in the EU, and your content is never used to train models.

Where to start

Start free at modus.builders and upgrade when you need more usage, more projects, or always-on services.

The first one-person billion-dollar company will be built onchain. If the idea is yours, it starts with one conversation.