Self-Closing Reviews Meet Plugin Evals and Managed Agent Harnesses

September 14 is a Monday hygiene-and-harness day built from late-week ships, so the useful work is how these four moves fit together. Copilot reviews can close their own resolved threads while Lite reviews get an ensemble, Claude Code finally gives plugin authors a scored eval CLI, Cursor Projects aim at multi-month coordinator work, and OpenAI’s Agents API productizes the Codex harness for your apps.

Treat today as a review-loop and agent-runtime day. Enable Copilot code review auto-resolution behavior on a busy PR, pin Claude Code to v2.1.270 and run one `claude plugin eval` against an internal plugin, open a Cursor Project for a migration or feature track, and smoke-test an Agents API hosted-sandbox session with `gpt-6-astra`.

Top Stories

Copilot code review now auto-resolves addressed comments and deepens Lite analysis
Practical dev impact: You no longer need to manually clear Copilot review threads that your latest commits already fixed, because GitHub’s September 11 changelog says Copilot resolves its own comments during rereview once a later commit addresses the feedback, and it leaves outstanding items open so the remaining queue is the real work. Applying a Copilot autofix suggestion now gets a smart commit message instead of a generic autofill, which keeps history readable when you accept many small fixes. Behind the firewall, review agents can use the full Copilot SDK shell tool set to run builds, tests, and scripts, and Lite effort reviews now combine an ensemble of agents rather than a single pass. GitHub’s experiments reported more high-severity findings with fewer nits for shell-backed analysis, plus more addressed comments per Lite review (about +47% high, +31% medium, +11% low) at roughly 8% lower review cost. Keep human judgment on security-sensitive paths, then watch whether open threads shrink without losing real findings.

Claude Code v2.1.269 ships `claude plugin eval`; pin through v2.1.270
Practical dev impact: Pin `@anthropic-ai/claude-code` to `2.1.270` (or at least `2.1.269`) so plugin authors can run `claude plugin eval` against a suite of prompts and graders and get scored, reproducible JSON plus HTML reports instead of vibes-based plugin shipping. The September 11 release also adds `/output-style` switching in remote and headless sessions, `CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS` (1 to 256) for inference-bound Workflow fan-outs, optional Bash edit diffs via `bashEditDiffEnabled`, and a VS Code agent map for subagents. Official docs document `claude plugin eval` and `claude plugin eval init`, with CI-oriented flags such as `–threshold`, `–max-cost-usd`, `–trust-plugin`, and `–json`. September 12’s v2.1.270 is a narrow fix: read-only git commands in Bash stopped prompting again after long sessions (a v2.1.269 regression). Prefer an explicit pin in images and Actions so fleets do not drift past the eval CLI and the git permission fix.

Cursor Projects beta: coordinator agents for months-long work
Practical dev impact: Open Projects from the left-hand nav when a feature, migration, or greenfield app is too large for a single chat, because Cursor’s September 10 launch keeps shared context across cloud and local agents, lets a coordinator plan and delegate without writing the implementation itself, and can fan out many parallel implementers. Each Project runs on its own cloud computer so closing your laptop does not stop the work, and the coordinator can spin a local agent when something must be tested on your machine. Agents write research, artifacts, and learned preferences into shared Project files so the next agent does not need a fresh onboarding speech. Subscriptions can watch Slack, run on a schedule, or follow PRs so the coordinator reacts to signals without waiting for a prompt. Treat the beta as a scoped pilot on one migration track with clear human checkpoints before you point it at auth or billing.

OpenAI Agents API public beta brings the Codex harness to your app
Practical dev impact: If you have been hand-rolling session state, compaction, and subagent glue on top of Responses, start a spike against the Agents API instead, because OpenAI’s September 10 announcement puts the Codex harness behind a managed API that owns sessions, orchestration, context compaction, and recovery while you supply tools and choose an environment. Docs describe OpenAI-hosted sandboxes, self-hosted sandboxes, or no sandbox, plus MCP tools, programmatic tool calling, mid-turn steering, and multi-agent fan-out. Model usage bills at the selected model’s API rates, with standard rates for built-in tools and hosted containers. The quickstart uses `client.beta.agents.sessions.create` with `model: “gpt-6-astra”` and `environment: {“type”: “openai_hosted”}` under the `OpenAI-Beta: agents=v1` header (SDKs add it). Keep API keys outside the sandbox, request `api.agents.read` / `api.agents.write` plus `api.responses.write`, and compare this managed path to keeping orchestration in-process with the Agents SDK when you need tighter control.

Practical Impact Analysis

Today’s through-line is who closes the loop on agent work, and who owns the long-running harness. Copilot code review’s auto-resolution and smart commits shrink the human tax on comments that are already fixed, while shell-backed validation and Lite ensembles push review quality without asking every team to jump to a heavier effort tier. That is the PR hygiene half of the Monday reset.

Claude Code’s `plugin eval` is the quality gate for the plugin economy Anthropic has been shipping hard this month. If your org distributes internal skills, hooks, or MCP bundles, a scored with/without suite plus `–threshold` and `–max-cost-usd` turns plugin merge criteria into something CI can fail. Pinning through v2.1.270 is the small operational follow-through so long sessions keep read-only git from nagging again.

Cursor Projects and the OpenAI Agents API attack the same problem from opposite ends. Projects are an IDE-native coordinator for multi-month product work with shared memory and subscriptions. Agents API is an application-native Codex harness with compaction and subagents so your product can run cloud agents without reinventing session infrastructure. Use Projects when the unit of work is a codebase initiative you still want to review in Cursor. Use Agents API when the unit of work is a product feature that must run for hours inside your own backend.

If you only do three things this morning, re-review a Copilot-covered PR and confirm auto-resolved threads match reality, pin Claude Code to v2.1.270 and run `claude plugin eval –help` on one internal plugin, and create either a Cursor Project for your longest open migration or a single Agents API hosted-sandbox session with `gpt-6-astra`.

Tutorial

Smoke-test OpenAI Agents API with a hosted-sandbox coding session. Export a Platform project key that has `api.agents.read`, `api.agents.write`, and `api.responses.write`. Keep the key on the host, not inside the sandbox.

1. Install or upgrade the Python OpenAI SDK and set `OPENAI_API_KEY` in your shell (never hardcode the key).
2. Create a hosted-sandbox session with `gpt-6-astra` and stream events.
3. Confirm the stream shows environment readiness, tool or shell activity, and a final tree listing.
4. Next, retry with `multi_agent` enabled or attach an HTTP MCP server from the overview examples when you are ready to leave the single-agent path.

import os
from openai import OpenAI

assert os.environ.get("OPENAI_API_KEY"), "Set OPENAI_API_KEY before running"

with OpenAI() as client:
    with client.beta.agents.sessions.create(
        agent={
            "model": "gpt-6-astra",
            "instructions": "Write clean code, run it, and report the actual output.",
        },
        environment={"type": "openai_hosted"},
        input=(
            "Create tree.py, a Python script that prints a readable tree of the "
            "files in the current directory. Run it and show me the output."

... click "Show full code" below to expand

import os
from openai import OpenAI

assert os.environ.get("OPENAI_API_KEY"), "Set OPENAI_API_KEY before running"

with OpenAI() as client:
    with client.beta.agents.sessions.create(
        agent={
            "model": "gpt-6-astra",
            "instructions": "Write clean code, run it, and report the actual output.",
        },
        environment={"type": "openai_hosted"},
        input=(
            "Create tree.py, a Python script that prints a readable tree of the "
            "files in the current directory. Run it and show me the output."
        ),
        stream=True,
    ) as events:
        for event in events:
            print(event.to_json(indent=None), flush=True)

Recommended AI prompt

Copy this paragraph into ChatGPT, Claude, Gemini, Grok, or whatever you use.

You are my staff engineer for coding-agent review loops and long-running harnesses on 2026-09-14. Copilot code review can auto-resolve addressed comments, suggest smart commits on autofix, run shell-backed validation, and ensemble Lite reviews. Claude Code v2.1.269 adds `claude plugin eval` with scored JSON and HTML reports; pin through v2.1.270 for the read-only git prompt fix. Cursor Projects beta coordinates long-lived cloud agents with shared context and Slack, schedule, or PR subscriptions. OpenAI Agents API public beta exposes the Codex harness with managed sessions, compaction, MCP, sandboxes, and subagents; the quickstart model id is `gpt-6-astra`. Ask which Copilot review repos, Claude Code pins, Cursor seats, and OpenAI Platform projects we run. Then produce a Copilot review adoption checklist for auto-resolve and Lite ensemble behavior, a Claude Code v2.1.270 pin plus first `claude plugin eval` CI gate, a one-project Cursor Projects pilot with human checkpoints, and an Agents API hosted-sandbox spike plan with key scopes and cost watches. Keep it concrete and copy-paste ready.