# Operately is an opinionated company OS, not another project tracker

> Operately is an Elixir and React application that bundles goals, project check-ins, team spaces, message boards and documents into one self-hostable system with a flat-rate licence model and a CLI and API for agents. It is aimed at teams of 5 to 100, and it is deliberately opinionated about how a company should run itself.

**operately/operately** — The open source company operating system.

- Repository: https://github.com/operately/operately
- Website: https://operately.com
- Stars: 592 · Forks: 79
- Language: Elixir
- License: NOASSERTION
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/operately-operately

## The pitch is that execution, not tooling, is the problem

Operately describes itself as an open source company operating system, and the argument it makes is about the failure mode of existing tools. Traditional work management tools give you infinite flexibility but zero guidance on how to actually run an organization, which the README says creates chaos and drains your energy. The alternative offered is an opinionated operating system with structure and discipline built in. The comparison table names Notion and ClickUp as the contrast: tools that let you build anything but leave you to figure out execution. Operately ships with proven workflows instead, described as goal reviews, project check-ins and accountability processes. The stated reason to switch is to focus on building something people want instead of figuring out how to run your organization. That is a product philosophy rather than a feature list, and it is the first thing to evaluate, because a tool that decides for you what a check-in looks like saves you design work and costs you flexibility.

## What is inside: goals, projects, spaces and documents

The feature set is the conventional set of an internal operating tool, arranged with a bias toward cadence. Goals and OKRs track company-wide progress with clear targets linked directly to daily work. Project management covers task boards, milestones and consistent check-ins. Team spaces give departments their own organised home for goals, projects and documents. Message boards replace scattered email threads with discussions that build shared understanding. Documents and files provide a centralised place to create, store and share content. Team management handles onboarding, permissions and company structure. The piece that ties them together is execution cadence, described as built-in check-ins and automated progress updates that create a consistent rhythm. The repository topics list goal-tracking, okr, project-management, operations, business, teams and communication, which is a fair summary of the scope. Nothing here is novel in isolation; the argument is that the pieces are pre-connected into one workflow rather than being six tools you configure yourself.

## The CLI and API are aimed at agents, not just humans

Operately is unusual among project tools in foregrounding programmatic access. The CLI and API feature is described as full programmatic access, with the explicit note that AI agents can create goals, update projects and post check-ins through either interface. On top of that there are published agent skills for Codex and Claude Code, and a listing for OpenClaw, which points at a separate repository holding the skills and a separate hub entry for the CLI. The comparison table makes the point sharply, listing AI agent access as CLI plus API plus skills for Operately against an MCP server plus API for Monday.com and API only for both Asana and Notion. There is a `cli/` directory at the top level of the repository, and the Makefile has dedicated targets for building and testing it, including unit and end-to-end tests and a separate `mcp.test.e2e` target, which suggests the MCP path is treated as a first-class surface rather than an afterthought. The repository also carries a `.agents/` directory and an AGENTS.md, so the project is developed with the same tooling it exposes.

## Self-hosting a single host with docker compose

The quick start downloads a single host tarball and brings the stack up with compose.

```bash
wget -q https://github.com/operately/operately/releases/latest/download/operately-single-host.tar.gz
tar -xf operately-single-host.tar.gz
cd operately
./install.sh
docker compose up --wait --detach
```

The `--wait` flag on compose is what makes that a one-liner, because it blocks until the services are ready rather than returning while the database is still starting. The install script is run before compose, so the configuration is in place before any container starts. The development environment in the repository is a different shape and tells you more about the stack. The compose file runs an app service from `operately/operately-dev:latest` on a Postgres 14.5 database, with a shared memory size of 1g, and it depends on db, s3mock and mailhog, so file storage is mocked and mail is captured locally rather than sent. Several ports are exposed for the dev server, the test server, a Vite server for JavaScript files in development, Storybook, and separate ACME servers for the dev and test environments. The production path uses a separate `Dockerfile.prod`.

## Elixir on the server, React and Turboui on the client

The primary language is Elixir, and the client side is TypeScript and React, with a `turboui/` directory that appears to be a separate UI package. The build tooling in the repository is worth a note, because it shows how the two halves are kept in step. The Makefile runs code generation through `mix operately.gen.page.index` and `mix operately.gen.typescript.api` inside a `devenv` shell, which produces the TypeScript API types and the page index, and the generated TypeScript is then formatted with prettier. A separate `mix operately.gen.api.docs` target generates API documentation and `mix operately.gen.api.catalog` produces an API catalog, both of which feed the published API docs. That is a deliberate contract between the Elixir backend and the TypeScript frontend, generated rather than hand-maintained, and the `gen` target runs prettier over the generated files to keep formatting consistent. The Makefile also carries screenshot and timing test targets, and the repository has `specs/`, `tests/` in the compose setup, and a Gemfile, which suggests some tooling still lives in the Ruby ecosystem.

## Who it is for, and the licence question you have to settle

The stated audience is specific: technology companies and startups, nonprofits, consulting firms, and compliance-focused organisations that need structured goal tracking and project management without enterprise complexity or per-seat pricing, with the guidance that it works best for teams of 5 to 100. The size range is the important part, because it is a product built for a specific scale rather than one that scales from five to five thousand. The licence terms are genuinely unclear from what is published, and that needs settling before you deploy it. The README carries an Apache 2.0 licence badge and the comparison table lists Operately as open source under Apache 2.0, but the licence identifier recorded for the repository is a custom licence that GitHub cannot classify, with the terms in the LICENSE file. Those two statements do not agree, and a licence badge is not the licence. A company that intends to run this as internal infrastructure for a commercial business should read the LICENSE file and confirm which terms apply before going further. The release history is steady, with 1.8.0 in July 2026, 1.9.0 in September 2026 and 1.10.0 on 2026-10-20, the same day as the last push.

## Conclusion

Adopt Operately if you run a small to mid-sized team that wants goals, project check-ins and documents in one self-hosted system, and you are willing to accept a fixed workflow rather than a blank canvas. Skip it if you need a flexible tool you can shape freely, since opinionated is the point, or if you need per-seat billing to match how you already charge. Before you commit, read the licence file, because the repository's licence identifier does not match the Apache 2.0 the README badge claims, and run the single-host install with the compose file before you trust the data model.

## FAQ

### How do I install and run Operately?

Download `operately-single-host.tar.gz` from the latest release, extract it, run `./install.sh` inside the `operately` directory, and then bring the stack up with `docker compose up --wait --detach`. The installation guide at operately.com/install covers the details.

### Can AI agents use Operately?

Yes. The CLI and API give full programmatic access, and the documentation says agents can create goals, update projects and post check-ins through them. Skills are published for Codex and Claude Code, with a separate listing for OpenClaw.

### How does Operately differ from Notion, Asana or Monday.com?

The comparison table states that Operately is open source and self-hostable, ships built-in goals and progress check-ins rather than paid add-ons, uses a flat rate instead of per-seat pricing, and gives agents CLI plus API plus skills where the others offer API only.

### What team size is Operately designed for?

The documentation says it works best for teams of 5 to 100, and targets technology companies and startups, nonprofits, consulting firms and compliance-focused organisations that want structured goal tracking without enterprise complexity or per-seat pricing.

## Sources

- [Issues](https://github.com/operately/operately/issues)
- [operately/operately on GitHub](https://github.com/operately/operately)
- [Project website](https://operately.com)
- [README](https://github.com/operately/operately/blob/main/README.md)
- [Releases](https://github.com/operately/operately/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/operately-operately