Agentic coding at Cubiq

November 1
6 min read

Most of the code we ship at Cubiq is now written by agents, and we review. Here is the stack we run them with: T3 Code, Paseo and the OpenCode web UI — plus honest lessons about why review is the real bottleneck.

In our previous post we mentioned, almost in passing, that at Cubiq we use OpenCode as our harness for synchronous coding assistance. That sentence deserves a post of its own, because the honest state of a bootstrapped software factory in 2026 is this: most of the code we ship is now written by agents. We specify, review, approve and merge. What changed is not only the tooling — it is the shape of the workday.

This post is about the stack we run agents with: T3 Code, Paseo and the OpenCode web UI.

What agentic coding means day to day

An agent is not autocomplete with good marketing. A coding agent takes a task in natural language, plans, reads the codebase, edits files, runs commands and tests, and comes back with a diff and a story. Your job moves to the edges of that loop: you write precise tasks, and you review diffs with polite suspicion.

A normal morning at Cubiq: open a thread per task, three to five in parallel, let them run while the coffee does its thing, then go through the diffs from the phone or the couch. When a diff looks right: commit, push, PR, merge. It sounds like the future, but it has quietly become unremarkable. The discipline moved to two places: writing the ticket and reviewing the result.

T3 Code: a control surface, not another assistant

T3 Code — built by T3 Tools, Theo Browne's shop (pingdotgg) — is what they call an "agent harness control surface": a desktop, web and mobile GUI that drives the coding agent CLIs you already use (Claude Code, Codex, OpenCode, Cursor, Grok Build and friends), with your existing logins. Your keys never pass through it.

What it puts on the table:

  • Parallel threads, each in its own git worktree and branch. Agents never collide, and merging is a normal review instead of a negotiation.
  • Per-turn checkpoints with revert. When an agent goes off the rails you don't argue with it; you turn back time.
  • Permission modes: Supervised, Auto-accept, Auto with an agent reviewer, or Full. You can live somewhere between the first and the third.
  • One-button commit → push → PR. The shipping part of the job became a rounding error.
  • Approvals from your phone. An agent stuck at a permission gate pings you wherever you are.
  • Switching agents mid-thread, carrying the conversation over. When a model gets stuck, you hand the case to a fresh detective.

T3 Code is free, MIT licensed, and sits at ~37k stars on GitHub. For a bootstrapped factory in Uruguay that is not a detail; that is the point.

Paseo: the workstation, not the cockpit

If T3 Code is the cockpit for a day of parallel work, Paseo is the whole workshop: "the agentic development environment", open source, Apache 2.0 and local-first. A daemon runs on your machine or dev server, and you get native desktop, web and CLI clients — plus a genuinely native mobile app.

It speaks to 39 agent providers out of the box. Workspaces come with status and CI badges. The core loop is Build → Review → Ship → Extend, with diff review and one-click "create a PR". Subagents are visible in-session, and you can fan out a batch of GitHub issues to separate worktree agents. That last one is our favorite trick of 2026: a sprint backlog burns down while lunch happens.

On the factory side, automation runs through MCP, a CLI and a TypeScript SDK, and Paseo Hub lets the team trigger agent runs from GitHub, Slack or Discord. When part of your production line is made of agents, the team needs a way to talk to them. This is that.

The OpenCode web UI: pair your phone

OpenCode, our main harness, is famous for its TUI. But the web UI is served by the same server that powers the TUI; it is there by default and password-protected. Run opencode pair and it prints a one-time connect link (it expires in 5 minutes) plus a QR code. Sessions last about 30 days, and the phone app pairs exactly the same way. If you need a standalone server, opencode serve runs a simple HTTP server with basic auth; for LAN access there is --hostname 0.0.0.0, an SSH tunnel, or OpenTunnel.

Our practical recipe: work starts on the dev machine, and supervision continues on the phone or browser over Tailscale. An agent is untangling that fiddly form validation while I'm on a call; the approval lands with a pocket tap.

Tailscale: our private road to the agents

One more piece keeps this setup safe and, frankly, boring: Tailscale — we already wrote a separate post about why we run it. All our machines — laptops, the dev server, our phones — form one private network. Nothing about our agents is exposed to the public internet: there are no open ports to scan, and keys never leave the machines that spawned the agents.

That unlocks the good part: the Paseo daemon and the OpenCode web UI are reachable over that private network from any of our machines, including the phone. The same session you started at your desk follows you out: review a diff, approve a permission gate, ship the PR from wherever you are. Traffic travels inside the network, the code stays where it lives, and the review happens wherever we happen to be.

How we combine them, and what we learned

The assembly looks like this: OpenCode as the engine, Paseo when the work spans days or a pile of issues or needs to be visible to the whole team, T3 Code as the polished third option that drives every agent CLI from one GUI, and the OpenCode web UI (or Paseo's mobile clients) as the remote control.

Now the honest part — what we learned the hard way:

  • Review is the bottleneck, not generation. Code became abundant and cheap; attention did not. Only parallelize work that is well-specified and low on cognitive load — every agent you fan out also schedules review time for you.
  • A well-specified task is the product. A ticket written for a smart but brand-new contractor comes back as a clean diff. A vague one comes back as a beautiful demonstration of the failure modes.
  • Send out a scout. Cheap, disposable probing tasks by subagents that map the terrain before you spend expensive context on the real work.
  • Delegate the planning to a subagent and keep the main thread's context clean for reviewing and deciding.
  • Worktree isolation is not a feature, it is the natural shape of the job. Every serious tool converged on the same trio: worktrees, phone approvals, generated PRs. Three different teams arrived at the same place, which tells you something.
  • Open source is the quiet superpower. Everything above is MIT or Apache 2.0. A factory in Uruguay runs the same agent stack as any Big Tech company, at zero license cost. You pay for tokens, not seats.

One last disclosure, in the spirit of the topic: this article was produced exactly the way it describes. One agent did the web research, another agent wrote the first draft, and a third translated and adapted it for our Spanish and Portuguese readers — all supervised from the OpenCode setup described above, with a human reviewing every paragraph and pressing the merge button.

We read it with the same polite suspicion we give any diff — then we merged it.

The agents are already writing the factory. We just review, approve and press buttons — and honestly, we've had worse jobs.

cross

STILL HAVE QUESTIONS?

Tell us about your challenges — at Cubiq, we love overcoming them. We can help with everything from technical best practices to plans and pricing.

cross