Skip to content
tripula
Sign inJoin the waitlist

The remote ADE for developers coding with Claude Code and Codex

From request to a ready PR, without babysitting the agent.

The agent plans, implements and goes through Quality before anything reaches you, on a cloud machine that keeps working with your computer off. You step in only to decide, from wherever you are, even your phone, and review work that's already been checked.

  • Plan, Quality and PR on every task
  • Keeps working with your computer off
  • Zero per-token costs
  • Contains the blast radius of supply chain attacks and prompt injection
  • Desktop, tablet and phone
Join the waitlistLook inside the ADE ↓

Free closed beta for selected customers. Afterwards, from R$199/month per developer billed annually, machine included. You bring your own Claude or Codex account: we don't charge for tokens.

Real screen: a task ready for review, with the conversation, the commented diff and Quality.

Works with what your team already uses

  • Claude Code
  • Codex
  • GitHubintegrated
  • GitLabvia SSH
  • Bitbucketvia SSH
  • Docker & Compose
  • Postgres
  • MySQL
  • Redis
  • SQLite
  • VS Codevia SSH
  • Cursorvia SSH
  • Playwright
  • Linux with sudo
  • Phone & tablet
  • TypeScript
  • JavaScript
  • Node.js
  • Python
  • Go
  • Java
  • Kotlin
  • C
  • C++
  • C# & .NET
  • Rust
  • Ruby
  • PHP
  • Swift
  • Dart
  • Elixir

Three reasons to move your agents off your computer.

01 · From anywhere

Your agents don't stop when you turn off your computer.

Close the lid and they keep going. Approve and review from your phone, in the middle of a meeting or on the way home: the agent isn't left idle waiting for you to get back to your desk.

02 · The team in view

See how much more your team ships with AI.

You pay for AI for everyone, but you can't see the return. Here you see how much of the shipped work was done by agents, whether quality held up, and who needs help to get more out of them.

03 · Isolated risk

Malicious packages and prompt injection, far from your computer.

Agents install packages and read third-party pages, issues and files all day long. Any of them can carry malicious code or hidden instructions meant to trick the agent (prompt injection). Here, that happens inside an isolated VM: if something goes wrong, the damage stays on that machine, away from your computer, your passwords, your cloud credentials and the code of your other projects. And Quality flags known malicious packages before the PR.

The ADE

Much more than a terminal with Claude.

Everything you need to trust what the agent did, without switching tools.

  • Chat and terminal

    Claude or Codex, with a real terminal right beside it. Switch agents and models on the fly.

  • Changes

    The diff of what the agent did. Comment on any line and send all your feedback at once. Commit and push right there.

  • Quality

    Security, dependencies, errors, accessibility and page performance, only on what the agent introduced.

  • Preview

    Your app running on the machine, with zero setup. Share the link with your team.

  • Database

    Databases from your docker compose show up on their own. Query, edit and see what the agent wrote.

  • Many agents, one screen

    Every project and session on the machine in the sidebar. Each on its own branch, with its context in view.

Prefer your own editor? Open the same machine in VS Code or Cursor over SSH with a single command.

How it works

From request to merged on main.

Stage 1 of 5

You describe it. In plain language, the way you'd explain it to a teammate.

Pick the project and the mode: Quick for small tweaks, Standard with a plan, Careful with tests and review. And what the agent may do without asking.

Stage 2 of 5

The agent plans. You approve it before a single line is written.

The plan comes split into subtasks, with the files each one touches and a warning when two overlap. If the agent has a question, it asks with options.

Stage 3 of 5

Three subtasks. Three agents at once, each on its own branch.

You track progress, answer permission prompts and send messages that get queued. Your Claude usage is always in view.

Stage 4 of 5

Quality reviews it first. You only review what matters.

Security, dependencies, errors, accessibility and performance, only on what changed. Serious issues go straight back to the agent; you see before-and-after screens, comment on the diff line by line and send all your feedback at once.

Stage 5 of 5

One PR per subtask. Delivered when it lands on main.

The agent stays on call: if CI fails or someone leaves a comment, it fixes it and lets you know. The task is only done when the code reaches the delivery branch.

Just want to chat with the agent, no stages? Open a free session: everything is recorded, and it becomes a task whenever you want.

Use cases

Less waiting, less rework: where Tripula helps you ship more.

Claude Code and Codex write the code. Tripula handles the rest: the path to a checked PR, a machine that doesn't stop, a ready environment and the team's rules. Everyday situations, with the real flow.

  • 01 · Developer · day of meetings

    The task reaches a checked PR while you're in meetings.

    The situation
    You ask for a change before stand-up and spend the morning in meetings. In the terminal, the agent stops at the first question, and whatever comes out still needs you to check it line by line.
    In Tripula
    In New task, the agent drafts the plan and you approve it from your phone. It implements, and Quality checks security, dependencies, accessibility and tests on what it changed: anything serious goes back to the agent to fix before it reaches you. Decisions and open items are recorded on the task.
    What you get
    When you're back, a PR that already passed Quality, with the plan and decisions alongside. You review what matters, without the back-and-forth.

  • 02 · Developer or team · tech debt

    Tech debt cleared with your computer off.

    The situation
    Small issues and a pile of tech debt that never fit in the sprint, and an agent that stops when your computer goes to sleep.
    In Tripula
    At the end of the day, open the tasks in Quick mode and set what the agent may do without asking. Turn off your computer and the cloud machine keeps working, with Docker and the databases up: every task goes through Quality and the PR opens on its own. When idle, the machine hibernates.
    What you get
    When you're back, PRs ready for review, and only what needed you waiting in Needs you.

  • 03 · Developer · autonomous agent

    More autonomy for the agent, without the fear.

    The situation
    For the agent not to stop at every command, you have to let it act on its own. But it reads third-party issues, pages and packages, and any of them may try to trick it.
    In Tripula
    It works in an isolated VM, away from your computer. The projects' API keys stay in the panel: the machine only has a placeholder that's worthless anywhere else. With restricted internet, only the addresses on the list get through, so a tricked agent can't send your code out.
    What you get
    You let the agent work on its own and stop babysitting it.

  • 04 · Developer · urgent bug

    Fix a production bug without dropping the day's work.

    The situation
    An urgent bug lands in the middle of a big task, and it only shows up with the data that's in your database right now.
    In Tripula
    Fork the machine: in seconds it copies the code (even what isn't committed), the dependencies and the docker compose databases, data included. The agent investigates and changes whatever it needs in the fork, without touching your work.
    What you get
    The fix comes back in one commit, the fork gets deleted and your environment was never touched.

  • 05 · New developer on the team

    A new developer, without days of setup.

    The situation
    Setting up a project's environment takes days: versions, database, secrets and the conventions nobody wrote down.
    In Tripula
    The machine starts with the project cloned and the environment checked, with the secrets the organization registered for the project. And the agent starts out with the company's rules: CLAUDE.md, skills and agents.
    What you get
    The first task can ship on day one, the way the team works.

  • 06 · Tech lead

    One standard for every agent, and a number for how the team performs.

    The situation
    Every developer uses the agent their own way, and you can't tell whether AI is turning into deliveries or rework.
    In Tripula
    Publish the company's CLAUDE.md, skills and agents to every machine, piloting with one team first. Make the plan and Quality mandatory per project. In the panel, see how each person performs and suggestions on what to do next.
    What you get
    One standard for the whole team, and “performs like X devs”, measured by the size of what reached main.

Quality before you

By the time it reaches you, the basics are already checked.

  • Only what's new. It compares against the base branch: issues that already existed don't block delivery.
  • Serious issues go back on their own. The agent fixes them and runs the checks again before asking for your time.
  • Way beyond lint. Security flaws, malicious packages, accessibility, front-end performance, CI and database migrations, all in one list.
  • Team rules. The lead decides which projects require it and at what level it blocks.

What it checks

Ten areas, from a forgotten secret to on-screen accessibility. Each one only runs when the change touches something it covers, so a round takes minutes.

  • highmedium

    Code security

    Passwords and tokens left in the code, SQL injection, XSS, commands built from user input, overly permissive file paths.

  • highmedium

    Supply chain

    Dependencies with known vulnerabilities, malicious packages, suspicious new dependencies (brand new, a name close to a popular one, install scripts) and licenses outside your company's allowlist.

  • highlow

    Errors and types

    Code that doesn't compile, type errors and the lint rules the project already uses.

  • mediumlow

    Maintainable code

    Overly complex functions, duplicated code instead of reuse, code and dependencies nobody uses.

  • mediumlow

    Accessibility

    In the code and on the rendered page, on desktop and mobile: contrast, field labels, focus, alt text, keyboard navigation.

  • medium

    Front-end performance

    Lighthouse score and bundle size compared with the base branch. Plus before-and-after screens, so you can review without running the app.

  • highmedium

    Infra and CI

    GitHub Actions with injection or excessive permissions, Dockerfiles, scripts, Terraform and Kubernetes.

  • highmedium

    API and database

    Breaking changes for API consumers and migrations that lock tables in production.

  • medium

    Tests

    New lines with no test covering them, when the project measures coverage.

  • optional

    AI review

    Logic errors, edge cases and requirements that weren't met. Uses your own agent account and never blocks on its own.

Lint and type checks for
  • JavaScript
  • TypeScript
  • Python
  • Go
  • Ruby
  • PHP
  • Java
  • Kotlin
  • Swift
  • Dart
Security, dependencies and infra: any language.
  1. 01Runs on its ownTripula does the analysis, not the agent. The result is the same with Claude or Codex.
  2. 02Only what's newEverything runs on the base branch and on yours. Pre-existing issues are listed separately and don't block.
  3. 03High goes back to the agentIt fixes and reruns, up to 3 rounds. If that doesn't solve it, the task comes to you with the risk noted.
  4. 04The rest becomes open itemsMedium and low stay in the task's plan for you to decide, and clear themselves once someone fixes them.

Uses the rules the project already has (ESLint, Ruff, RuboCop, .gitleaks.toml…); without them, recommended defaults. The lead chooses what's required in each project, what blocks (high, or high and medium) and how many rounds the agent gets.

Plan records

Decisions don't get lost in the terminal scrollback.

With Claude Code in the terminal or in Remote Control, the approved plan, the decisions and whatever was left open disappear mid-conversation. In Tripula, every task keeps all of it in one place, easy to find later, for you and for whoever leads the team.

What you see in the task

  • Request and approved plan

    The request as you wrote it, the plan you approved and, for each subtask, what the agent did, in which files and in which PR.

  • Decisions, risks and open items

    The agent notes why it chose a path, what could go wrong and what was left for later. A filter shows only what's still open; when something is resolved, it records who resolved it and how.

  • Quality, round by round

    What each round found, what the agent fixed and what was already there. Anything that doesn't block but deserves attention becomes an open item on the task.

What leads see in the panel

  • Every task on the team

    Request, summary, stages, open items and risks, PRs and how many times Quality blocked. Search by title or by request.

  • Rules with history

    Who changed a rule, who asked to skip a stage and why, and who approved or declined it.

The panel gets what happened in the task, never the code. The full decisions and notes stay on the machine, with the task.

Any device

On your desktop, tablet or phone. The same machine.

Agent stopped and waiting on you? Your phone lets you know, and you grant permission, approve the plan or review the diff right there.

Desktop
Tablet
Phone

Security

Let the agent work on its own without putting your computer at stake.

No environment is immune to a malicious package or to an agent tricked by prompt injection. What you can control is how far they get: here, only as far as the machine the agent works on.

  • One VM per machine

    Its own kernel, not a shared container. A malicious package, prompt injection or a bad command only affects that machine, not your computer or the others.

  • Away from what's yours

    No browser passwords, personal SSH keys, AWS credentials, VPN or other clients' code within the agent's reach.

  • Keys that never leave

    Your git key stays in the panel: the machine asks for a signature on every push, but never holds the key. A malicious package can't walk off with your git access.

  • Internet under control

    Allow only the hosts the project needs: a tricked agent can't send data to just any site. And see what was blocked in the last hour.

For leaders

AI on your team, with numbers, rules and predictable cost.

Each role sees what it needs to make decisions. People who only follow along don't take a seat.

1 of 4

Know whether AI is turning into delivery.

  • Is the team shipping more?With AI, the team performs like how many devs, and how that compares with what it delivered before. Only what reached main counts, weighted by the size of the change.
  • How much comes from AIWhat share of the shipped work was done by agents, by team and by project.
  • Without losing qualityWhether AI is solving problems or creating new ones, and how many deliveries had to be reverted.
  • Where to investWhich teams and projects get the most out of agents, and what's holding the others back.

2 of 4

Help each person get more out of the agents.

  • Person by personWho already gets a lot out of the agents and who still needs help. Only the lead sees this.
  • What to do nextPractical suggestions, like teaching the agent something or switching models, and whether the change worked.
  • Approvals in one placeRequests for resources, to skip a stage and to join the team.
  • Team tasksWho's waiting on whom, what's up for review and what's already shipped.

3 of 4

The same rules for every agent.

  • Agent rulesCompany CLAUDE.md, skills and agents on every machine, with versioning, pilots and rollback.
  • Required stagesPlan, tests or Quality required per project, and who can skip them.
  • Autonomy under controlThe most an agent can do without asking, per project.
  • History and auditWho changed what, when and why.

4 of 4

Predictable cost, no token surprises.

  • One price per developerThe machine is included. The model is the subscription the developer already has.
  • Cap on extra spendSet a ceiling for anything beyond the allowance and see usage per person.
  • Fair seatsOnly developers pay. Seats of people who leave become credit; unused seats are flagged so you can free them.
  • With a tax invoiceCredit card: annual charged up front, monthly every month. A Brazilian service invoice (NFS-e) for your finance team.

Agents on your computer vs. agents on Tripula.

On each developer's computer

  • The agent runs on your computer, right next to your passwords, keys, VPN and cloud logins. One malicious dependency or one instruction hidden in a web page and it all goes with it.
  • Turn off the computer or lose the connection, and the agent stops.
  • Worktrees separate the code, not everything else: three agents, the dev servers and Docker fight over the same computer's memory. And you're the one splitting the work and stitching the PRs together.
  • Nobody knows how much of what lands on main came from AI, or whether it's any good.
  • The approved plan, the decisions and what was left open get lost in the terminal scrollback.
  • Every developer with their own rules and shortcuts.

On Tripula

  • The agent runs in an isolated VM. If something goes wrong, the damage stays on that machine.
  • Agents keep working; you follow along from any device.
  • The agent splits the request into subtasks and warns you when two touch the same file. They run in parallel, each with its own PR, on a machine sized for the job.
  • Metrics on what reached main, per person and per team, plus security, accessibility and quality checked before every PR.
  • Every task keeps the request, the approved plan, the decisions, the open items, Quality and the PRs. Leads see what's still open in the panel.
  • Company rules apply to every agent.

Pricing

One price per developer. The machine is included.

What you pay for here is the machine, the ADE and the pipeline all the way to delivery. The model runs on the subscription each developer already has.

Zero per-token costs

Agents run on the subscription your developers already have.

Claude Pro or Max, ChatGPT Plus or Pro with Codex. No API keys, no usage-based bills, no end-of-month surprises.

Tools that bill through the API

Every task costs tokens.

Parallel agents multiply the bill, and you only see the amount afterwards.

On Tripula

A flat price per developer.

Run as many tasks as you like within your Claude or Codex plan limits. The screen shows how much of the limit you've used.

Beta

Free during the beta, for selected customers.

The prices below apply after the beta. Billing only starts with notice in advance and your acceptance of a plan.

Solo

For developers working on their own.

Price after the beta

R$199/month

R$2,388 per year, paid up front by card

  • Allowance of 4 vCPU, 8 GB and 60 GB
  • The full ADE, tasks and free sessions
  • Agents in parallel
  • Desktop, tablet and phone
  • VS Code and Cursor over SSH
Join the waitlist

Team

For companies

3 to 10 developers. Everything in Solo, plus management.

Price after the beta

R$349/dev/month

R$4,188 per developer per year, paid up front by card

  • Allowance of 4 vCPU, 8 GB and 80 GB per developer, pooled across the team
  • Subtasks in parallel, one PR each
  • Quality before every PR
  • Rules for agents and tasks
  • AI usage metrics per person and per team
  • Managers and the billing role join for free
Join the waitlist

Enterprise

For more than 10 developers.

Contact us

Negotiated price, annual license per developer from 11 developers

  • In our cloud or yours
  • Everything in Team
  • Runs on your AWS or on a dedicated server
  • Outbound traffic only to allowed destinations
  • Company single sign-on (SSO)
  • Contractual support SLA
Talk to us

Build your machine

Your plan already includes an allowance. Go beyond it and you only pay the difference.

CPU
fits your plan (up to 4 vCPU)
4 vCPU
Memory
fits your plan (up to 8 GB)
8 GB
Disk
fits your plan (up to 60 GB)
60 GB

Beyond your plan

R$0

This machine fits within the Solo plan allowance.

R$25 per vCPU, R$15 per GB of memory and R$1.20 per GB of disk, per month.

On Team, the allowance is 4 vCPU, 8 GB of memory and 80 GB of disk per developer, pooled across the team.

  • Payment, after the beta: credit card, with a Brazilian tax invoice. Annual charged up front; monthly every month
  • 7-day money-back guarantee on every plan, after the beta

How you get started

  1. Connect your code. GitHub in one click, or any git over SSH.
  2. Create your machine. It boots with the project cloned and the environment checked.
  3. Sign in with your Claude. Or Codex. We use your subscription, at no extra cost.
  4. Ask for your first task. The diff shows up alongside while the agent works.

After the beta, R$349 per developer on the Team plan, billed annually. The machine, the ADE and the pipeline to delivery. The model runs on the subscription each developer already has.

FAQ

Questions before you start

The product

What is an ADE?

An agentic development environment: a development environment built for agents. Beyond the editor and terminal, it has what you need to follow and review what the agent does (a commentable diff, Quality, preview, database, plan and PR), all in one place.

What if I just want to chat with the agent, no stages?

Open a free session. You drive it like in the terminal, and it becomes a task whenever you want. Everything counts toward the metrics once it reaches main.

What does Quality check?

Secrets and security flaws in the code, vulnerable or malicious dependencies or ones with licenses outside your rules, errors and types, duplicated or dead code, accessibility and page performance, CI, infrastructure, API contracts, database migrations and new lines without tests. It uses the rules the project already has and only looks at what the task changed. AI review is optional and never blocks on its own.

Where do decisions and open items live?

In the task itself: the request, the approved plan, what each subtask did, the agent's notes (decisions, risks, open items, results and evidence), the Quality rounds and the PRs. Open items and risks also show up for leads in the team panel, with the request, the summary and the stages. Rule changes and requests to skip a stage go into the organization's history.

Can I keep using VS Code or Cursor?

Yes. One command sets up SSH, and your editor opens the machine as if it were local.

Does it work with GitLab or Bitbucket?

Yes, over SSH: clone, push, the ADE and the metrics work the same. The integration is GitHub-only for now; with GitLab or Bitbucket, you open the merge request in your git host and CI doesn't show up in the task.

Which languages and stacks work?

Anything that runs on Linux: the machine is a VM with sudo and Docker, so databases, queues and services start up just like on your computer. Anything that requires macOS, such as iOS builds, won't run on it.

Can I use Codex instead of Claude?

Yes, and both on the same machine. You pick the agent for each task, and the metrics compare the two.

What happens when I turn the machine off?

It hibernates. When you turn it back on, it comes back with the same processes, databases and terminals. Nothing is deleted.

Can I share my machine with a teammate?

You can invite them to your machine: they work alongside you, using your logins, without being able to copy your keys. If they need their own copy, with their own logins, copy the machine in about 20 seconds.

Security and data

Where does my code live?

On your machine's disk, in a VM of your own that only you and the people you invite can access. Only what happened goes out for metrics (stages, timings, Quality counts), never the code. On the Enterprise plan, if you prefer, everything stays on your AWS or on a company server.

Does Tripula use my code to train AI?

No. Tripula doesn't read or store your code outside the machine. What the agent sends to Claude or Codex is governed by the terms of your own account with them.

Is it safe to let the agent run commands on its own?

That's exactly why the machine is isolated: the agent runs in its own VM, with no access to your computer, your passwords, your VPN or your cloud credentials. Nothing removes the risk of a bad package, a wrong command or prompt injection, but here all they can reach is that machine. And if you restrict its internet access, data can't leave for just any server: the block comes from outside the machine, so not even sudo inside it can lift it. You choose what the agent does without asking, and the organization sets the limit.

Can it run on my company's servers?

Yes, on the Enterprise plan (more than 10 developers), which runs in our cloud or yours: in your AWS account or on a dedicated server. Updates arrive on their own, without disrupting anyone who's working.

Beta, plans and payment

How do I join the beta?

Join the waitlist on this page. The beta is closed: we invite customers in order of arrival and by team profile, and send the invite by email. If you already have an invite, use Sign in.

How much does it cost during the beta?

Nothing. During the beta, Tripula is free for selected customers, with no credit card. The prices on this page apply after the beta, and billing only starts with notice in advance and your acceptance of a plan. Agents still run on your own Claude or Codex subscription.

Are there per-token costs?

No. Agents run on the subscription each developer already has, Claude Pro or Max, or ChatGPT with Codex, not on a usage-billed API key. Tripula doesn't resell tokens or charge for the model: your cost is the per-developer price plus the subscription, the same every month. The usage limit is your Claude or Codex plan's, and Tripula shows how much has been used.

Who takes a seat?

Only people who code with a machine and an agent. Managers who follow the metrics and the billing role join for free.

How does the CPU, memory and disk allowance work?

Each developer brings an allowance, and on the Team plan it's pooled across the whole company: whoever needs more uses what someone else doesn't. Only what goes beyond the total is billed, up to a cap you set.

Is there a free trial?

During the beta, Tripula is free for selected customers. After the beta, every plan has a 7-day money-back guarantee: if it's not for you, we refund the full amount, no questions asked.

Do you issue invoices?

Yes. Payment is by credit card (annual charged up front, monthly every month), and every charge comes with a Brazilian service invoice (NFS-e).

What if I cancel?

Cancel from the panel, no need to talk to anyone. Everything keeps running until the end of the paid period; after that, the machines hibernate for 30 days so you can export whatever you want, and only then are they deleted.

Closed beta

Join the beta waitlist.

Tripula is in a free closed beta for selected customers. Leave your details: we invite people in order of arrival and by team profile.

  • Free during the beta
  • Invite only
  • No credit card

We only use your details to talk about the beta. See the Privacy policy.