Tencent Hy4, Nvidia Hugging Face Talks, and Copilot Agent Policy Converge

The open-weight stack just grew another frontier-sized coding model, the default model hub may be about to change owners, and the two most widely installed coding surfaces both moved the agent layer. That is a lot of gravity for one Thursday.

Tencent’s Hunyuan team put Hy4 preview on GitHub, Hugging Face, and OpenRouter this morning — a 770B MoE with 49B active parameters and a 1M-token context, pitched at long-horizon software engineering, office artifacts, and research, with API input priced at $0.834 per million tokens. Two days earlier, The Information reported Nvidia had agreed to acquire Hugging Face for $12.9 billion, a claim Reuters and TechCrunch carried while noting that neither company had confirmed it. If it closes, the vendor that already owns the training cluster would also own the distribution layer most open models actually travel through.

Microsoft tightened the agent loop in the editor and the forge. VS Code 1.135 (August 26) lets you resume Copilot or Claude sessions started elsewhere and run `/rubber-duck` so a complementary model reviews the first agent’s work. GitHub’s August 28 changelog tells Business and Enterprise admins to expect unified Copilot policy, longer chat retention, and upfront seat charges this fall. Treat today as a routing problem: which models you call, who hosts the weights, and which agent policy your org inherits by late September.

Top Stories

Tencent open-sources Hy4 preview, a 770B productivity MoE with 1M context Practical dev impact: You can hit a long-context, Apache 2.0 coding model today via OpenRouter, Tencent Cloud TokenHub, or a vLLM/SGLang image without waiting for a closed-API waitlist. Tencent released Hy4 preview on August 28 as a 770B-total / 49B-active Mixture-of-Experts with a 1M-token window, native MTP speculative decoding, and tool/reasoning parsers (`hy_v4`). Official positioning is software engineering, document-heavy office work, game prototypes, and scientific research; an internal blind eval of 163 experts on 203 engineering tasks scored it 2.99/4, slightly ahead of GLM 5.3 and Kimi K3 on that private set. API list price is $0.834 / $2.501 per million input/output tokens ($0.042 cached). Tencent itself flags this as an early preview that still over-reasons and over-verifies. Weights and an FP8 build are on Hugging Face (`tencent/Hy4-preview`); serving recipes exist for `vllm/vllm-openai:hy4-preview` and `lmsysorg/sglang:hy4-preview`.

Reports: Nvidia agrees to buy Hugging Face for $12.9 billion Practical dev impact: Until there is a signed, confirmed close, keep model cards, Spaces, and CI pulls portable — the GitHub of open weights may sit under the GPU vendor. The Information reported late August 26 that Nvidia had agreed to acquire Hugging Face for $12.9 billion; Reuters, TechCrunch, and Forbes repeated the figure while stressing that neither company had commented. Business Insider described talks above $13 billion that had not produced a signed agreement and could still fall apart. Hugging Face hosts more than two million models for a community The Information and follow-on coverage put in the low tens of millions of developers, on roughly $150 million of annualized revenue. A close would put the chipmaker that already finances most frontier training in control of where builders discover, version, and download open weights — the layer that decides which models actually get run.

VS Code 1.135 adds Rubber Duck and cross-app agent session resume Practical dev impact: Upgrade to 1.135, enable the Copilot agent host, and treat `/rubber-duck` as a cheap second-pass review before you merge agent diffs. Visual Studio Code 1.135 (August 26) ships an experimental Rubber Duck that asks a complementary model family to critique the primary agent’s plans, code, and tests — invoked with `/rubber-duck` inside a Copilot agent-host session. The same release shows recent Copilot or Claude sessions created in other apps in the Sessions list so you can continue them under your Copilot subscription (`chat.agentSessions.showExternal`). The agent host now runs harnesses in a dedicated process on the Agent Host Protocol, aligning editor Copilot with Copilot CLI and the standalone Copilot app. Chat footers also expose per-model input, cached-input, and output token counts per turn — useful as metered agent usage becomes the default bill.

GitHub Copilot unifies chat, mobile, and cloud agent — and tightens card billing Practical dev impact: Admins should lock Copilot cloud-agent policy and code-review effort before September 28, and finance should model October 1 upfront seat charges if you pay by card. In an August 28 changelog, GitHub said it will reopen Copilot Business and Enterprise sign-ups for credit-card/PayPal customers on September 1 with stronger vetting: new seats require payment before access, and existing card-billed orgs see upfront charges for assigned seats starting October 1. Seat prices are unchanged. No earlier than September 28, Copilot Chat on github.com, Copilot Chat in GitHub Mobile, and Copilot cloud agent become one experience and one policy, enabled by default; github.com chat data then follows cloud-agent retention (life of the account, not 28 days). Opting out of the unified policy drops web and mobile Copilot after launch. The same date, Copilot code review’s Default effort flips from Lite to Balanced unless you pin Lite explicitly.

Practical Impact Analysis

Three control planes moved at once: model supply, model distribution, and the agent IDE.

Hy4 preview is not a laptop model. 49B active still wants a serious GPU island (Tencent’s vLLM recipe starts at tensor-parallel 8 on the FP8 checkpoint). For most teams the useful path is API-first: OpenRouter or TokenHub as a long-context coding/research endpoint at well under closed-frontier input rates, with the Apache 2.0 weights as an escape hatch if you later need VPC serving. Treat Tencent’s own caveats as load-bearing — budget extra tokens for over-verification, and keep `reasoning_effort` (`high` vs `no_think`) as an explicit knob in your client.

The Hugging Face reports are the strategic risk, not a merge-day event. No confirmation, no close date, and one outlet still describes unsigned talks. What you can do this week is reduce single-hub coupling: pin model SHAs, mirror hot weights into your own registry, and make CI fail closed if `huggingface.co` is the only fetch. If Nvidia does own the hub, expect more CUDA-first packaging and a harder conversation about whether “open” still means vendor-neutral discovery.

VS Code 1.135 and the Copilot changelog are the near-term ops work. Rubber Duck is the right idea — critic models catch edge cases the author model will not — but it doubles model spend on every serious agent turn; watch the new per-turn token footer. External session resume means Claude CLI work can land back in Copilot-billed VS Code; decide whether that is a feature or a budget leak. On GitHub, September 28 is the real deadline: one Copilot policy, default-on unified agent, longer retention, and Balanced reviews that will chew more AI credits just as the summer promotional credit pools expire. Pin Lite if you want cheap review. Confirm the cloud-agent policy if you want web/mobile Copilot to survive. Put a payment method that can take October 1 upfront seat charges on file if you are still on card billing.

Net: add Hy4 to the eval harness, freeze your model-hub story, and treat late September as Copilot’s policy freeze — not a feature drop you can ignore.

Tutorial

Wire Hy4 preview into a two-pass coding loop: the model implements, then a second call (same or different model) plays Rubber Duck. OpenRouter is the path Tencent listed for global API access; the OpenAI Python SDK talks to it unchanged.

1. Create an OpenRouter key and export `OPENROUTER_API_KEY`. 2. `pip install openai`. 3. Point the client at `https://openrouter.ai/api/v1` and model `tencent/hy4-preview`. 4. For direct answers, pass `reasoning_effort: “no_think”`; leave the default (`high`) for hard refactors. 5. Run the critic pass with a stricter system prompt so it only reports defects.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],
)

MODEL = "tencent/hy4-preview"
SPEC = """Add a Python CLI `retry.py` that wraps any command with exponential backoff.
Requirements: argparse, max 5 attempts, jitter, non-zero exit if all attempts fail,
no extra dependencies."""

def chat(messages, no_think=False):
    extra = {}

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

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],
)

MODEL = "tencent/hy4-preview"
SPEC = """Add a Python CLI `retry.py` that wraps any command with exponential backoff.
Requirements: argparse, max 5 attempts, jitter, non-zero exit if all attempts fail,
no extra dependencies."""

def chat(messages, no_think=False):
    extra = {}
    if no_think:
        extra["extra_body"] = {
            "chat_template_kwargs": {"reasoning_effort": "no_think"}
        }
    resp = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        temperature=0.9,
        top_p=1.0,
        **extra,
    )
    return resp.choices[0].message.content

draft = chat([{"role": "user", "content": SPEC}])
critique = chat(
    [
        {
            "role": "system",
            "content": (
                "You are a hostile code reviewer. List only defects: missing "
                "requirements, unsafe shell usage, broken backoff math. "
                "If the draft is solid, say PASS."
            ),
        },
        {"role": "user", "content": f"SPEC:\n{SPEC}\n\nDRAFT:\n{draft}"},
    ],
    no_think=True,
)
print("=== DRAFT ===\n", draft)
print("\n=== RUBBER DUCK ===\n", critique)

Swap `MODEL` on the critic call if you want a true cross-family review (the VS Code Rubber Duck design). Keep Hy4’s recommended `temperature=0.9` / `top_p=1.0`. For local serving, replace `base_url` with `http://127.0.0.1:8000/v1` after the official `vllm/vllm-openai:hy4-preview` container.

Grok Deep Dive

Today is 2026-08-28. Tencent just open-sourced Hy4 preview (770B/49B MoE, 1M context, Apache 2.0, OpenRouter `tencent/hy4-preview`, vLLM image `vllm/vllm-openai:hy4-preview`, API $0.834/$2.501 per million, Tencent-acknowledged over-reasoning). Unconfirmed reporting says Nvidia agreed to buy Hugging Face for $12.9B. VS Code 1.135 added `/rubber-duck` plus resume of external Copilot/Claude sessions. GitHub’s changelog freezes Copilot’s fall: card-billed Business/Enterprise seats go upfront October 1; no earlier than September 28 chat, mobile, and cloud agent become one default-on policy with account-lifetime retention, and code review Default flips Lite → Balanced. I want a production routing plan: when to eval Hy4 versus closed coding models, how to de-risk Hugging Face as a single point of distribution without abandoning it, and an org checklist for Copilot policy, credit pools, and Rubber Duck spend before those September dates. Push back if any of those dates or numbers look overstated.