Enterprise

Every client gets an open-source CompanyOS in one repo

Kortix is the open-source CompanyOS a consultancy hands over as one git repo per client: agents, skills, memory, connectors, and policy the client owns.

The Kortix Team
Kortix··6 min read

Kortix is the open-source CompanyOS. A workforce of agents does real work, and everything that defines the system is files in one git repo you own. For consultancies, that matters because the deliverable is no longer a single chatbot. The deliverable is a governed project the client can keep running after the pilot. If you want the full product spine first, read Introducing Kortix.

The market is already pointing this way. Accenture AI Refinery frames enterprise AI around agents, knowledge, models, and governance. Deloitte describes multiagent systems. They understand requests, plan workflows, coordinate role-specific agents, collaborate with humans, and validate outputs. The missing question is where all of that lives so it can be owned, reviewed, repeated, and ported into the tools people already use.

The pilot is not the product

Most client engagements start with a useful prototype: a support agent, a sales-research assistant, a finance close helper, a legal intake workflow, a marketing campaign planner. The prototype proves demand. Then the real work starts.

  • Who owns the instructions? If the prompt lives in one vendor dashboard, the client cannot audit or improve it like normal operational IP.
  • Where does the context accumulate? If every tool stores a different slice of memory, the organization never gets one shared brain.
  • How are tools governed? Reading a CRM, sending an email, querying Stripe, and posting in Slack should not have the same permission profile.
  • How does the work become official? A finished deliverable needs review, history, rollback, and a clear path into the client’s source of truth.
  • How do you repeat it for the next department? The second project should be a fork of the first.

A proof of concept can avoid those questions. A production program cannot. The operating layer becomes the product because it decides whether the client gets a one-off demo or a system that keeps improving.

One client, one repo

In Kortix, a project is a repo. That repo contains the company’s agents, skills, memory, triggers, connector policy, sandbox definition, and operating instructions. One kortix.yaml defines how the project runs. Every session happens on an isolated branch, and a change request is how its work reaches main.

acme-project/
├─ kortix.yaml              # project, sandboxes, triggers, connectors, policy
├─ agents/                  # role-specific agents: finance, support, sales, legal
├─ skills/                  # repeatable client playbooks and workflows
├─ memory/                  # durable company context and decisions
├─ commands/                # approved operating motions
├─ artifacts/               # reports, briefs, packets, launch plans
└─ docs/                    # source-of-truth operating docs

Plain files are the reason the project can be handed to a client without trapping them in your service team forever. Files can be inspected. Diffs can be reviewed. A successful sales-ops project can be forked into a recruiting project, and a regulated client can run the same pattern in their own VPC or on-prem environment. The docs walk through the project, session, and change request model in detail.

The project needs five layers

If you are bringing AI into a client’s company, a chat UI will not carry the work. A serious agent project needs at least five layers working together:

  • Context. The policies, playbooks, decisions, customer notes, docs, and memory the agents need to act like part of the company.
  • Agents and skills. Named roles and reusable workflows, not one giant prompt that tries to do everything.
  • Connectors. Access to the real systems of work (Slack, Gmail, HubSpot, Stripe, Linear, Notion, warehouses, internal APIs), brokered through scoped credentials instead of pasted keys.
  • Policy. Tool-level allow, ask, and block rules so a project can automate research freely and still pause before it sends, pays, deletes, or posts.
  • Review. A change request path for durable work: what changed, who requested it, what the agent touched, and what a human approved.

The unit of delivery is a governed project where many agents can do real work safely.

Governance belongs in the runtime

Enterprise buyers ask where secrets live, how access is scoped, what gets logged, how approvals work, how quickly a bad change can be reverted, and whether the system can run under their infrastructure constraints.

Kortix was built around those constraints. Sessions run in disposable Linux sandboxes on their own branches. Connector credentials are brokered server-side and never enter the machine. Secrets are encrypted at rest with a key per project. Session work reaches main through a change request. Merge is default-deny for agents. The same project can be used from the web, Slack, Teams, CLI, API, and MCP, so no one has to adopt another destination app. Those mechanisms turn a connected LLM into a controlled workforce, one that survives procurement, security review, and the third month of production use.

Why consultancies feel this first

Consultancies and systems integrators are where the repeatability pressure shows up fastest. They need to deploy the same architecture across many clients, many departments, and many compliance profiles. The plumbing cannot be rebuilt for every client.

  • For the partner: one horizontal platform can become the delivery substrate for many vertical offerings.
  • For the client CTO: the project is Git-backed, self-hostable, and inspectable instead of a vendor-owned service wrapper.
  • For the delivery team: each department gets its own agents, memory, connectors, and policies without losing the shared pattern.
  • For the end user: the agent shows up where they already work (Slack, Teams, web, CLI, API) instead of asking every employee to adopt another AI portal.

This is also where open matters: a consultancy cannot credibly tell a bank, manufacturer, or healthcare company that their future operating layer is a closed prompt stack nobody can inspect. The closer agents get to real work, the more the client needs to own the substrate. That is why Kortix is open, self-hostable, and built for enterprise deployment from the start.

What to build first

A first project has to be narrow enough to ship and important enough to prove the operating model, so pick one workflow where the client already has documents, tools, approvals, and recurring pain. Then encode it as files.

  • Sales renewal project: read CRM context, summarize account risk, draft renewal plans, open human-reviewed follow-ups.
  • Support triage project: monitor tickets, classify urgency, draft replies from docs, escalate edge cases with evidence.
  • Finance close project: pull reconciliations, produce variance notes, flag missing evidence, create the close packet for review.
  • Recruiting project: source candidates, enrich profiles, draft sequenced outreach for the hiring manager to review, log every touch, never send without approval.
  • Engineering review project: review PRs, run checks, verify previews, and return concrete blockers instead of vague comments.

Kortix runs internal sweeps for production errors, PR review, docs maintenance, weekly briefs, and outbound research.

A quick test for your stack

Before you choose a platform, ask five questions:

  • Can the client clone or export the actual operating layer (agents, skills, memory, policy, and triggers) as files?
  • Can two hundred agents run in parallel without sharing one fragile machine or one user’s desktop state?
  • Can tool access be scoped per person, group, agent, and action?
  • Can a security reviewer see what happened after the fact: prompts, tool calls, commits, approvals, and diffs?
  • Can the same project move from cloud to VPC to on-prem without changing the basic model?

Run those five questions past every platform on your shortlist. Five yeses are what separate a good agent demo from a CompanyOS.

Build the client project as files, then run it with agents.

Start with one department, connect the tools it already uses, and turn the workflow into a git-backed project the client can own.

Get started

Own your company’s AI.Start today, in our cloud or yours.

Start for free

Open source · SOC 2 Type I · SAML SSO and SCIM · Any model, your keys