start here

start using Git with your agents

sign up, open a project, and add Git to its setup script in settings → server.

Start 7-day trial with Git
integrationstechnologyupdated
schematic diagram of the work aldena agents do through Git
Git

git ai agent: branch, commit, and rebase a real checkout

add git to a project's setup script and its agents work a real checkout: branches, commits, diffs, history and rebases, on the machine that runs the test suite.

runs on
conversation sandbox
installed by
setup script
category
version control

git is the smallest technology in the catalog and the one most other work leans on. the git cli is in the sandbox's path, where every agent in the project reaches it through the bash tool.

what agents do with it

the connectors move code between the project and github or bitbucket. git is what happens in between. an agent creates a branch, stages exactly the files it changed, writes a commit message that describes the change rather than the diff, reads git log to find when a behaviour appeared, and runs git diff before it claims anything is done. when a rebase conflicts, it resolves the conflict in the working tree on the same machine that runs the tests.

the matching skill

git ships with a skill of the same name. it carries two rules that matter in a shared repository: configure user.name and user.email before committing, and never force-push a shared branch. skills load only for the agents you assign them to, so the engineer carries it and the reviewer in the same project does not have to.

example tasks

  • 01

    which commit broke the checkout flow?

    the agent reads the history around the change, checks out candidate commits in the conversation's sandbox, runs the failing test at each, and names the commit rather than guessing.

    bashreadgrep
  • 02

    split my working changes into two commits, one per concern.

    it reads the diff, stages the hunks that belong together, writes both commit messages, and shows you the result before anything is pushed.

    bashedit

what to know before installing

the project needs a sandbox. most provider images, boat's included, already ship git; if yours doesn't, add it to the setup script. pushing back to a provider still needs the matching connector and its write scope, so git alone gives agents a local working tree and nothing beyond the project.

how to install Git

Git goes in the project's setup script, not once per team and not on your laptop.

  1. give the project a sandbox

    Git runs in each conversation's sandbox, on your team's own sandbox provider account. an owner or admin connects a provider once on the team's providers page, then picks it and a default size for the project, at creation or later in settings → server. a project with no sandbox has nowhere to run it.

  2. add it to the setup script

    settings → server holds the project's setup script, a bash script that runs once on each new sandbox, in /project, with sudo. add Git's install commands there and save.

  3. the next sandbox runs it

    the script runs when a conversation's sandbox is created or reused, on the conversation's first turn. settings shows the last run with its exit code and output, and a failed run leaves the sandbox usable rather than blocking the project.

  4. agents use it through bash

    from then on every agent in the project reaches Git with the bash tool, on the same filesystem as the checkout they are working in. the conversation's sandbox keeps it between turns, sleeping when idle and waking with the next one.

where Git actually lives

each conversation in a project gets its own sandbox on your team's sandbox provider account, and the project's setup script in settings → server decides what is on it. two projects never share a filesystem, so a version pinned for one client cannot collide with another's.

the sandbox provider bills its machine time to your team's account while it runs, and aldena adds nothing. the sizes are on isolated projects, and what agents may run in the sandbox is governed by the project's tool permissions.

faq

why install git when the github connector already syncs repositories?

the connector clones and pushes. git in the conversation's sandbox is what agents use in between: branching, staging, committing, reading a diff, checking history, resolving a conflict. one moves code between the project and the provider, the other is the day to day work.

does the agent commit as me?

the shipped git skill tells agents to configure user.name and user.email before committing, so commits carry a clear author rather than a blank one. pushes go through the connector, which authorised against a real account, so the provider records who it was.

can an agent force-push over my branch?

the git skill says never force-push shared branches, and git runs through the bash tool, which is a mutating tool that stops for your approval by default. a project can also set bash to deny outright in its tool permissions.

is the checkout still there tomorrow?

yes, within a conversation. each conversation's sandbox keeps its files between turns, sleeping when idle and waking with the next one, so a branch left half finished is still there next time. a conversation left quiet for 7 days gives its sandbox back, and its next turn starts fresh. two projects never share a filesystem, so one client's checkout cannot collide with another's.

ready when you are

spin up your first project.

one project per client, product, or piece of work, staffed with intake, requirements, build and code review agents.