Skip to content
Trama

Launching · core for Linux and macOS

Your agents talk to each other.You stop being the wire.

AI agents working your clients' boards and repositories, on a machine you own. A card only moves on when the client's build passes — the agent's word moves nothing.

R$ 99.90 per core, per month · one plan · you bring your own Claude Code

Linux or macOS, x86_64 or arm64 · Claude Code on the core's machine

The web panel is open to subscribers. Buy →

Illustration · test data See the real screens ↓
Trama build-sp-01

Operate

Board

Girassol shop · read just now · deciding spends no tokens

Ready for the agent

In progress

In review

Done

GIR-45Show the stock
GIR-38Faster listing
GIR-35Validate postcode
GIR-41Fix the shipping cost on checkout task running MR !87 · pipeline build green moved by the build
  1. Turn
  2. Commit
  3. Build of the commit
  4. Verdict
  5. Card on the board

Not a screenshot: one card's path, drawn with the panel's test data.

Works with

  • Jira Cloud
  • GitHub
  • GitLab
  • Linear
  • Claude Code
  • Codexcoming soon
  • Gemini CLIcoming soon

Codex and Gemini CLI are in the code and not cleared yet.

For teams serving many clients

Built for peoplewho deliver to clients.

Agencies, software houses, teams that run other companies' systems: each client's board becomes the queue, and a delivery only counts when their CI says it passed.

  1. 01
    One core, every client.

    Each project with its own board, repositories and credential — on a machine you own.

  2. 02
    The build decides, not the agent.

    A card only moves on when the client's CI goes green on the commit delivered.

  3. 03
    You approve, signed.

    A decision goes through whoever holds the key on their device, and stays in the audit trail outside your machine.

Right now, the wire is you

Without Trama

  • You read the card in the tracker and paste the context into an agent session.
  • The agent says it's done. You open the pipeline to find out whether that's true.
  • Back to the board, move the card, comment — and repeat for the next client.
  • Close the laptop and everything stops.

With Trama

  • Someone puts the card in the entry column, and the core picks it up from there.
  • The agent works in a copy of the repository and opens the merge request.
  • The client's build checks the delivered commit; only then does the card move.
  • The core runs on a server or a machine that stays on — your laptop can close.

Three pieces, one account

The core works where the repositories and credentials are. The panel is how you see and steer it — from anywhere, without the core opening a single port.

a machine you own core dials out platform you panel · app board repositories client's CI no open port you panel · app platform dials out no open port core a machine you own board repositories client's CI
The core dials out to the platform. Nothing reaches it from outside: no SSH tunnel, no fixed IP, no firewall rule to ask the client for.

The core

tramad, on a machine you own

A server, a VM, a Mac on the desk. It reads the board, works in the repositories, keeps the history and the credentials. One core serves many clients and projects, each project with its own board and repositories.

The platform

the web panel, hosted by us

Account, organisation, invitations and roles; the Topology; the audit trail. It is how you reach your cores from anywhere.

The desktop app

the panel, as an application

Topology, Board, Deliveries and Inbox on your computer, signing in with the same account. No installer yet.

Trama's Topology in the panel: at the top, the Approvers with a key enrolled; below, the Platform; and two cores joined to it by dashed teal cables, a task running. Under each core, its projects side by side, grouped by client and joined in amber: the Girassol shop and orders, for Café Girassol, and a Claude Code agent on one; on the other, the Três Pontes portal, for that client, and the Vento Sul site, with no client. On the left, the cable legend.

Who can approve, the platform and each core, joined by cables whose colour is the state of the link — and every cable also says why, in words.

From card to green build

The client's board is the queue. The core doesn't invent work: it takes what a person put in the right place, and only calls done what the client's build confirmed.

  1. 1
    A person puts the card in the entry columnThat's the gate, when the project sets one. The core only works what someone moved there; when it takes the card it moves it to the in-progress column, and working it again takes someone putting it back.
  2. 2
    The agent works in a copy of the repositoryEach project with its own working copy, under a directory you choose. The agent's prompt, model and subagent policy go into a signed configuration, and a prompt written as text is checked against it before every task.
  3. 3
    The delivery opens the merge requestOn the client's GitLab or GitHub, with the commit that was actually delivered.
  4. 4
    The client's build decidesThe card only moves to the column you chose when the build went green on that exact commit. Red, and it doesn't move — and the screen says why.

The build is the one on the delivered commit. The agent's word closes nothing.

Deliveries

The delivery, from commit to card

Every agent turn becomes a row: turn → commit → build of that commit → verdict → card on the board. What didn't get there shows as not reached, with the reason — and what nobody recorded is said that way, instead of looking like success.

  • If the commit a reviewer opens is not the one the build read, the screen says so.
  • Each turn's cost alongside. What isn't known shows as not known, not as zero.
  • The merge request is one click away, on the client's GitLab or GitHub.
The Deliveries screen: each row joins the turn, the commit, the build of that commit, the verdict and the card on the board. The first two reached the end and moved the card from In review to Done; the third stopped at a red build, and the card did not move.

Board

The board through the core's eyes

Cards from Jira, GitHub, GitLab or Linear, read page by page, up to a thousand a read — and if there are more, the read says it stopped there. The screen says how many become a turn, how many were left out and how many run at once. Deciding spends no tokens.

  • On Jira and Linear, only the active sprint or cycle; on any tracker, only the column that admits work.
  • One credential per site: two Jiras, a self-hosted GitLab, each with its own.
  • One ceiling on simultaneous tasks holds for the whole core, across every project.
The Board in the panel: a shop's cards in four columns — to do, in progress, in review and done — and above them how many were read, how many will become a task, how many were left out and how many tasks run at once.

Inbox

What needs a person, in one place

Agents' questions and approvals arrive here. An action that can't be undone says so before the button, and the approval is signed with your device's decision key.

  • Before signing, you can see exactly what will be signed.
  • Declining takes a reason, if you want to give one.
  • Alerts — a core that stopped answering, a turn running too long — land here, with the time since when.
The Inbox with two items waiting on you: an agent's question about which postcode format the field should accept, with the options and an answer button; and an approval to move a card from In progress to In review, with what will be signed in view. Below, an alert about a task running for over an hour.

Agents

Provider and model, agent by agent

Each agent has its own prompt, model and subagent policy, signed with it — and, when the prompt is text, the core only runs a task with the text that was signed.

  • Today the provider is Anthropic, through Claude Code. OpenAI (Codex) and Google (Gemini CLI) are in the code and not cleared yet.
  • The prompt can come from a file in the repository, read from the default branch.
  • Subagents by kind, each kind with its own model.
A reviewer agent's form: the prompt text, the repository file it can be copied from, the provider Anthropic (Claude Code), the model and the subagent policy.

And more

One core, many clients

Each project has its own id, its own credential per site and its own working copy. A client's schedule is set once for all of its projects.

Organisation and roles

Owner, admin, member, and a member who only reaches the clients they were given. The team joins by invitation.

Signed approvals

Decisions are signed with your device's key. The private key never leaves it; the platform keeps only the public one.

An audit trail outside your machine

Who did what, when, and with what result — with a hash of the parameters, never the parameters.

Loops that pause

A loop stops and resumes where it was, on the same branch, with what it had already spent and done. An iteration already running finishes first.

An installer that checks

The core and its installer ship signed, and the installer refuses a binary whose signature doesn't verify.

Where your data lives

On the core, on your machine

  • Cards, tasks, deliveries, conversations and the history, in SQLite.
  • The repositories' working copies.
  • The Jira, GitHub, GitLab and Linear credentials, the licence and the deciders' public keys.

On the platform, with us

  • The account: organisation, members, invitations, roles, sessions and billing.
  • The register of each core: identity, version, when it was last seen and the machine's state.
  • Projects and clients, budgets, alerts, the audit trail and daily usage totals.

A credential the platform can't open

You type the tracker or repository credential in the browser, it is sealed to the core's key and crosses the platform closed. The core is what opens it.

Passes through, doesn't stay

What you open in the panel crosses the platform on its way to your screen. Code, diffs, prompts and conversations are not stored on our side.

No telemetry in the product

The core and the app send no usage metrics and no crash reports. The core sends the platform the machine's state — CPU, memory, load — and usage totals, which is what your panel shows. Claude Code, which is the provider's, follows its own telemetry settings. This site counts page visits on its own domain, with no cookie and no profile; the email you leave here goes on a notification list, not into the product.

AI, straight with the provider

Claude Code runs on the core's machine, with the client's own account. We don't resell tokens.

One price

One plan, no table to compare. You bring the agent — the Claude Code you already pay for — and pay us for the rest: the core working the board, the CI gate and the audit trail.

Trama

R$ 99.90

per core, per month

  • Bring your own agent: Claude Code runs on the core's machine, on your subscription.
  • Everything on this page, no reduced edition.
  • 3 tasks at once, on each core
  • No cap on people or projects
Buy

Full refund within 7 days (section 6 of the Terms of Use).

Already a customer? Sign in

To subscribe again or add cores, use Plan and payment in the panel.

You pay your provider for the model, and you pay us for the gate between “the agent says it's done” and “the card is closed”. We don't resell AI, and our bill doesn't move when your provider's does.

Billed monthly, in Brazilian reais, by card or bank slip (boleto). No free trial and no launch discount: R$ 99.90 from day one.

Within 7 days of the first payment we refund everything and access ends. After that there is no pro-rata refund, and a cancellation takes effect at the end of the period you paid for.

Trama news, only when there is any.

Leave your email and we'll write when a new version of the core or the panel ships, and when the desktop app gets an installer.

We'll write when a new version ships. We keep only the address, with no name; the site uses no tracking cookies and counts visits without identifying you. Every notice carries a link to leave the list.

Install

The core installs with one command, on a machine you own. The panel and the app reach it through your account.

  • CoreLinux and macOS · x86_64 and arm64
  • Web panelapp.trama.sh, for subscribers
  • Desktop appno installer yet

In a terminal on the core's machine:

curl -fsSL https://downloads.trama.sh/bootstrap.sh | sh

Installs tramad in ~/.local/bin and registers it as a user service — systemd on Linux, launchd on macOS. The installer prints the public key it checks the binary with; compare it with this one:

RWREfC2rSmkcE0abUx3caQU/v9Gn0bbMvZ9cbnuvIalBeq+ThhqNjV1i
  • Claude Code installed and signed in on the core's machine — it runs every task, with the client's own account.
  • minisign, and curl or wget.
  • On Linux, bubblewrap and systemd. Keeping the service running with no session open (loginctl enable-linger) takes an administrator.

Check a binary by hand

The installer already does this and refuses anything that doesn't verify. To do it without it — on an Apple Silicon Mac, for example:

curl -fsSLO https://downloads.trama.sh/tramad-latest-aarch64-apple-darwincurl -fsSLO https://downloads.trama.sh/tramad-latest-aarch64-apple-darwin.minisigminisign -Vm tramad-latest-aarch64-apple-darwin -P RWREfC2rSmkcE0abUx3caQU/v9Gn0bbMvZ9cbnuvIalBeq+ThhqNjV1i

On other systems, swap the end of the name for your machine's:

  • x86_64-unknown-linux-gnu
  • aarch64-unknown-linux-gnu
  • x86_64-apple-darwin
  • aarch64-apple-darwin

A good signature answers "Signature and comment signature verified" and, on the next line, the name of the file that was signed, with its version. Any other answer means stop and tell us. A signature from another key is refused by its ID; this one's is 131C694AAB2D7C44.

On its own, the core has no screen: your account on the platform is how you see and steer it. Trama doesn't replace Claude Code — it organises the work Claude Code does, and the AI bill keeps going straight to the provider.

The full reference: options, uninstalling and what's in 0.5.0

Questions before you install

What if the platform goes down?

The core carries on: tasks in flight keep running, and schedules keep firing the board cycle, which picks cards from the entry column. It reconnects on its own, backing off up to a minute, and never gives up. What waits for the platform to return are new decisions — approving, starting a task — because the panel and the app reach the core through it.

Do I need an open port, a fixed IP or a domain?

No. The core only makes outbound connections: to the platform, to the client's tracker and Git host APIs, to git over HTTPS, and to downloads.trama.sh. Claude Code talks to the AI provider on the client's own account, and to whatever its tools reach.

Which trackers, Git hosts and agents work?

Trackers: Jira Cloud, GitHub Issues, GitLab Issues and Linear. Git hosts: GitLab and GitHub; self-hosted ones are in the code and not yet rehearsed with a real account. Agent: Claude Code. Tested end to end with a real account, from card to merge request: Jira Cloud with GitLab. GitHub Issues with GitHub ran the cycle before the delivery opened the pull request on its own. The other pairs are in the code and have not been through that rehearsal yet. Codex and Gemini CLI are in the code and not cleared.

Does Trama merge on its own?

No. The delivery opens the merge request on the client's GitLab or GitHub, and people merge it there. The core does not merge, close or comment on merge requests.

Who can approve?

Only someone with a device enrolled as a decider on the core's machine (tramad decider enrol). Every decision is signed, and is good once and for five minutes. In the panel, owners and admins decide and members don't — but the core has the last word, and it checks the signature.

What can the agent touch on the machine?

It runs as the same user as the core. For every task, the core writes Claude Code permission rules that deny its reading tools the credentials, the database and the backups. It is not operating-system isolation: run the core under a user, or on a machine, of its own.

Does it work without the platform?

The core runs on its own from the command line — the board cycle, credentials, the service, backups — but with no screen, and configuring a project means editing cycle.json by hand. Seeing the work and deciding from the panel takes an account on the platform.

What about Windows?

Not yet. The core is published for Linux (x86_64 and arm64) and macOS (Apple Silicon and Intel). On an Intel Mac the binary exists, but the install has not been proven.

Where is the platform hosted?

On Hallen Tech's own servers, in São Paulo (SP), Brazil: the platform's data stays in Brazil.

What about data protection (LGPD)?

The platform stores no code, prompts, conversations or the credentials your cores use — see Where your data lives. In Settings → Profile you export your data as a JSON file and ask for your account to be deleted. Once you ask, access ends at once, on every device, and what identifies you is erased thirty days later by a daily pass. The sole owner of an organisation with other members can't ask until they hand over ownership. The privacy policy and the data processing addendum are published, as a preliminary version under review, in the footer.

How do I uninstall?

tramad service uninstall stops and removes the service. The binary in ~/.local/bin, the data (database, credentials, licence) and the working copies stay on disk for you to delete when you choose. The steps are on the install page.

Stop being the wire between the board and your agents.

How to install
Ambiente de staging — não é o site publicado 6d2d01c6