GitHub Copilot’s CLI Goes Remote — Why April 13’s Preview Matters for .NET & Azure Engineers

TL;DR: On April 13, 2026, GitHub shipped remote-controlled Copilot CLI sessions in public preview. You can now monitor and steer a running copilot session from the GitHub web UI or mobile apps. For teams shipping .NET on Azure, this quietly changes how you debug pipelines, pair with agents, and think about security boundaries—without rewriting your tooling. (github.blog)

What actually shipped (and what didn’t)

GitHub’s update introduces copilot --remote, which streams a live CLI session to GitHub in real time. From the web or mobile, you can observe output and interactively guide the session while it runs. This is a preview feature and builds on the existing Copilot CLI—no new shell, no new IDE. (github.blog)

Key characteristics engineers should note:

Live streaming of terminal activity to GitHub (near real time).
Remote steering, not just read-only logs.
Works with existing Copilot CLI flows, including agentic tasks.
Public preview as of April 13, 2026 (expect changes).

What it does not do (yet):

It’s not a general-purpose SSH replacement.
It doesn’t magically grant elevated permissions—you’re still bound by the host’s auth and OS policies.

Why this matters for .NET + Azure workflows

If you’ve ever tried to reproduce an Azure deployment failure that only happens in a headless runner, this is the most interesting part. A Copilot-driven CLI session running your az, dotnet, or Bicep commands can now be observed and nudged remotely.

That’s especially useful for:

Long-running dotnet publish or dotnet test tasks.
Terraform/Bicep deployments that fail mid-flight.
Agentic “fix-forward” scripts that need human judgment.

2) Agent supervision becomes practical

GitHub has been pushing autonomous and semi-autonomous agents hard this spring. The remote CLI closes a supervision gap: you can let an agent run, but still step in from your phone if it’s about to rm -rf the wrong directory (we’ve all been there). (github.blog)

GitHub Copilot’s CLI Goes Remote — Why April 13’s Preview Matters for .NET & ...

3) Better alignment with Azure’s security model

Because the CLI still runs where you launched it, your Azure auth story doesn’t change:

Managed Identity stays managed.
az login semantics are unchanged.
Network isolation (VNETs, private endpoints) still applies.

In other words, GitHub didn’t punch a hole through your Azure perimeter—it gave you a remote steering wheel, not remote root.

Cost, latency, and quotas (the unsexy but important bits)

Cost: There’s no separate SKU for “remote CLI.” Usage rolls into your existing Copilot usage metrics; GitHub recently unified CLI activity into the main metrics pipeline, so expect this to show up in org-level reports. (github.blog)
Latency: Streaming is designed for interaction, not pixel-perfect mirroring. For most command output, latency is acceptable; don’t expect buttery-smooth TUI gaming.
Quotas: Prompts and agent actions still count toward Copilot quotas, just like local CLI usage. (github.blog)

How to try it (high level)

# Run your Copilot-powered task with remote support
copilot --remote

From there:

Start the task locally (or on a runner/VM).
Open GitHub (web or mobile).
Attach to the running session and steer as needed.

Because this is preview, exact flags and UI affordances may evolve—expect some churn.

Practical guidance before enabling this for a team

Set expectations: This is supervision, not autopilot. Someone is still accountable.
Audit permissions: Treat remote CLI sessions like any other privileged shell.
Start with non-prod: Especially for Azure subscription–wide operations.
Document escape hatches: “How to stop the agent” should be obvious.

The bigger picture

This preview fits a clear pattern: GitHub is turning Copilot from a suggestion engine into an operational collaborator. For .NET and Azure engineers, the value isn’t novelty—it’s reducing the friction between automation and oversight.

If you’ve been waiting for agentic tooling that doesn’t require blind trust, this is a meaningful step.