Agentome GitHub
Contents

Integrations

Agents work in your own systems: GitLab and GitHub for code, Jira Data Center for issues, any MCP server for the rest, and the model provider of your choice for agents on the server. This page shows how to connect each one, and what agents can and cannot do through it.

How agents reach your systems

Integration tokens stay on the server. An agent never holds them, on a person's computer or on the server:

Each call goes by the agent's tool policy: allowed, asked, or denied. See Approvals and control.

GitLab and GitHub

A connection belongs to a project. It gives the agents of that project access to the repositories under one GitLab group or one GitHub owner, as the account the token belongs to. Only admins manage connections, and a project must exist first (see Projects and tasks).

Admin, Connections: a GitLab group and a Jira project, each with its project, the account it acts as, and when it was checked.

Prepare a token

Decide which account the agents act as. A bot account and a person's account both work. Whatever the agents do (branches, change requests, comments) shows that account's name on the host.

Give the account access only to what the agents need.

Add the connection

  1. Go to Admin → Connections and select New connection.
  2. Under Connect to, pick GitLab or GitHub.
  3. Pick the Project.
  4. Under For, keep Every agent of the project, or pick one agent. An agent with a connection of its own acts as that account; the others use the project's.
  5. For GitLab, fill in the GitLab address, such as https://gitlab.acme.com, and the Group, such as acme/platform. Subgroups are reached too. For GitHub, fill in the Owner: the user or organization, such as acme.
  6. Paste the Token and select Connect.

The Acts as column shows the account the token belongs to once the token is checked. The row's menu has:

The token is stored encrypted and never shown again.

Cloning and pushing

A run clones the task's repository through the git proxy, on the computer that runs it. The agent commits there and pushes back through the proxy. The proxy enforces four rules, whatever the agent tries:

The proxy checks a push before the branch moves. The commits land first on a ref of its own under refs/agentome/, on which no pipeline runs; the branch moves to them only once they pass, and the ref is deleted. So a pipeline never starts on a commit the proxy refused.

The proxy opens only for a run that is still working. When the run ends, is cancelled or reaches its time limit, its access ends with it.

What CI runs for an agent's push

A push to agent/… starts the repository's pipeline, as anyone's push does: that is how Fix failed pipelines (below) learns the agent's change broke something. The pipeline is the one on your default branch, but it runs the agent's code: its tests and the scripts its jobs call. So keep CI secrets out of its reach:

Change requests

When its work is ready, the agent opens a change request: a merge request on GitLab, a pull request on GitHub. It may open it as a draft.

Open a change request asks the owner first by default. The request waits in Approvals with the title and description the agent wrote, and opens only when you approve it. You can change that in the agent's Tools & policies.

The change request is linked on the task, with its state and its pipeline. With webhooks set up (see below), the task follows it: when the change request is merged, the task is done.

The agent can also read a change request and its review, read a pipeline's failures, and reply on a change request. Each is a tool with its own policy.

Webhooks for pipelines and reviews

Webhooks tell Agentome when a change request or its pipeline changes. Without them, the task does not learn that its change request was merged or its pipeline failed.

  1. In Admin → Connections, open the connection's menu and select Webhook settings.
  2. Copy the Payload URL and the Secret. The URL has the form https://<your server>/webhooks/gitlab/<connection> or .../webhooks/github/<connection>.
  3. Add a webhook on the host with them.

On GitLab, in each repository's settings under Webhooks, or once in the group's settings where your GitLab edition has group webhooks:

On GitHub, in the organization's or the repository's settings, under Webhooks:

The host must reach your Agentome server at its public address.

What a project does with them

On the project page, When something happens has three settings:

A webhook starts at most three runs a day for one task, and only within the budgets.

Jira Data Center

A Jira connection turns the issues of a Jira project into tasks of an agent or of the project's team, and moves the issues as the work goes. Agentome polls Jira, so there is nothing to set up on the Jira side. Jira Data Center 10 or newer is supported.

The New connection dialog for Jira: the project, where issues go, the Jira address, the project key, a JQL filter, and the statuses to move the issue to.

Prepare a token

Make a personal access token for the account that may see, move and comment on the issues. Agentome moves issues and comments as that account.

Add the connection

  1. Go to Admin → Connections and select New connection.
  2. Under Connect to, pick Jira.
  3. Pick the Project.
  4. Under Issues go to, pick an agent, or The project's team: its lead gets the issues and splits them, and starts at once if the project says so.
  5. Fill in the Jira address, such as https://jira.acme.com, and the Project key, such as PAY.
  6. Optionally, fill in Filter (optional) with JQL that narrows the project's issues, such as labels = ai-team. Only issues that match become tasks.
  7. Under Move the issue to, give the status names of your workflow for On run start, On review and On merge. The defaults are In Progress, In Review and Done. Use the names exactly as your workflow has them.
  8. Paste the Token and select Connect.

An issue's summary and description reach the agent as data, not as its task: the run is told to do the work the issue describes, with the issue's words in a marked block that it is told not to obey. That makes a planted instruction much less likely to work, not impossible. When the project's lead starts on new issues at once, anyone who can file an issue in the filter starts a run: keep the tools that write outside on Ask for such an agent, or let a person start each task.

How issues and tasks follow each other

The agent can also read the issue and comment on it during a run. Comment on the Jira issue asks the owner first by default.

If Jira refuses a step, the task shows the error, and later steps try again.

MCP servers in the Library

Any remote MCP server can give agents more tools: a tracker, a wiki, a database. You add it once to the Library, then give it to agents.

The Library: skills and MCP servers, with one MCP server open, showing its address, its sign-in and the tools it lists.

Add a server

  1. Open Library and select Add an MCP server.
  2. Fill in the Name, in lowercase, such as tracker. Its tools reach the agent as tracker__<tool>.
  3. Fill in the Address of the server, such as https://mcp.acme.com/mcp. It must be a remote server over streamable HTTP.
  4. Under Sign-in, pick one:
    • A token: paste it in Token. Agentome sends it as Authorization: Bearer and the token. Another scheme, such as Basic, can be typed whole. The token is optional.
    • OAuth in the browser: each person signs in with their own account.
  5. Describe What it does, so others know when to use it.
  6. Select Add server, or Add and sign in for OAuth.

Agentome checks the server and lists its tools.

An MCP server added to the Library: its address, its sign-in, who added it, who it is shared with, and the tools it listed.

Secrets stay on the server

A server's token is kept on the Agentome server, encrypted, and is not shown again. It never reaches a person's computer: an agent calls the server's tools through the MCP gateway, which adds the token.

Share it and give it to agents

A new server can be used only by the person who added it. An admin can select Share with everyone in its menu, and then everyone can give it to their agents.

To give a server to an agent, open the agent's Tools & policies and pick it in Add an MCP server. Its tools then appear under its name, and each asks first until you set it otherwise.

The server's menu also has Check again, to read its tools again after it changed, and Delete.

OAuth sign-in per person

With OAuth in the browser, each person signs in once with Sign in on the server's page in the Library, and their agents use their account. A person who has not signed in sees Not signed in, and the server lists its tools after they sign in.

Sign-ins are personal. When an agent passes to another owner, the new owner signs in again to the servers it uses.

The server's authorization server must accept Agentome's return address. If the sign-in stops at once with invalid_request, see MCP servers that sign in with OAuth.

Model connections

Agents on people's computers run under their owner's own Claude or ChatGPT subscription, and need no model connection. An agent that works on the server, by itself, needs one: an API key that the company pays for.

Admin, Models: two model connections with their address, the models each lists for Claude Code and Codex, and when they were checked.

Add a connection

  1. Go to Admin → Models and select New connection.
  2. Give it a name.
  3. Pick the kind:
    • Anthropic: Claude models, for Claude Code.
    • OpenAI: GPT models, for Codex.
    • Gateway: a gateway such as LiteLLM: Claude models for Claude Code, the rest for Codex. Fill in its address, such as https://litellm.acme.com.
  4. Paste the API key. Use a key made for agents, with a spending limit at the provider: it is what a leak could cost.
  5. Select Connect. Agentome lists the connection's models to check the key, and keeps the key encrypted.

The New model connection dialog: a name, the kind Gateway, the gateway's address and an API key.

The row's menu has Models, the models the connection offers by engine, Check now, Edit and Delete. Deleting a connection erases its key, and agents on its models cannot work on the server until they get another one.

Put an agent on the server

Needs a license key.

In the agent's Engine & model section:

  1. Under Where it works, pick By itself.
  2. Pick the Model connection and the Model.

The server needs a seat that runs the agents. An admin starts it once; see Agents on the server and Computers.

Sign-in with Keycloak

Needs a license key.

People can sign in with the company's Keycloak, beside their passwords. An admin creates a client for Agentome in the realm and sets three settings on the server; see Keycloak.

Once it is on:

Without a license key, people sign in with their passwords.

n8n

The community node n8n-nodes-agentome lets an n8n workflow give an agent a task when something happens elsewhere, wait for its result, decide what the agent asks to approve, and start when a run ends or an approval waits.

  1. In n8n, open Settings → Community nodes → Install, enter n8n-nodes-agentome and confirm.
  2. In Agentome, make a personal API token: open the menu under your name and choose API tokens. The nodes act as you; a Read only token can only read.
  3. In n8n, add an Agentome API credential with your server's address and the token.

The node's README lists its operations.

Edit this page on GitHub