> ## Documentation Index
> Fetch the complete documentation index at: https://koreai.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Collaborate with Git

Each project has one shared working copy. A second person who opens the same project doesn't get a private sandbox. Use Git and a clear ownership model so that several developers can change one project without overwriting each other.

## Roles and the Git permission

Studio's Git actions need the `project:git` permission. The built-in Admin project role has it. The built-in Developer role doesn't.

| In a project | Admin | Developer | Tester | Viewer |
| - | - | - | - | - |
| Edit agents, tools, workflows, and tables | Yes | Yes | Read | Read |
| Select project models | Yes | Yes | Read | Read |
| Write and run evals | Yes | Yes | Yes | Read results |
| Publish agent versions | Yes | Yes | No | No |
| Create deployments | Dev, staging, production | Dev, staging | No | No |
| Git: connect, push, pull | Yes | No | No | No |
| Manage project members | Yes | No | No | No |

To give builders Git access without full admin rights, a workspace admin creates a custom role with `project:git` at **Admin** → **Team** → **Role Management** → **Create Role**, then assigns it on the project. See [Workspace and team settings](https://koreai.mintlify.site/agent-platform/administration/workspace-and-team.md).

## Choose a working pattern

| Pattern | Fits when | Keep in mind |
| - | - | - |
| **One shared project, with a named owner for each agent** | A small team can coordinate edits and avoid touching the same agent at once. | Tell teammates before you edit shared agents or tools. Pull remote changes before you start. |
| **A separate project per developer or workstream, each connected to its feature branch** | Several people need isolated working copies and parallel changes. | Each project has one Git integration and one branch. Configure the required models, auth profiles, and environment values in each project. |
| **An integration project plus a CI-only project** | You need a predictable merge and evaluation gate. | Keep CI as the only writer to its project. Run read-only pull-request sets there; isolate and reset data for write evaluations. |

The editor shows an advisory lock for about 30 minutes, and a save checks whether the source changed since you read it. A conflict dialog offers choices. It doesn't merge two edits for you.

## Review through Git

Connect the project at **Project** → **Settings** → **Integrations** → **Git** → **Connect Repository**. Change agents in the working copy, then use **Push to Remote** with **Create pull request**. After a merge, use **Pull from Remote** before anyone edits in Studio again.

* Never edit the same agent in Studio and in the repository between syncs.
* Let the push rebuild `abl.lock`. Never merge it by hand.
* In CI, run validation and an eval gate on a project that only CI writes to. Keep eval sets that write out of the pull-request gate.

See [Integrations settings](https://koreai.mintlify.site/agent-platform/administration/integrations-settings.md) to connect a repository.

## Hand off a feature branch

**1. Create the workstream project**

Create a project for the workstream, and connect it to the intended repository branch. Confirm the repository and sync path with the project owner.

**2. Pull and resolve dependencies**

Select **Pull from Remote**. Resolve the listed setup dependencies, such as models, auth profiles, and environment values.

**3. Agree on ownership**

Agree on an owner for each agent, workflow, and shared tool. Avoid simultaneous edits to the same definition.

**4. Change, validate, and push**

Make a focused change, validate it, and run its scenarios. Then select **Push to Remote** and create a pull request.

**5. Integrate**

After the merge, the integration project pulls the branch. Review the resulting diff, and rerun the integration checks.

## Resolve a save conflict

Keep the conflict strategy set to **Manual**. Reopen the current source, compare both edits, merge them on purpose in the editor, and rerun validation. Don't overwrite from a stale copy, and don't hand-edit generated `abl.lock` entries.

Share tools by contract, and give each shared tool one owner. Each agent repeats the tool signature and description, so a contract change must update every consumer and its checks.

## Team working agreement

1. Name one owner for each agent, workflow, and shared tool. Tell the team before you edit shared resources.
2. Pull before a work session. Don't edit the same definition in Studio and Git before you sync.
3. Keep the conflict strategy at **Manual**. Resolve a stale-save dialog from the latest source; never overwrite a teammate's change from a stale copy.
4. Use a separate project and feature branch when work needs an isolated working copy. Confirm its repository and sync path.
5. Push through the supported Git flow, and create a pull request. Let the platform rebuild `abl.lock`.
6. Run read-only evaluation gates in a CI-only project. Keep write scenarios separate, reset their data, and reconcile any unknown outcome before a retry.
7. Review the diff, validator output, baseline status, affected run cases, and traces before you approve the merge or release.

For CI commands, see [Evaluate agents](https://koreai.mintlify.site/agent-platform/best-practices/evaluate-agents.md#run-evaluations-in-ci).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.