How it works.
BuildEx is an app on your machine that gives an AI agent a company to run: a folder of plain files it reads and writes, real tools it can act through, a gate you hold, and git remembering every move. No magic, no cloud brain. Here's the whole machine, part by part.
One job, end to end.
A real job, from the email landing to the commit that remembers it. Every part of the product shows up exactly once here. The rest of this page is just those parts, in detail.
Something arrives
Dana at Globex emails about SSO. Your Gmail connection pulls that thread onto your machine as a markdown file under sources/gmail/, with a link back to the original. Bringing things in is read-only and involves no AI at all.
You ask for something
“Reply to Dana about SSO.” One line, in plain language. The agent runs when you ask it to, or when an automation you wrote fires on a schedule. It is not sitting there inventing work in the background.
It reads what your company knows
The agent opens the files that matter: your operating rules, the Globex client file, the decision log where you wrote which SSO commitments you're willing to make. There's no search index and no upload - the knowledge is the files, sitting on the same disk as the agent.
It follows your way of doing it
Answering a client is a job your company has a way of doing, so that way is written down as a skill: a short markdown file the agent follows like a checklist. Same job, same shape, every time - whoever asks.
It does the work
It drafts the reply in your voice, updates the Globex file with what was agreed, and notes the interim decision. All of it as edits to real files you can open, read and change yourself.
The outward step stops
Sending mail leaves your company and reaches a real person, so it doesn't just happen. A card appears: “Send email to dana@globex.com”, with the exact request one click away. Approve, edit, or deny. Nothing has left your machine yet.
You tap approve
Only now does the send actually happen, through your own Gmail connection - and it's written to the company's activity log, so “what did the AI actually do out there?” always has a boring, checkable answer.
It's remembered
Every file that changed lands as one commit with a readable message. Next month you can see what changed, when, and why - and undo it. Nothing was overwritten silently, because nothing here ever is.
Three panes, and you already know two of them.
Apps & sessions
The tools you've connected, and every piece of work you have open. A session is just a conversation about one job, kept for good.
The work itself
Chat with your agent, or open any document in your company and edit it directly. Answers come back as tables, drafts and files - not as walls of text.
The brain rail
Your company's mind as a live map: what's coming in, the rules and skills it runs on, the tools it can reach, what's waiting for your tap, and what it has learned.
It's a folder. That's the whole trick.
Your company's brain is a directory of markdown files on your own disk. Strategy, clients, decisions, numbers, the raw material your connections drag in - all of it plain text, one idea per file, organized in folders named after what your company actually does.
It comes in three layers. core is the starter pack we ship (conventions and a handful of skills), your company layer is the shared brain everyone in the company works from, and your private layer is yours alone - it never leaves your machine unless you say so.
How it gets fed
Three ways, all of them ending in a file: you write or drop something in, a
connection brings material in under sources/, or the
agent captures something as it works - a decision it just watched you make, a number it
just verified.
How the AI actually reads it
It opens the files. That's it. There is no vector database, no embedding step, no ingestion pipeline, and nothing is uploaded to us to be indexed. The agent runs on your machine, in that folder, with a file browser and your rules - which is exactly why it can be trusted with the whole thing at once. The app even has a viewer that shows you, verbatim, what your agent is handed.
your-company/ core/ the starter pack we ship conventions.md how the brain is organized skills/ capture-decision, weekly-review, ... acme-labs/ the shared company brain CLAUDE.md always-on rules, read every turn strategy/ charter, positioning, plans clients/ globex.md one file per client decisions/ log.md every non-obvious call, dated finance/ metrics-q3.md sources/ gmail/ raw material, brought in as files private-you/ yours alone - never shared CLAUDE.md notes/
Programming your company, without programming.
Two kinds of instruction, both plain markdown, both versioned like everything else. The difference is only when the agent reads them.
Rules - always on
- One CLAUDE.md per layer: ours, your company's, yours.
- Read on every single turn, before anything else happens.
- The standing contract: how you speak, what you never do, what always gets written down.
- Layered, not overwritten - your company extends the base, you extend your company.
Skills - on demand
- One folder per repeatable job, with a name and a “use this when…” line.
- The agent picks the right one by that description, then follows the steps.
- Reply to a client, run the weekly review, capture a decision, draft content.
- Write one in five minutes. If you can write a checklist, you can write a skill.
A real skill, in full
This is capture-decision, one of the skills every workspace starts with. Nothing is hidden behind it - no code, no config, no prompt engineering. It's a page of instructions, and the agent follows it.
Because it's a file, it's reviewable, editable, copyable between companies, and its history is in git like everything else. When you change how your company answers clients, you change a paragraph.
The agent also offers them: notice it doing the same job the same way twice, and it will suggest saving that as a skill - one line, inline, that you accept or ignore.
core/skills/capture-decision/SKILL.md --- name: capture-decision description: Use when a non-obvious call is made about the company - a strategy choice, a policy, a trade-off, a reversal - and it should be remembered so it is never silently decided twice. --- # capture-decision ## Steps 1. Open `decisions/log.md`. 2. Add a dated entry at the top: Decision, Context, Alternatives, Consequence. 3. If it changes a prior decision, say so - never edit the old one away. ## Rules - One decision per entry; absolute dates. - Plain markdown; nothing secret. - Superseding is honest: the new entry wins, the old one stays as history.
You bring the AI. We never touch it.
BuildEx doesn't sell you intelligence. It runs the coding agent you already pay for - today that's Claude Code, and the driver seam is open for others - as a program on your machine, pointed at your company's folder.
What that buys you
- The agent talks to your model provider with your subscription, directly.
- Your files never make a detour through us to get to it.
- You see the model, the effort setting, and the usage, in the window.
- When your agent gets better, your company gets better - no upgrade to buy from us.
Bright lines we hold
- We never read your agent's credential store.
- We never proxy or resell you model tokens.
- We never set a provider API key on your behalf.
- We never render a provider sign-in and collect what you type into it.
How the outside world gets in - and how it gets out.
A brain that only knows what you typed into it is a notebook. Connections are what make it an operating system: your real inbox, your real CRM, your real invoices.
Products you already use
Sign in once to Gmail, Slack, HubSpot, Notion, Linear, Intercom, Stripe, Asana, Calendly and
the rest. Two things happen: material flows in as files under sources/, and that product's actions become tools the agent can use. The
sign-in is a normal OAuth flow, and the tokens live in your machine's keychain.
Anything else with an API
MCP is the open standard for handing an AI a set of tools. Point BuildEx at any MCP server - one you found, one your vendor ships, one you wrote this afternoon - and its tools show up in the same list, under the same gate, with no special-casing.
Every tool passes one gate
However a tool arrives, it goes through a single gateway that decides what it's allowed to do on its own. The classification comes from what the tool is for, plus what its provider says about it - and you can tighten or loosen any of it.
| The tool wants to… | Examples | What happens |
|---|---|---|
| Look something up | get_, list_, search_, read_ | Runs on its own. Reading is never gated. |
| Create or update inside your tools | add a CRM note, update a task, file a doc | Runs on its own. It's your data, and it's reversible. |
| Reach a real person or move money | send, post, publish, charge, refund, invoice | Waits for your tap. Always logged. |
| Destroy something | delete, revoke, cancel, archive | Waits for your tap. Always logged. |
| Anything you've marked sensitive | your call, per tool | Waits for your tap - or is hidden from the agent entirely. |
Installing an app is a commit.
An app in BuildEx isn't code that runs in a sandbox somewhere. It's a bundle of files: the connector that talks to the product, the skills that know how to use it well, the conventions for where its material gets filed, and the docs.
Install it and those files land in your company's folder as a commit you can read. Uninstall it and they leave as another commit. There's no hidden state, no phone-home, and nothing installed that you couldn't have written by hand.
That's also how a company's know-how travels. A good skill for running a discovery call is a file. It can be shared, forked, improved, and pulled into another company - the same way code has moved between teams for thirty years.
$ install “HubSpot” + acme-labs/apps/hubspot/README.md + acme-labs/skills/log-a-deal/SKILL.md + acme-labs/skills/pipeline-review/SKILL.md + acme-labs/conventions.md (deals file under clients/) + .buildex/connectors/hubspot.json one commit · reversible · readable
Wide open by default. The sharp edges wait for you.
The fear about an AI running a company isn't that it drafts a bad paragraph. It's that it sends one. So the line isn't drawn around thinking - it's drawn around leaving.
Reading, drafting, filing, building, updating your own tools: all of that runs without asking. Money, messages to real people, publishing, and anything you can't undo: those stop and wait, right where you're already working. No separate approvals inbox to babysit.
The card shows the action as a sentence you can judge in two seconds, with the exact request one click away if you want it. And it's a dial, not a wall: widen a gate you trust, tighten one you don't.
Every outward action that goes through - approved by you, or auto-approved because you widened that gate - is written to the company's activity log.
Git, doing the boring job it's best at.
Every change your agent makes is committed: which files, when, at whose request, with a readable message. Not a log about the work - the work itself, versioned.
That single fact is what makes the rest safe. Nothing is overwritten silently, because every previous version is still there. Undo is real - not a feature we implemented, just what git does. “When did we decide that?” has an answer with a date on it. And an AI that edits your company is auditable line by line, by you or by anyone you hand the folder to.
The Learning stage in the right rail is that history, made readable: recent commits, the files each touched, and one click to open any of them.
Work is committed on your machine first. Sending it anywhere else is a separate, deliberate step.
recent changes a3f9c21 reply to Dana re: SSO clients/globex.md · decisions/log.md you · 4 minutes ago 7e10b8d Q3 metrics verified finance/metrics-q3.md agent · 2 hours ago decisions/log.md + 2026-07-22 Interim SSO: shared service + account for ~60 days. + Supersedes the 2026-05 “no shared + accounts” note, with an end date.
One brain, several machines.
Today shipped
Your company is one repository. It lives on your machine, and you can point it at a remote you already own - your own GitHub, your own server - and it will keep itself backed up there. Your work is committed locally first and pushed when you say so; if you're offline, the commits queue and go when you're back.
Next coming soon
Hosted sync and seats: every member's machine holds a full copy of the company brain, and changes travel between them as commits. Someone else's edits arrive as history you can read, not as a mysterious overwrite. Your private layer stays on your machine.
The rule that makes it safe
If two people changed the same thing, the loser's version is backed up byte for byte before anything else happens, and flagged for a human. Losing an operator's work isn't a bug here, it's a failing test.
And the cloud's job stays deliberately small: the cloud syncs, it never thinks. No model runs there. No one reads your company to make the product better.
your machine teammate's machine acme-labs/ acme-labs/ full copy full copy │ │ └────────► sync ◄────────┘ commits in, commits out never reads, never thinks private-you/ private-them/ stays put stays put
Now go poke at it.
Every claim on this page is either visible in the app or readable in the repo. Download it and check, or read the code first - both are free.