Skip to content
| Docs

Changelog

The latest improvements to Avrea. Subscribe via RSS.

Smart monorepos, even faster CI

  • cache
  • performance

Nx is built to keep monorepo CI fast: it runs only the projects a change touches and reuses what it already computed for the rest. That reuse is only as quick as the cache behind it, so Avrea now hosts an Nx remote cache right next to your runners.

On Avrea runners there's nothing to wire up. Your tasks pick up the cache as-is:

- run: pnpm install --frozen-lockfile
- run: pnpm nx run-many -t build test lint

Because the cache is shared, a result computed once is reused everywhere: the next CI run, other branches, and teammates sitting on the same commit. The first run fills it; after that, the projects nobody changed are restored instead of rebuilt, so CI spends its time only on what's new.

Works with Nx 20.8 and newer. See the Nx caching docs →

Docker builds that reuse layers instead of rebuilding them

  • cache
  • docker
  • performance

Docker builds on Avrea runners can now pull their layers from a cache that lives right next to the runner, so unchanged steps come back in seconds instead of rebuilding from scratch.

Add url_v2=https://cache.avrea.com/ to your type=gha cache settings:

cache-from: type=gha,url_v2=https://cache.avrea.com/
cache-to: type=gha,url_v2=https://cache.avrea.com/,mode=max

On the first run, BuildKit builds and stores every layer. On the next run with unchanged inputs, each RUN step hits the cached layer and the build finishes in seconds — no more waiting on the slow upstream GitHub Actions cache.

Set up Docker build caching →

Your first cached build of the day starts faster

  • cache
  • performance

The first build to reach the cache used to pay a small cold-start cost while the index loaded. Now that index is pre-warmed across every scope ahead of time, so the first cached build of the day is as quick to start as the rest — no change needed on your end.

Invite teammates by email, and skip the setup they don't need

  • console
  • onboarding
  • notifications

Getting a teammate into Avrea no longer means sending them a link out of band and walking them through setup.

  • Invites arrive in their inbox. When an admin invites someone by email, they get an email notification with a direct link to join — no separate heads-up needed.
  • A shorter first run for invited members. If your org already has the GitHub App installed, invited members skip the install step and the onboarding wizard steps out of the way, so they land on a working console instead of a setup screen.

Runs that keep going when GitHub drops a webhook

  • reliability
  • runs

GitHub occasionally drops or delays the webhooks that tell us a job is ready. When that happened, a run could sit waiting. It no longer has to.

  • Stuck queues unstick themselves. When a webhook never arrives, Avrea reconciles queued jobs by polling the workflow run directly, so they start instead of hanging.
  • Dropped notifications get retried. Failed webhook deliveries are redelivered automatically, so a transient hiccup on either side no longer strands a run.
  • A job that can't start tells you, instead of waiting. If a job's container image can't be found, the run now stops and notifies you right away rather than sitting indefinitely.

Fewer runs that quietly go nowhere.

The fastest Apple Silicon yet, now running your builds

  • runners
  • performance
  • macos
  • arm

Apple M5 Max Macs are now part of the Avrea fleet — the fastest ARM CPUs available. If your build is CPU-bound, the wall-clock you've been waiting on just got shorter, with no changes to your workflow.

  • macOS builds, on the latest Apple Silicon. Xcode builds, test suites, and signing run on M5 Max hardware, so the heaviest macOS jobs finish sooner instead of holding up the rest of your pipeline.
  • Linux ARM, on the same fast cores. It isn't only for macOS. Your Linux ARM workloads run on this hardware too, so ARM container builds, cross-compiles, and ARM-native test runs get the same top-tier single-thread speed — without keeping a separate machine class around.

One fleet, the fastest ARM CPUs available, whichever OS your work needs.

More of your build cached out of the box — and SOC 2 Type 2

  • cache
  • runners
  • compliance
  • security

Two threads landed this week: the cache covers more of what your build actually downloads, and the platform underneath it picked up another attestation.

More of your build, cached out of the box. If your runner pulls it, we probably cache it now — with no workflow changes on your side.

  • .NET on Linux. Linux dotnet runners used to go straight to api.nuget.org. They now resolve through the Avrea NuGet cache, the way Windows already did — so cold restores stop being the slow part of the build.
  • Gradle, on every OS. repositories { mavenCentral() } was silently going direct, because Maven's mirror config doesn't govern Gradle's resolver. Gradle builds now flow through the Avrea cache via a surgical URL rewrite that leaves your other repositories — google(), gradlePluginPortal(), JitPack, corporate Maven, mavenLocal() — exactly as you wrote them.
  • Go build cache on Windows. Windows runners now get the same Go build cache as Linux and macOS, instead of a silent no-op. Repeat Go builds on Windows feel like Go builds anywhere else on Avrea.

SOC 2 Type 2, continuously verified. Avrea is now SOC 2 Type 2 attested, in addition to ISO 27001:2022 certified — both are listed on the security page. To keep the posture honest between audits, the hosts that run your builds are continuously scanned against the same hardening controls, with results streamed into our observability stack. So the attestation isn't a once-a-year snapshot; it's the steady state.

The console now talks back — and the log view keeps up

  • console
  • notifications
  • performance

The console now tells you about the things you used to find out by accident.

  • A notification center, in the product. A new bell in the top bar collects anything Avrea needs to surface to you — and the important ones (like running low on credits) appear as an acknowledge banner you have to dismiss, so you don't first hear about them from a failed run. Each notification has its own seen / acknowledged state per user, scoped to the right people in your org.
  • A log viewer that follows the work, not the other way around. Click any point on the job's metrics chart and the log scrolls straight to that moment — even if the line is inside a collapsed group or filtered out, you land near it instead of nowhere. Scroll back to the bottom of a live log and follow-tail re-engages on its own; an explicit Pause / Play control is back when you'd rather drive manually. Big logs render with noticeably less stutter.
  • A cleaner metrics chart. CPU, memory, and the other series toggles moved into a settings popover on the chart itself, so the chart area stays focused on the data. Line colours are retuned for the dark theme so the series stay readable when they overlap.

Small stuff — but the kind you notice every time you open a job.

Your console just got a lot faster — and shows more

  • console
  • performance
  • observability

The console feels noticeably snappier, and it finally answers the question you actually have: what did this job use?

Job lists and dashboards now load up to 22x faster, with workflow aggregations roughly 4x faster. If you have a repository with a long history of jobs, you'll stop waiting on spinners to see what's going on.

Every job and step now reports its average CPU and peak memory, and the workflow metrics chart adds step-level markers, multi-job tooltips, and an inline picker when several jobs overlap on a busy graph. Spotting the slow step — or the one that's about to run out of memory — is now a glance, not an investigation, which makes it easy to right-size the runner you pay for.

Fewer interruptions, more reliable runs

  • console
  • reliability
  • cache

A batch of changes whose whole point is that you notice them less.

  • Stay signed in while you work. Console sessions now extend on activity (up to 36 hours idle, with a 14-day cap) instead of logging you out mid-task.
  • A sidebar that fits your screen. The navigation auto-collapses on smaller screens, so the console stays usable on a laptop or a split window.
  • No more zombie runs. Cancelled GitHub runs no longer spin up doomed retry loops, and pending workflow webhooks no longer leave run status out of sync.
  • Caches you can trust. Package and GitHub Actions cache now verify end-to-end integrity with native checksums and compressed-frame checks, at near-zero overhead — including a fix for the Bundler / RubyGems checksum errors some Ruby projects were hitting.

Individually small; together, fewer surprises in your day.

Lock down runner network egress per repository

  • security
  • runners
  • compliance

You can now meet network compliance requirements without moving work off Avrea.

Define exactly what a repository's runners are allowed to reach — by CIDR, fully-qualified domain, protocol, and port. The policy is enforced on both the IP and DNS planes, so a workflow can only talk to the destinations you've explicitly allowed, and attempts to reach anything else are blocked rather than quietly succeeding.

For regulated and security-conscious teams, that means CI builds can run on Avrea while still satisfying the egress controls your auditors expect.

Move a workflow to Avrea runners in a few clicks

  • console
  • runners
  • onboarding

Trying Avrea on a real workflow no longer means hand-editing YAML.

From the console, pick an existing GitHub Actions workflow and convert it to run on Avrea runners. We generate a pull request for you to review and merge — so the change goes through your normal review process, and you can see exactly what's different before anything ships.

It turns "evaluate Avrea" from an afternoon of edits into a few clicks and a PR.

Drive Avrea from your terminal with the new avr CLI

  • cli
  • automation

Anything you do in the console, you can now do from your terminal — and from your own scripts.

The first public release of the avr CLI is here. It's designed to feel like GitHub's gh: structured --json output for piping into other tools, --watch modes so you can follow runs live, clickable hyperlinks, and pipe-friendly formatting that does the right thing whether you're at a prompt or in a pipeline.

That means you can wire Avrea into your existing automation without scraping the UI — kick off and monitor work, pull status into a dashboard, or gate a deploy on a result, all from the command line.