Company OS,
layer by layer.
The simple version is four steps: connect, know, act, work. This page opens each one up, so you can see every part and how they fit together.
Click any part to jump to its details.
Connect
How your data, rules and actions get in.
Context engineering
Your data, your rules and your actions, plugged in.
Company OS connects to the systems you already run. It doesn't just copy data out. It learns your business rules too, and gets permission to act back in those systems.
- Data: live sync from email, Slack, CRM, calendars, files and databases (800+ connectors)
- Logic: your formulas, pricing rules, approval chains and existing scripts
- Actions: safe write-back, like updating a deal or opening a ticket
- Real-time, scheduled or streaming, with or without code
Know
How it understands your company.
Knowledge graph
One connected model of your company.
Every person, customer, deal, project and document becomes an object, linked to the others. The graph records what things are, what can be done to them, and the decisions made along the way.
- Things: people, customers, deals, projects, documents
- Actions: what each role or agent is allowed to do to each thing
- Decisions: who decided what, when, and why
- History: see any record as it was on any date
Swipe to see the whole graph.
Documents & search
Every file, searchable by meaning, with sources.
Documents, images, audio and video are read, indexed and linked to the graph. Search mixes keywords, meaning and relationships, then checks its own evidence before it answers.
- Docs, spreadsheets, images, recordings and transcripts
- Hybrid search: keywords, meaning and graph links, re-ranked for accuracy
- Self-checking: it searches again when the evidence is thin
- Every answer cites its sources
Tools & compute
The safe building blocks agents and apps use.
Each tool is one clear action: read a report, run a calculation, update a record. Tools carry their own permissions and limits, and they run wherever the work needs them to.
- Data, logic and action tools with clear inputs and outputs
- Permissions and rate limits on every tool
- MCP support, so any compatible AI app can use them
- Runs on demand, on a schedule, in batches or as a stream
Act
How work gets done.
Agent lifecycle
Build, run and test agents like real software.
Agents are put together from tools, knowledge and rules. A lead agent can hand work to specialists, or to a person. Every agent is tested before release and scored while it runs.
- Build: pick the role, tools, data and rules
- Orchestrate: agents hand off to other agents or to a person
- Evaluate: tests on every change, plus live scoring
- Memory: agents remember past work and what worked
An example scorecard. Every agent gets one, and it must pass before a release.
Automations
Work that starts on its own.
Not every job needs an agent. Plain automations run on a schedule, fire when something happens, or start when another system calls them.
- Scheduled: every Monday at 7:00, or at month-end
- Event-driven: when an invoice lands or a deal changes stage
- API-driven: your own apps and partners can call them
- Retries and alerts built in, so nothing fails silently
Work
How your people use it.
Apps & dashboards
Tools your team actually opens.
Build internal apps and live dashboards on top of the knowledge graph, without starting from scratch. Every number links back to the records behind it.
- No-code and low-code app building
- Live dashboards and analytics
- Workflow and task management
- Scheduling and resource planning
| Deal | Stage | Owner |
|---|---|---|
| Acme renewal | Contract | Maria |
| Northwind | Proposal | Sam |
| Globex | Won | Priya |
Teams & developers
A place for every team, and a door for engineers.
Operations, sales, finance and leadership each get assistants and views shaped for their work. Developers get APIs, an SDK, notebooks and IDE extensions to build on the same foundation.
- Team workspaces, with assistants in Slack, email or the app
- APIs and an SDK for your own software
- Notebooks and a code workspace for analysts and engineers
- IDE extensions and MCP for AI coding tools
Across everything
What keeps it safe, fast and under control.
Security & governance
Everyone sees exactly what they should.
Access follows your org chart and your data labels, for people and agents alike. Big actions pause for a person, and risky changes are tried in a safe sandbox first.
- Access by role, by data label and by purpose
- Approvals and checkpoints on high-stakes actions
- Safe sandboxes to test changes before they go live
- Secrets kept in a vault, never inside prompts
| Role | Public | Internal | Confidential | Restricted |
|---|---|---|---|---|
| Sales team | ||||
| Finance team | ||||
| Contractors | ||||
| Bookkeeper agent |
Model gateway
Any model, behind one safe front door.
Every AI call goes through one gateway. It masks private data, picks the right model for the job, and falls back to another model if one is slow or down.
- Commercial models: OpenAI, Anthropic, Google, xAI
- Open-source models, your own models, or Local AI
- Private-data masking and content filters, in and out
- Smart caching, retries and fallbacks, with usage limits and budgets
Need it fully private? See Local AI
Back to the mapObservability
See every step, cost and result.
Every question, agent run and automation is traced from start to finish. You can see what happened, how long it took, what it cost, and whether it was right.
- Step-by-step traces for every run
- Cost and speed per model, per agent, per team
- Quality scores, with alerts when results drift
- A full audit log of where each answer came from
Build & ship
Change it safely. Roll it back instantly.
Agents, prompts, tools and apps are versioned like code. Changes move from a sandbox to testing to production, and any version can be rolled back.
- Versions for agents, prompts, tools and workflows
- Separate environments: sandbox, testing, production
- Release channels, so a change can reach one team first
- One-click rollback to a known-good version
Two things Company OS does all day.
AWhen someone asks a question
BWhen an agent takes action
Built for production, not demos.
Company OS runs on the same agent architecture we use for every build. These are the parts that keep it fast, safe and reliable.
- Working memory
- Long-term memory
- Memory of past runs
- Shared team memory
- Task breakdown
- Workflow graphs
- Retries and timeouts
- Escalation to people
- Planning
- Self-checks
- Confidence scores
- Error recovery
- Policy engine
- Prompt-injection defense
- Secret vault
- Sandboxed code
- Replay-safe actions
- Dead-letter queue
- Graceful fallbacks
- Checkpoint and resume
- Model routing
- Prompt caching
- Answer caching
- Cost tracking
- Checks on every change
- Nightly test runs
- Live monitoring
- Human feedback
- MCP
- Agent-to-agent protocols
- Webhooks and APIs
- Data lineage
Runs where you need it.
Managed by us
We host it, watch it and keep improving it.
In your cloud
Deployed into your own AWS, Azure or Google Cloud account.
Walk through the architecture
with an engineer.
Tell us what you want to dig into. We'll map it to your own tools and data.