# OpenAI Dots for teams: open-source rules a reviewer can diff

> A team gives an agent its own login only after a reviewer can say what it may touch, who approves the step and what record is left afterwards. Kortix is the open-source AI Operating System, and in a Kortix project those answers are lines in a manifest that arrives in a diff.

URL: https://openaidotsalternative.com/openai-dots-for-teams

## Kortix and OpenAI dots, side by side for a team review

The questions a security reviewer asks first, answered for both stacks.

| | Kortix (recommended) | OpenAI dots |
| --- | --- | --- |
| Open source | Yes. Code you can read, fork and audit. | No. |
| Per-agent permissions | Grants per agent in `kortix.yaml`; an omitted grant resolves to none. | ChatGPT app controls; each specialist dot has its own credentials. |
| Approvals | You set allow, ask or block per tool call, down to the arguments. | Custom Rules act, require approval, or block a step. |
| How finished work lands | A change request a person reviews; merge is default-deny for agents. | Results in the conversation; Activity View shows status. |
| Workspace data | Configuration, memory and connectors live in your git repo. | Workspace content is not used to improve models by default. |

## The file a reviewer reads

`kortix.yaml`

```yaml
# v2 is deny-by-default: an omitted connectors/secrets/kortix_permissions/
# skills grant resolves to "none", so a scoped specialist starts locked down.
agents:
  kortix:
    file: agents/kortix.md
    connectors: all
```

Source: https://github.com/kortix-ai/suna/blob/dev/packages/starter/templates/base/kortix.yaml

The starter's default agent is granted everything on purpose, so a new project works on day one; every other agent in that map gets only what its block lists, because an omitted grant resolves to none.

## What a security review asks before an agent acts alone

An agent with its own login is a new principal inside the company. It holds credentials, reaches systems of record, and keeps working after the person who set it up has gone home. A reviewer signs that off only when five things hold.

The identity comes first. OpenAI sets a specialist dot up with "its own identity, credentials, and access to the systems it needs", so one agent can be revoked without touching a person's account. Kortix runs people and agents through one permissions model: per-resource permissions for people and agents, with roles, groups, and an audit trail.

Credentials are the second question. Dots reach supported sites through secure sign-in: the model pauses while the password goes to the browser, and saved passwords arrive from an encrypted credential service without entering the model's context. OpenAI names the limit itself, since a secret pasted into a message can still be visible to the model. In a Kortix project a secret is declared by name in `kortix.yaml`, and its value never appears in the repo.

Then the scope. A dot inherits the workspace's app connections, managed in the plugins settings and shared across ChatGPT, ChatGPT Work and Codex. Built-in action rules and Custom Rules sit on top. In Kortix the `agents:` map in `kortix.yaml` is the scope: connectors, secrets, permissions and skills per agent, with an omitted grant resolving to none. That map is a file a reviewer can read before the pilot starts.

The decision before the step is the fourth question. Before a dot sends, shares or changes anything, Auto-review checks the step against your instructions, your rules and OpenAI's safety requirements, and a blocked step comes back with a reason. Password changes and transfers between accounts stay with the person. Kortix leaves approval gates off until you set them, then holds the call until a person answers.

The record comes last. Activity View lists a dot's ongoing and delegated tasks with their status, and a person can redirect or stop the work there. On Kortix the record is the branch: the commits, the change request and its diff.

Both stacks answer these questions. What a reviewer has to decide is where the answers live: in settings spread across a product, or in a file that arrives in a diff.

## From pilot to rollout

OpenAI describes the current shape plainly. Specialist dots start as focused enterprise pilots across procurement, invoice processing, email marketing, customer support and commercial contracting. OpenAI's engineering teams work with each organization to define a dot's responsibilities, the tools it can use and how people review its work. Integration with Microsoft Agent 365 is planned, so dots can be managed through Microsoft's governance tools. That is a careful way in, and it leaves the rules inside a vendor's product.

The Kortix version is duller and easier to undo. A grant is a line in the manifest. Memory and connectors are declared in the same repo, and the work is commits. Change a grant and it is a one-line diff that goes through review like any other change to the repo. Clone the repo and you hold every rule your agents follow ([Kortix on GitHub](https://github.com/kortix-ai/suna)).

OpenAI is the better pick for one team: the one that wants a capable always-on agent inside ChatGPT, with no repository and no manifest to maintain. The review gets hard at the point where the agent holds a company identity, touches a system of record and keeps running while everyone sleeps. At that point the permissions have to be something a reviewer can comment on and diff against last quarter's version. [The head-to-head comparison](/openai-dots-vs-kortix) covers the rest of the field.

## Questions teams ask before a pilot

Two answers, both taken from OpenAI's own pages.

### Does an OpenAI dot get its own identity and credentials?

Yes. OpenAI says a company sets up each specialist dot with "its own identity, credentials, and access to the systems it needs", so one agent can be revoked without touching a person's account.

### Does OpenAI Dots work with Microsoft Agent 365?

Not yet. OpenAI lists Microsoft Agent 365 integration as planned, so a team that governs agents through Microsoft's tools has no shipped path today. Dots stay inside ChatGPT's own admin controls until then.

## Start with a manifest a reviewer can read

Kortix is open source, and every grant your agents obey arrives in one file that shows up in a diff.

[Try Kortix](https://kortix.com) · [Read the docs](https://kortix.com/docs)