GitHub Copilot Review (August 2026): Agent Plugins 1.0, Grok 4.6, and Whether Slack Changes the Verdict

GitHub Copilot spent nine days in August shipping the kind of update that moves a buying question, not just a changelog line. Between the 12th and the 21st it made Agent Plugins 1.0 generally available, dropped three models into the picker, and put a working agent inside Slack and Teams (GitHub changelog, pulled 2026-08-24). Our July 8 review rated Copilot 4.4 and predated all of it. The re-call: 4.5 out of 5.

Here is the one thing to leave with, because it is the single change that alters a decision rather than a feature list. Before August 12, a Copilot plugin was locked to the client it was built for, the standing reason a VS Code team already on Cursor treated Copilot Business as a second, redundant seat. Agent Plugins 1.0 fixes that: an open standard, co-published with AWS, Anysphere (Cursor's maker), Microsoft, OpenAI, and Vercel, that packages agent skills and MCP servers into one installable plugin (GitHub changelog, Aug 12). One plugin.json now runs across compatible clients. The rest of the August wave (three models, Slack, Teams) is breadth on top of that, and the price did not move.

What shipped in August

Five updates landed, each dated and with its plan gate. Note the release status on each, because three of the five are still rolling out or in preview.

• Agent Plugins 1.0 went GA (Aug 12). A plugin bundles a skill with an MCP server (say, a deployment runbook plus its tool integration) into one portable package. Support is generally available in VS Code, Copilot CLI, the GitHub Copilot SDK, and the Copilot app, on all Copilot plans (GitHub changelog, Aug 12). Existing plugins that do not target the spec keep working with no migration.
• Kimi K3 is rolling out (Aug 13). Moonshot AI's model reached the picker on Pro, Pro+, Max, Business, and Enterprise (GitHub changelog, Aug 13). It is the cheap-routine slot the July review filled with Kimi K2.7.
• MAI-Code-1.1-Flash is rolling out (Aug 13). Microsoft's lightweight coding model landed with native image understanding, so a screenshot or diagram goes straight into a prompt without a separate vision step (GitHub changelog, Aug 13).
• Grok 4.6 is rolling out (Aug 14). xAI's reasoning model is aimed at agentic coding and longer-horizon, multi-step work, on the Pro, Pro+, Max, Business, and Enterprise SKUs; GitHub calls the rollout gradual (GitHub changelog, Aug 14). It is billed at provider list pricing under usage-based billing.
• Copilot reached Slack and Teams (Aug 21, public preview). Mention @GitHub in a channel or thread to start a cloud agent session. Slack is gated to Copilot Business and Enterprise; Teams is available on any paid Copilot plan (Slack changelog, Teams changelog, both Aug 21).

Rounding out the week, the CLI picked up the changes day-to-day agent users will feel. You can manage parallel subagents in /tasks, queue prompts and commands while a turn runs, restore agent changes with /rewind without touching git, and in headless mode have the agent draft a plan and then implement it (GitHub changelog, Aug 13).

# Headless CLI: plan first, then implement, in one non-interactive run.
# Source: GitHub Copilot CLI changelog, 2026-08-13.
copilot -p "add rate limiting to the /api/search route" --plan --mode autopilot

# Undo the agent's last set of edits without a git reset:
#   /rewind        (inside an interactive session)
# Inspect and steer parallel background agents:
#   /tasks

The model picker: which one to default for your team

August turned the picker into a real routing decision. A single paid plan now reaches Grok 4.6, Kimi K3, and MAI-Code-1.1-Flash alongside the frontier Claude and GPT models Copilot already carried (models and pricing, pulled 2026-08-24). The real question a team lead is asking is "which do I set as the org default, and when do I switch." The answer, by task rather than benchmark:

Task type	Reach for	Why
Everyday chat and routine boilerplate	Kimi K3	Cheapest slot in the picker, rolled to every paid plan; burn credits here, not on a frontier model (changelog, Aug 13)
Long agent runs, multi-step refactors	Grok 4.6	Built for longer-horizon reasoning and sustained tool use in the terminal (changelog, Aug 14)
Screenshot, diagram, or PDF to code	MAI-Code-1.1-Flash	Native image understanding, so visual input skips a separate vision pass (changelog, Aug 13)
Hard architectural calls	A frontier Claude (Opus tier)	Top powerful tier, $25 per 1M output tokens; save it for the genuinely hard problems (pricing docs)
Balanced org default	Claude Fable 5	GA, "powerful" tier at a mid rate; a sane single default when you do not want per-task routing (pricing docs)

One honest note on redundancy: if your team already defaults to a frontier Claude, MAI-Code-1.1-Flash is worth switching to only for image-heavy tasks. For pure text coding it is a lateral move, so do not re-point the whole team at it. The pick most teams want is Claude Fable 5 as the standing default, Kimi K3 wired to routine work, and Grok 4.6 in reserve for the long agent sessions where sustained reasoning earns its higher meter draw.

The reason routing matters is the credit budget. Every paid plan includes a monthly allowance at 1 credit = $0.01, and agent work meters against it (Copilot plans, pulled 2026-08-24). Route routine turns to the cheap model and the fixed budget stretches.

Example: routing on Copilot Pro ($15/mo in credits, 1 credit = $0.01)
The lever is the ratio, not the exact figure:
  All agent turns on a frontier model  ->  the $15 pool empties fast
  Routine turns on Kimi K3, hard turns on a frontier model
                                       ->  the same pool lasts noticeably longer
Real cost depends on input + cached + output tokens per call; check current
per-model rates on GitHub's models-and-pricing docs before planning a month.

Agent Plugins 1.0: the lock-in objection just got weaker

The July review named the standing knock on Copilot Business for a team already paying for Cursor: two seats, overlapping capability, and plugins that did not travel between them. Agent Plugins 1.0 is the answer, and it is GA, not a preview toggle.

The spec was published August 6 by GitHub with AWS, Anysphere, Microsoft, OpenAI, and Vercel; Google joined as a core maintainer the same day (GitHub changelog, Aug 12). That co-maintainer list matters more than the feature. Anysphere makes Cursor. When Cursor's own vendor helps govern the plugin format, a plugin your platform team writes once is meant to load in Cursor's client and Copilot's alike.

Adopting the spec is mostly manifest work. You add a $schema field to plugin.json, keep skills under skills/, put MCP configuration in mcp.json, and move any Copilot-specific files into a namespaced directory that other clients ignore.

{
  "$schema": "https://agent-plugins.org/schema/1.0/plugin.json",
  "name": "deploy-runbook",
  "version": "1.0.0",
  "skills": "./skills/",
  "mcp": "./mcp.json"
}

deploy-runbook/
  plugin.json          # the spec manifest above
  skills/              # portable agent skills (loaded by any compatible client)
  mcp.json             # MCP server configuration (portable)
  com.github.copilot/  # Copilot-only: custom agents, commands, rules, hooks
                       # other clients ignore this directory

Governance rides on the settings you already run. Plugins are controlled through existing Copilot policies rather than a new admin surface, so an org that already gates models and features gates plugins the same way (GitHub changelog, Aug 12).

So does one seat replace the other? Not quite, and the answer splits by plan. If your team runs Cursor for its editor and Copilot Business for GitHub-native PR review and org billing, the portable plugin removes the duplication tax on internal tooling but not the reason each seat exists. You keep Cursor for the multi-file editing edge and Copilot for the GitHub control plane; what you stop doing is maintaining two copies of every internal plugin. On Enterprise the calculus tips further toward consolidation, because the governance surface Copilot already enforces now also covers the plugins your engineers pull from the Awesome Copilot marketplace. For a small Cursor-first team with no compliance mandate, this does not manufacture a reason to add Copilot; it just makes adding it cheaper to maintain if you do.

Copilot in Slack and Teams: who this is actually for

Both integrations shipped August 21, both are public preview, and they are not the same product with two logos. Read the plan gate before you plan around either.

In Slack, mention @GitHub in a direct message, channel, or thread to start an agent session. It can answer questions about your code and GitHub activity, triage bug reports and create or label issues, investigate failures and implement changes in a secure cloud sandbox, and open a pull request linked back to the conversation (Slack changelog, Aug 21). The gate is the catch: the preview is open only to organizations on Copilot Business and Enterprise. Pro and Pro+ seats are out.

# Slack, in a channel or thread (public preview, Business/Enterprise only):
@GitHub why is the nightly build failing on main?
@GitHub triage this stack trace and open an issue with a repro
@GitHub implement the fix in a sandbox and open a PR linked here

Teams is the broader gate. Shared agentic work means anyone in the conversation can ask questions, add context, and help steer the same session; participants with write access to the repo can trigger changes (Teams changelog, Aug 21). The preview is open on any paid Copilot plan, not just Business and Enterprise, and cloud agent runs consume AI credits under usage-based billing budgets, with cloud sandbox usage billed separately.

# Teams, mid-standup (public preview, any paid Copilot plan):
@GitHub help
@GitHub investigate the checkout 500s while we discuss the rollback

Does this reduce the need for Cursor or Claude Code? For most teams it is additive. The Slack and Teams agents win at the handoff, turning a decision made in chat into a triaged issue or a draft PR without a switch to the editor. They do not do your close-quarters, multi-file editing; that still happens in Cursor or the Copilot editor. The real audience is a team that lives in Slack or Teams and keeps losing the thread between "we decided this in the meeting" and "someone opened the issue." One guardrail for admins: a repo owner can require an extra approval on any PR attributed to the Copilot app identity before it merges, keeping a human in the loop on agent-authored work (Slack changelog, Aug 21).

Pricing, still flat

Nothing on the sticker changed since July, which is worth stating plainly because the value went up at the same price.

Plan	Price/mo	Monthly credits	August note
Free	$0	50 chat requests	No premium picker
Pro	$10	$15 in credits	Kimi K3, Grok 4.6, MAI-Code in the picker
Pro+	$39	$70 in credits	All Pro models plus premium; Teams preview
Max	$100	$200 in credits	Same picker at 2.9x the budget
Business	$19/user	Pooled	Slack + Teams previews; pooled credit control
Enterprise	$39/user	Pooled ($100/mo AI credits)	Slack + Teams; org governance for plugins
Source	plans	plans	changelog

All prices and credit budgets pulled from the Copilot plans page on 2026-08-24. New paid seats are still enabled gradually, so a fresh seat may not be instant.

Rating

Copilot earns 4.5 out of 5 in August 2026, up a tenth from 4.4 in July. The tenth is specific.

It goes to Agent Plugins 1.0 reaching GA. This is the one August change that alters the buy rather than padding it. The lock-in objection (Copilot plugins stranded in Copilot's client) was the standing reason a Cursor-first team treated a second Copilot seat as pure overlap, and a cross-vendor spec co-maintained by Cursor's own maker retires it (GitHub changelog, Aug 12). The three new models and the CLI upgrades are real value, but they are breadth inside an existing budget, not a structural change, so they support the tenth rather than earning their own.

What holds it below a higher score is the same edge that has held since June, plus this month's preview asterisks. Agent mode still trails Cursor Composer on whole-repo multi-file refactors. The credit model keeps monthly cost variable in a way a flat plan never was, and now Slack, Teams, and cloud agent runs all pull from that same pool (Teams changelog, Aug 21). The two integrations that would justify another tenth are public preview, and the plan gate on Slack (Business and Enterprise only) is exactly the kind of thing that shifts before GA. Grok 4.6, Kimi K3, and MAI-Code are all still rolling out, so the picker you read about may not be the picker on your seat yet.

The pick, by who you are

Three buyers, three answers. August moves two of them.

Solo developer. Pro+ at $39 is still the working tier, and it buys more this month at the same price (Copilot plans, 2026-08-24). Grok 4.6 handles the long agent sessions, Kimi K3 keeps routine work cheap, and MAI-Code takes a screenshot straight to code. The flip condition has not changed since June: if your day is all-day multi-file agent editing and you would rather not watch a credit meter, Cursor's Composer still edits cleaner on whole-repo refactors and its flat usage removes the meter. Our July Cursor review walks those tiers.

Small team on Business ($19/user). This is where August earns its keep. The Slack and Teams agents are gated at Business and above (Slack strictly so), and they land the handoff a small team keeps fumbling: a decision in chat becomes a triaged issue or a draft PR without anyone leaving the conversation (Slack changelog, Aug 21). If your reason to standardize on Copilot was coordination rather than raw editing speed, that reason got stronger. Treat the previews as previews and expect the plan gates to firm up before GA.

Enterprise on Enterprise ($39/user). Copilot was already the control-plane buy for GitHub-native orgs, and Agent Plugins 1.0 widens the lead. Engineers can pull portable plugins from the Awesome Copilot marketplace, run them under the Copilot policies you already enforce, and reuse the same plugin in a Cursor client without a rebuild (GitHub changelog, Aug 12). The action item is small: pick your org default model now that the picker is wider, and require the extra approval on Copilot-authored PRs if agent work will reach main. Re-check the Cursor comparison only if a team's day is genuinely editor-bound; for everyone whose work runs through GitHub, the August wave keeps Copilot the standardize-here pick.