start here

start using Go with your agents

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

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

go ai agent: agents that build, test, and vet a go module for real

add the go toolchain to a project's setup script and its agents run go build, go test, go mod tidy and gofmt against the module, reading real compiler output.

runs on
conversation sandbox
installed by
setup script
category
runtime

go is the case where having a compiler in each conversation's sandbox changes the quality of what an agent produces, not just its speed. a type error is not a matter of opinion, and an agent that can build finds out immediately.

what agents do with it

once the setup script has run, go and gofmt are in the sandbox's path. agents build the module with go build ./..., run the suite with go test ./..., tidy the module graph with go mod tidy, format with gofmt -w ., and run a program directly with go run .. each of those is a real invocation against the real checkout, so the compiler is the reviewer for anything structural before a human ever sees it.

the matching skill

go ships with a skill of the same name. it carries the build and test commands, dependency tidying, formatting, and running from the module directory. skills load only for the agents you assign them to, so the engineer on the go service carries it and the reviewer in the same project does not have to.

example tasks

  • 01

    add the new handler and make sure the whole module still builds.

    the agent writes the handler, builds the module in the conversation's sandbox, fixes the interface mismatch the compiler names, and runs the suite before reporting.

    writebashedit
  • 02

    there is a data race in the worker. find it.

    it runs the tests with the race detector in the conversation's sandbox, reads the exact goroutine trace, and points at the shared map rather than guessing at locks.

    bashreadgrep

what to know before installing

the project needs a sandbox. put the toolchain install in the setup script and print the version at the end, so the last run's output in settings → server records what landed.

how to install Go

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

  1. give the project a sandbox

    Go 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 Go'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 Go 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 Go 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

what does installing go on a project give the agents?

the go toolchain in each conversation's sandbox, with go and gofmt on the path. agents run go build ./... and go test ./... against the module, tidy dependencies with go mod tidy, and format with gofmt, all through the bash tool.

why does a compiler matter so much for an agent?

because go's compiler is strict and its errors are precise. an agent that can compile gets told exactly which type does not satisfy which interface, on which line, instead of producing code that looks right and fails when someone else builds it.

can agents run the full test suite?

yes. go test ./... runs in the conversation's own sandbox against the checkout that is already there, so table tests, race detection and benchmarks all produce real output the agent can read and act on.

is there a matching skill?

yes. go ships with a skill of the same name covering go build, go test, go mod tidy, gofmt, and running a program with go run. skills load only for the agents you assign them to.

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.