OpenCompany

Run an entire company with a headcount of one.

OpenCompany is the operating layer for one-person businesses powered by agents. You bring the vision and the judgment calls. Your agents do the work — every function, around the clock, at the speed of software.

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, and things may be incomplete or break between commits. Explore it, fork it, build on it — but don't depend on anything staying put yet. Not production-ready.

---

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. Opportunity scouts, founders, engineers, designers, marketers, lawyers, finance, support, recruiters — 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. It's a company runtime — a durable host that stands up a roster of specialized agents, gives each one a clear mandate, and runs them as a coordinated business on top of the OpenHuman and TinyHumans runtimes.

What one person can now run

Every folder under companies/ is a complete company you can launch today — a roster of agents, their responsibilities, and the handful of moments where a human signs off:

You want to run a…	Your agents handle	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
Marketing Agency	Creative, copy, SEO, paid, email, landing pages, analytics	Campaign sign-off
Design Studio	Branding, UI, motion, illustration, user testing	Creative direction
Media Company	Finding, verifying, writing, illustrating, distributing stories	Editorial standards
Influencer Brand	Scripting, editing, thumbnails, posting, community, sponsorships	Your face (or an avatar)
Game Studio	Worlds, story, code, art, QA, balance, launch	Creative direction
Game Business	UA, monetization, LiveOps, community, store optimization	Growth strategy
Recruiting Firm	Sourcing, outreach, screening, interviews, offers	Final hiring calls
Enterprise Sales	Lead gen, outreach, CRM, proposals, contracts, follow-up	Closing strategic accounts
Support Org	Tickets, docs, bug reports, escalations, refunds	Policy & escalation
Real Estate Co	Sourcing, analysis, underwriting, contractors, tenants	Purchase approvals
Accounting Firm	Bookkeeping, tax, payroll, forecasting, audit prep	Signing the filings
Law Firm	Research, drafting, litigation support, discovery, compliance	Approving filings
Pharma Startup	Literature, molecule discovery, simulation, trial planning	The lab work
Signals + Opportunity Studio	Scouting signals, clustering pains, ranking opportunities into a weekly brief	Which opportunities to fund

Nineteen companies. One operator. Pick one and run it — or run several at once.

Signals and the Opportunity Engine are a template, not kernel code. The Signals + Opportunity Studio realizes them as a roster, a charter, and a weekly [[schedule]] over the existing channel, memory, and brain ports — nothing new in the runtime.

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.
• 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 and the TinyHumans agent modules — it reuses their runtime instead of reinventing it.
• 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.

The engine: Medulla

A company of one only works if something can hold the whole company in its head. That something is Medulla — TinyHumans' orchestrator model, purpose-built to run large fleets of agents as a single coordinated business.

Medulla is orchestrator-first. Every event — a customer email, a market signal, a finished task — lands on a deep orchestration tier that reads the full picture, decides what matters, and fans the work out across your agents. It compresses the noise coming in, compiles the right output for each channel going out, and routes results back into the loop. One brain, many hands.

It's the difference between a pile of chatbots and an actual org that runs. As your company grows from nine agents to nine hundred, Medulla is what keeps it coherent, on-strategy, and moving — without you in every message.

Medulla is a hosted model. You reach it with a TinyHumans API key; OpenCompany is the open host that points your companies at it.

Grab your key and request Medulla access at tinyhumans.ai.

Start your company

# 0. Get a TinyHumans API key (unlocks Medulla, the orchestrator) and set it
export TINYHUMANS_API_KEY="th-..."

# 1. Pull in the OpenHuman + TinyAgents runtimes
git submodule update --init --recursive

# 2. Check a company definition before you launch it
cargo run --bin opencompany -- check companies/agentic_marketing_agency

# 3. Launch that company on the host — pick any folder under companies/
cargo run --bin opencompany -- serve --company companies/agentic_marketing_agency

The host is one configurable backend; each folder under companies/ is a business definition (a company.toml manifest plus docs), not its own program. Point --company at a different folder to run a different business.

Without a key you can still build, inspect, and explore every company in companies/. Add the key when you're ready to put Medulla in the driver's seat and let the agents run for real.

To let companies trade with other agents on tiny.place, build with the tinyplace feature and pass serve --discoverable to opt every loaded company into going public (register a @handle, publish an Agent Card, and answer inbound A2A tasks/send over SIWX + x402). See docs/modules/server/README.md for the full discovery flow and the TINYPLACE_API_URL / OPENCOMPANY_PUBLIC_URL settings.

Each company folder holds a company.toml (the manifest — the team, the output, the human's role) and a README.md describing the business. Edit the manifest to reshape the team; opencompany check reports any problems in plain language. Adding a new business is a new folder, not a new program.

cargo build               # the host (the one configurable backend)

Run it anywhere (Docker)

One command spins up a company and its operator console, with a single switch — OPENCOMPANY_COMPANY — choosing which company runs:

cp .env.example .env          # set OPENCOMPANY_COMPANY (e.g. fund, marketing, software)
docker compose up --build     # console → :5173, host API → :8080

The same two images deploy to DigitalOcean (App Platform spec in .do/app.yaml), AWS (Fargate task in deploy/), or any Docker host. See deploy/README.md.

Compile against vendored TinyAgents, or preview an OpenHuman launch:

cargo check --features tiny
cargo run --bin opencompany -- open-human --dry-run -- status

Under the hood

OpenCompany is a Rust 2024 crate: one configurable host. Business types are data, not code — a manifest plus docs — and the operator console is a separate Vite app.

src/app/                Runtime config and shared state
src/company/            Company manifest parsing, validation, and boot
src/ports/              Kernel port traits and shared types
src/store/              File-based CompanyStore/EventLog/Memory/Context/Secrets
src/policy/             Manifest-driven ApprovalGate
src/brain/              Offline EchoBrain (the default cognition seam)
src/feedback/           Feedback items, privacy scrubber, GitHub issue filing
src/runtime/            CompanyRuntime, CycleRunner, cron scheduler, registry
src/server/             Axum HTTP router and handlers
src/openhuman/          OpenHuman launcher seams
src/tiny/               TinyAgents/OpenHuman status surface
src/bin/opencompany.rs  CLI entrypoint
companies/              19 business definitions (a company.toml + docs each)
frontend/               Company-agnostic operator console (Vite + React)
docs/spec/              Architecture reference
docs/modules/           Per-package design docs
vendor/openhuman/       OpenHuman git submodule
vendor/tinyagents/      TinyAgents git submodule

Package surfaces: app (config + shared state), company (manifest parsing, validation, and boot), ports (kernel trait seams), store (file-based default stores), policy (approval gate), brain (offline cognition seam), runtime (company runtime + cycle loop), server (Axum router), openhuman (launcher seams), tiny (vendored TinyAgents status).

See docs/spec/README.md for the architecture reference and companies/README.md for the full company catalog.

License

OpenCompany is licensed under the GNU General Public License v3. See LICENSE.