[!WARNING]
🚧 Work in progress. OpenCompany is under active development and moving
fast. APIs, the CLI, the example harnesses, and the docs will change without
notice. Explore it, fork it, build on it, but don't depend on anything
staying put yet. Not production-ready.
Download
The quickest way in is the desktop app. Get it from the website or straight
from the GitHub release:
Open the .dmg, drag OpenCompany into Applications, launch it, and pick a
company. The app updates itself from the same releases page. Prefer to run the
host yourself, in Docker or from source? Jump to the Quickstart.
The company of one
For a century, ambition meant headcount. Want to ship a product? Hire engineers.
Want customers? Hire marketers, then sales, then support. Every new capability
was a new payroll line, a new manager, a new quarter of ramp-up.
That tax is gone. OpenCompany turns a single operator into a full org chart.
Scouts, founders, engineers, designers, marketers, lawyers, finance, support and
recruiters, all instantiated as agents, coordinated by one host, working while
you sleep. You stay where humans are irreplaceable: capital, taste, and the
decisions that actually matter. Everything else is delegated.
This isn't a chatbot with a to-do list, and it isn't a pipeline of agents
handing a ticket down the line. It's a company runtime: a durable host that
stands up a roster of specialized agents, gives each one a clear mandate, seats
them at desks, and lets each desk think as a hive on top of the OpenHuman and
TinyHumans runtimes.
Not a team of agents. A hive mind.
Most "multi-agent" systems are fan-out: publish a task, wake N agents, collect
the replies, average them somehow. That's a thread pool with a prompt attached.
It has no notion of who is talking to whom, no way for one specialist to hand
a finding to the one colleague who needs it, and no reason to stop other than
running out of members.
OpenCompany runs its desks as rooms, via
tinyhivemind, the hive-mind
library that grew out of this repo, hosted over the
OpenHuman agent runtime.
How a desk thinks
Every conversation in a company runs through one company hive — a
TinyHiveMind Coordinator that owns who runs and when. A message to a desk opens
an episode on that desk's hive: the members it needs start at once, each
turn can talk to the room or to one colleague, and the episode settles when
the members it assigned say their part is done.
engineer hivemind_send_agent → writer Keep the copy short; the page ships Friday.
writer (reply) Draft is up — numbers in the second para.
engineer hivemind_complete Numbers checked against the ledger. Done.
- Talking is a tool call. An agent posts to a hive it sits on, messages a
colleague directly, or completes its part of an episode with the
hivemind_* tools. A message is delivered, not awaited: the answer arrives
on the sender's next turn, so nothing blocks on anybody.
- Concurrent, never twice. Different agents run at once, within a desk and
across desks. One agent runs one turn at a time across every hive it sits
in — the CEO on two desks is the same agent with the same memory.
- Routing by a model built for it. Who an unaddressed message needs is
asked of Jev — TypeSafe's System One routing model — through the TinyHumans
proxy on the key you already have. Name someone and they start; no key, and
the desk lead starts.
- A reason to stop. An episode settles when its assigned members say it is
done, or fails at the desk's round cap. One operator message is one bounded
number of turns.
- Reach you can state. Who may message whom is the manifest's
delegates_to: desk peers plus the desks it names, or anybody when empty.
- One continuous agent. Each teammate is one agent with one session that
spans every desk it sits on, its DMs and the general line, so the question it
answered on a desk an hour ago is one it remembers in a DM now.
What you get out of it
Every turn is on the record: who started, who spoke, who messaged whom, and
when the episode settled — live in the room as it happens, and rebuilt from the
journal after a reload. A desk of one behaves
like a single agent, so nothing here costs you anything until a desk has
somebody to work with.
docs/spec/runtime/hive.md has the whole
mechanism, and scripts/measure-coordination.sh has the numbers on a
two-desk company.
What one person can now run
Every folder under companies/ is a complete company you can
launch today, with a roster of agents, their responsibilities, and the handful
of moments where a human signs off:
| You want to run a… | The hive handles | You keep |
|---|
| Venture Studio | Scouting, founding, building, launching, operating a portfolio | Capital allocation & strategy |
| Startup Accelerator | Sourcing, screening, mentoring, demo day, investor intros | Investment decisions |
| VC Firm | Deal flow, diligence, memos, portfolio support | The final "yes" |
| Consulting Firm | Research, analysis, modeling, decks, implementation plans | Executive workshops |
| Software Company | PM, design, frontend, backend, QA, security, docs, support, DevRel | Product direction |
| Product Team | A triaged queue, a groomed backlog, a defended roadmap | Prioritization calls & roadmap sign-off |
| Marketing Agency | Creative, copy, SEO, paid, email, landing pages, analytics | Campaign sign-off |
| Design Studio | Branding, UI, motion, illustration, user testing | Creative direction |
Twenty-two companies. One operator. Pick one and run it, or run several at once.
companies/README.md has the full catalog.
Quickstart
You do not need a software background to run a company. You need either
Docker Desktop or Podman
with its Docker-compatible CLI and Compose provider, a terminal, and about
fifteen minutes. On Windows the terminal must be POSIX —
WSL or Git Bash — because the
quickstart below uses export and ./scripts/launch-demo.sh.
git clone --recurse-submodules https://github.com/tinyhumansai/opencompany.git
cd opencompany
export TINYHUMANS_API_KEY="th-..." # grab yours at tinyhumans.ai
./scripts/launch-demo.sh marketing up
There is no bundled username or password. The first run takes a few minutes
while it downloads and builds. When it settles, open
http://localhost:5173: the sign-in screen of a company nobody has joined
yet asks you to choose the admin login and a password (it suggests one — keep
a copy), and signs you straight in. That's the console, where you watch your
agents work and answer anything waiting on you. Whoever reaches a fresh host
first becomes its admin, so do this before you expose the port to anyone else;
the offer disappears the moment the first account exists.
Prefer to set the admin up from the shell — for a scripted deploy, or a host
you will not be first to open? ./scripts/init-demo-admin.sh marketing [email protected] prompts for a password and creates the account before the
first launch. Removing the data volume with
./scripts/launch-demo.sh marketing down -v removes the account too.
./scripts/list-demos.sh lists the other businesses you can launch in place of
marketing, and ./scripts/launch-demo.sh marketing down shuts it all down.
Prefer to build the host from source, deploy it somewhere, or change the runtime
itself? That path lives in docs/running-locally.md:
Cargo builds, Compose, feature flags, the Tauri desktop preview, and
DigitalOcean / AWS deploys.
You'll want a TinyHumans API key. It's what lets the agents think and
act. Without one you can still launch a company and look
around; the agents just won't do real work. Grab a key at
tinyhumans.ai and
export TINYHUMANS_API_KEY="th-...".
Why it works
- A real org chart, not a prompt. Each company is declared as a roster of
agents with distinct mandates in a simple
company.toml. The host
instantiates them, coordinates them, and keeps them running.
- Desks that think as a hive. Any desk with two or more members answers as
a room: rounds of concurrent turns in which seats post, DM and broadcast to
each other until one reports the work complete, every utterance on the
record. A desk of one behaves exactly like a single agent. No fan-out, no
vote-averaging.
- Humans in the loop where it counts. Every harness names the exact
decisions reserved for you. Delegate the work; keep the judgment.
- Built on proven runtimes. OpenCompany is a light host over OpenHuman, the
TinyHumans agent modules and tinyhivemind, so it reuses their runtime and
their mechanics instead of reinventing them.
- Rust-fast and inspectable. An Axum HTTP surface, a small default build,
and deeper capabilities behind feature flags. Simple to start, honest to
operate, easy to test.
- Yours to own. GPL-3.0, self-hostable, no lock-in.
Make it yours
Each company folder holds a company.toml, a plain text file naming the roles,
what each one owns, which desks they sit at, and where you want to be asked
before anything happens. It's written to be read by people; changing a role, or
tuning how a desk works (how many seats run at once, its round cap, whether it
can refer a question to another desk), is editing a few lines rather than programming. opencompany check reports any problems in plain language, and
adding a new business is a new folder, not a new program.
Your first company walks through it.
What it reports about itself
Nothing, unless it is a tenant on the TinyHumans hosted platform.
- A self-hosted install sends nothing — and not "nothing by default" in
the sense of a switch someone could flip. The network client is behind a
cargo feature the shipped default build does not compile in, so there is no
code in that binary that could make the request. Getting one out of that
state takes a recompile, not a config change.
- The desktop app reports by default, and you can turn it off in
Settings → Privacy (or
OPENCOMPANY_ANALYTICS=off). It sends the same
shape-and-outcome events as a hosted tenant, from the app's Rust host, under
a random per-install id that names no person
(docs/spec/runtime/analytics-desktop.md).
- Hosted tenants report product usage, because the platform builds their
image with that feature on and injects a project token. What it reports is
shape and outcome under an opaque id: how many companies are configured,
which storage backend is in use, whether a turn finished or failed, and token
and cost counts.
- No company content ever leaves, on any install. Not message text,
prompts, agent output, file paths, ledger values, tool names or arguments,
email addresses, company or agent names, task titles, error messages, or
credentials of any kind. That is enforced by construction rather than by
review: a reported property is a word compiled into the binary, a count, a
number or a boolean, and the type has no
String variant for runtime text to
arrive in.
- To turn it off, set
OPENCOMPANY_ANALYTICS=off (on the desktop, also the
Privacy setting). It outranks everything else, and boot prints one line saying
which way it resolved.
docs/spec/runtime/analytics.md has every
event and property, the conditions that must all hold before anything is sent,
and how the opaque id is derived. Crash reporting is separate: a self-hosted
host is off until you configure your own Sentry DSN, while the official desktop
app, hosted tenants and a console bundle built without VITE_SENTRY_DSN report
to TinyHumans' projects unless you set your own DSN or OPENCOMPANY_SENTRY=off
/ VITE_SENTRY_DSN=off —
docs/spec/runtime/crash-reporting.md.
Documentation
| Where | What's there |
|---|
docs/gitbooks/ | The full docs: what OpenCompany is, what one person can run, and how it holds together |
docs/running-locally.md | Docker, Compose, from-source builds, feature flags, desktop preview, deploy targets |
docs/repository-layout.md | Where everything lives in the tree and what each package owns |
docs/spec/README.md | Architecture reference |
docs/spec/runtime/hive.md | How a desk works: episodes, concurrent rounds, speaking as a tool call, Jev routing and cross-desk referral |
docs/gitbooks/developers/ | Build, CLI, authoring companies, deployment, configuration |
scripts/qa/ | Checking a release against a deployed tenant |
Contributing
New here? Start with the
good first issues,
which are scoped to be finishable in a sitting.
CONTRIBUTING.md has the local checks to run before opening a
pull request, and anything big enough to break an existing company starts as an
RFC
rather than a PR.
Community
Discussions is where
questions get answered and large changes get argued out before they're built.
docs/SUPPORT.md says which channel takes what.
Star us on GitHub
Running a company with a headcount of one? Star the repo and help others find the path.
Contributors Hall of Fame
Show some love and end up in the hall of fame. Contributors get free merch and special access to our Discord.
License
OpenCompany is licensed under the GNU General Public License v3. See
LICENSE.
