TRC Models and Music

� Bring your own key — or use your TRC wallet

BYOK needs no second account. Point TRC at your own OpenAI, Anthropic, Google, DeepSeek, Alibaba or xAI key and those tokens bill to your provider, not to a TRC balance — nothing to top up. Prefer one key for everything? Use the TRC wallet instead. Switchable per provider.

Also new: Grok 4.6 — xAI's flagship with a 500K context window — joins the Designer roster beside Qwen 3.8 Max & Flash.

Frontier models inside GitHub Copilot Chat — Claude, GPT, Gemini, DeepSeek, Qwen and Kimi — through one TRC account. No separate API keys, no juggling provider dashboards: a single wallet, per-token billing, and the same trusted models TRC serves across its platform.

Two ways to pay — your choice

You are not required to have a provider account — that is the point of the single wallet. BYOK is there for people who already pay a provider and would rather use that key than run two balances.

Either way, TRC still bills for what TRC runs — image generation, video, transcription and storage. That cost is ours, so your own key does not make it free.

TRC Models and Music is a bridge that registers TRC's OpenAI-compatible Model API with VS Code's built-in language-model-provider support, and ships a music player alongside it. Models appear as *@trc in the Copilot Chat picker. It is independent of GitHub and Microsoft. A free TRC account is required. Usage bills to your TRC wallet, or to your own provider account when you add a key.

See it

Music, social posting, the AI team bus, and bring-your-own-key — all inside the editor, with no browser and no second app.

🎵 Free music player

Discovery, playlists and radio inside the editor, with a mini player that follows you between panels. Browsing the catalog is free.

🤝 Team bus — comms for AI teams

A shared, append-only board where several agents and devs post state instead of chat: who is editing which file, what is blocked, what is ready to pick up. Each agent gets its own channel, and claims expire on their own so a crashed agent cannot hold a file forever. It stops agents overwriting each other's work.

🔑 Bring your own key

Your own OpenAI, Anthropic, Google, DeepSeek, Alibaba or Kimi key — used for inference, so those tokens never touch your TRC wallet. Keys are encrypted on TRC's servers and the editor never keeps a copy, so an uninstall leaves nothing behind.

📣 Write a post, and send it

A composer for your own social accounts, inside the editor — with the media you already made in TRC one click away. Or skip the composer and ask the agent: it can draft and publish through the same path.

Image URLs are absolute on purpose. The GitHub repo is private, and vsce resolves relative README images through raw.githubusercontent — which returns 404 for a private repo, so the Marketplace listing would show broken images. The public bucket renders in both the Marketplace and the extension details page, and npm run release uploads and re-fetches every one.

Overview

Pick your Designer

TRC ships a curated roster of chat agents — one default coding agent and eight design agents. Pick yours with TRC: Choose Designer… (or set trc.defaultDesigner):

The roster is pinned to the top of the TRC Models picker in Copilot Chat and labeled by role, so your designer is always one click away. The full frontier catalog stays available right below it.

Models

Every model below is in the picker. The id is what you select (or set in trc.defaultDesigner); the picker shows the id when you hover a model.

Qwen 3.8 Max and Qwen 3.8 Flash are the current Qwen pair: both take a 1,000,000-token context with up to 131.1K output tokens, both accept image input, and both support tool calling and a reasoning_effort level. Max is the 2.4-trillion-parameter MoE flagship; Flash is the fast multimodal one.

The picker is curated to the frontier set and mirrors TRC's central model catalog, so what you see is exactly what the platform serves.

Asset tools — your chat agent can make the art too

Models are great at writing code and useless at making assets — they can describe a sprite but can't produce one. TRC closes that gap: two tools let any model in the picker generate real image files straight into your workspace, then reference them in the code it writes.

"generate 3 sci-fi crate icons into assets/items and wire them into the registry"
"make a 4x4 tileset of grass, dirt, stone and water at 32px for my game"

Why the tileset tool matters: AI image models can't render 16×16 or 32×32 natively (they output 512–1024) and one-tile-per-prompt means a generation per tile — slow, expensive, and the palettes drift so the set looks like soup. Asking for a single sheet with solid separator lines gives you one generation for up to 16 consistent tiles, sliced automatically and downscaled with nearest-neighbour so the pixels stay crisp. Ask for a pack of 36 game textures and you get a coherent set, not 36 unrelated pictures.

• Files land in your workspace — trc.assetFolder (default assets/generated), and the model gets absolute paths back so it can immediately use them.
• Billed to your TRC wallet — per image / per sheet, same key as chat.
• Works with every model — not just TRC frontier models; Copilot's own models get these tools too.

Requires the TRC backend image endpoints (/api/v1/ai/images/*) to be deployed on the API your extension points at.

Team bus — many agents, one board

Running several AI interfaces in the same folder set normally means silent collisions: one agent overwrites another's committed work, or rotates a key the others are using. TRC ships a team bus so agents coordinate instead.

Built to run for years

The board is append-only and can run for months or years, so reads are designed to not grow with history:

• read shows state, not history — open items plus a bounded window of recent activity, and it tells you when it's showing a window.
• search is the on-demand path to detail — the log and its archives are searched together, with capped results.
• The log compacts by carry-forward — when it outgrows a size threshold it archives in full and starts a fresh live log holding only what is still true (unexpired claims, unacked warnings, a short recent tail). History stays on disk; the live board stays small.

It is deliberately not a chat channel:

• Append-only log (<workspace>/.agent-bus/bus.jsonl) — concurrent writers can only add, never overwrite, so it can't be clobbered the way a markdown file can.
• Typed entries — blockers and warnings surface before notes.
• Scopes and channels — team:backend chatter never drowns another team's digest, so large sub-teams can work all day without flooding the board.
• Expiring claims — a claim dies after its TTL (default 45 min), so a crashed agent doesn't hold a file forever.
• Collision detection — if your claim overlaps another agent's, you are told immediately (in the digest, on the board, and on the panel). path: scopes match by directory containment, so claiming src/routes collides with someone holding src/routes/apiV1.js.
• State, not conversation — reads return a compact digest.

Pair it with the lease guard (agent-tools/lease.mjs) for files: the bus advises, the lease hook enforces. Point several worktrees at one bus with trc.teamBusPath so agents in separate folders still coordinate.

Seeing it — TRC: Open Team Bus

The Team Bus item sits at the top of the TRC sidebar with live state next to it (3 claims · 1 warning), and TRC: Open Team Bus opens the full view: open blockers and warnings, the merge queue, handoffs, who has claimed which paths, and recent notes. It refreshes itself every 15 seconds, and you can drop your own note on the board from the composer at the bottom.

That is the point of the whole thing: agents coordinate in one place, and you can watch it happen without reading a log.

Social posting — write it here, send it from here

You already generate images and music in TRC. Social closes the loop: a composer for your own accounts, in the editor, with the media you already made sitting one click away.

TRC: Social (or the Social item in the TRC sidebar) opens two tabs:

Linked accounts are yours — the extension posts as you, to your accounts. TRC never posts for you.

Let the agent do it

trc_social_post lets any model in the picker draft and publish — including scheduling:

"announce my new single, out Friday, and schedule it for 9am"
"post that album art to Instagram and X with a short caption"

It cannot post silently. Before anything is sent, VS Code shows you the exact text and the destination and asks you to allow it. Publishing is public and irreversible, so there is deliberately no flag to skip that step — and the tool will refuse to post if nothing is linked, rather than guess.

With no targets, it posts to every account you linked. That is your earlier choice, not the model's.

Media is a picker, not an upload — on purpose

The attach row lists your TRC library: the images you generated with TRC's models, and the files you uploaded to TRC. TRC storage holds TRC assets, so there is no path here for pushing an arbitrary local file into it — which is exactly what you want from a tool that can publish to your accounts.

Why linking opens your browser

Every provider requires a pre-registered redirect URI, and those URIs belong to TRC's website. A vscode:// callback is not one of them and cannot be added from the editor, so the Connect button starts the flow and your browser finishes it. That is a provider requirement, not a shortcut.

Scheduled posts keep running

Scheduling hands the post to TRC's server, which publishes it on time even with the editor closed. Nothing is queued locally, so closing your laptop does not cancel anything.

Seeing what's happening — Activity

TRC is not a black box. TRC: Open Activity (or the Activity item in the TRC sidebar) shows:

It refreshes every 20 seconds and links to the full web console for history.

Not included: chat conversations. Your prompts and replies live in Copilot/VS Code — TRC does not store them, so the extension cannot display them. Activity covers the operational side (requests, tokens, spend), and the Team Bus covers what agents choose to report.

Updates

Installed from the Marketplace, the extension updates itself — VS Code checks in the background and applies new versions on reload, so you don't search for it.

• You'll be told what changed. On a version change you get a one-time notice naming the release highlights, with a See what's new button. (Background updates are silent by design; this makes them visible.)
• Want to check now? TRC: Check for Updates, or the Check for Updates item in the TRC sidebar, which also shows your running version.

⚠️ Installed from a .vsix file, the extension can't update itself — VSIX installs have no link back to the Marketplace, so new versions must be installed manually. Install from the Marketplace to get updates automatically.

Off-peak pricing (DeepSeek)

DeepSeek charges half price off-peak, and that saving is passed straight through to your wallet. Peak is 01:00–04:00 and 06:00–10:00 UTC, Monday–Friday — everything else, including all weekend, is off-peak.

The model picker tells you what applies right now, with a live countdown:

DeepSeek V4.1 Flash   Default coding agent · DeepSeek · OFF-PEAK · peak in 6h 20m

Because coding agents are cache-heavy, off-peak also halves the cache-hit rate — which is where most of the cost lives, so the difference is larger than it looks.

Getting started

1. Install the extension from the VS Code Marketplace (or from the VSIX — see Manual install below).
2. Connect: run TRC: Sign In / Set API Key, then either
   • Sign in with email — a developer key is created for you automatically, or
   • Paste a developer API key — create one free at trc.inc → Developer API.
3. Open Copilot Chat, pick any model under TRC Models, and start.
4. Usage is billed to your TRC wallet — included credits are consumed first.

If no key is set yet, the status bar shows TRC: Set API Key; click it to connect in one step.

Billing

• All models are billed per token to your TRC wallet (author wallet for user keys, partner wallet for partner keys).
• Every call is logged in the Developer API console — requests, status and latency — and rolls up into your usage dashboard.
• Pricing is kept at cost and reinvested in TRC's AI platform and services.
• Top up at any time from the wallet page or the status bar.

Commands

Settings

Security

• Keys are stored with VS Code SecretStorage (OS-level encryption) and sent only in the x-trc-api-key header, directly to api.trc.inc.
• Only the SHA-256 hash of a key is stored server-side. Revoke a key from the Developer API console at any time; it stops working immediately.
• No telemetry and no analytics SDKs. The extension communicates only with the API endpoints you configure.

Manual install (VSIX)

1. Download the .vsix from the TRC CODE download page.
2. In VS Code: Ctrl+Shift+P → Extensions: Install from VSIX... → select the file.

Changelog

See CHANGELOG.md.

License

MIT — see LICENSE.txt. © 2026 The Relationship Constitution, LLC.