Bluwing
Blog/Product/Pin a version, move an alias3 min left
Start free

On this page

01Versions are immutable02Why the pin matters03Moving an alias04What an alias is not05Rolling back06Frequently asked questions

Bluwing

HomeBlogWhy it's cheaperFeaturesHow it worksPricing
  1. Blog
  2. Product
  3. 3 min read

Pin a version, move an alias

Editing tools in production is how a working agent breaks on a Tuesday. Bluwing serves one request from one version, and aliases let you move traffic when you decide.

Bluwing teamSeptember 18, 2026
Three version plates on a stack, with an alias pointer between them.

On this page

  1. 01Versions are immutable
  2. 02Why the pin matters
  3. 03Moving an alias
  4. 04What an alias is not
  5. 05Rolling back
  6. 06Frequently asked questions
Back to the top
Key takeaways
  • A request is served by exactly one version
  • Aliases are pointers you move, not copies you rewrite
  • Determinism is only meaningful against a pinned version

Tool definitions are code. They change, they regress, and they need a way to ship without taking production down. Yet many tool-calling setups edit the live definition in place, so a request that arrived before the edit can be served by a schema that no longer exists.

Bluwing separates the version from the name you call.

#Versions are immutable

Every build produces a version number. That version is a fixed snapshot of the tree: the branches, the leaves, the schemas, the hints. It does not change when you edit a tool. Editing produces a new version.

A request names a version, directly or through an alias:

json
{
  "model": "brick:support-desk@live",
  "messages": [{ "role": "user", "content": "Find Acme's latest invoice" }]
}

live is an alias. Behind it is a version number such as 7. The engine resolves the alias once, at the start of the request, and uses that version for every stage. If you publish version 8 while the request is in flight, the request still finishes on 7.

Rule

one request, one version, even when you deploy in the middle of it.

#Why the pin matters

Determinism — the same request, facts and version give the same call — is only a useful promise if the version is part of the input. Without a pin, "the same request" can silently mean "the same request against whatever schema was live at the time," and the guarantee evaporates.

The pin also makes debugging sane. A trace names the version it used, so a regression can be reproduced against the exact tree that produced it, not against today's tree.

#Moving an alias

Aliases are how you ship. A typical flow:

  1. Build the new tree. It gets a version, say 8.
  2. Point staging at 8.
  3. Run your evaluation suite against staging.
  4. Point live at 8 when you are satisfied.
  5. Keep 7 addressable for rollback.

Nothing about steps 1–3 touches production traffic. The move in step 4 is a pointer change, not a rebuild, so it is immediate and reversible.

AliasPoints atPurpose
live7Production traffic
staging8Evaluation and QA
canary8A slice of production, if you want one

You can also pin a version explicitly — @7 — for a batch job or a regression test that must not move.

#What an alias is not

An alias is not a copy. It does not snapshot the tree, and it does not isolate you from edits. If you point live at 8 and then build 9, live stays on 8 until you move it. The pointer is the only thing that changes traffic.

It is also not a per-request setting you should scatter through your code. Pick one place — configuration, an environment variable, a request header — and let the application read it from there. An alias hard-coded in twenty services is a deployment problem wearing a version number.

#Rolling back

Rollback is the same operation as release: point the alias at the older version. Because versions are immutable, rollback is exact. There is no "revert the edit and hope the cache clears" step.

If a rollback is needed often, that is a signal about the evaluation suite, not about the versioning system. Add the failing case to the suite before you ship the fix.

Three versions, one alias

#Frequently asked questions

Can two aliases point at the same version?

Yes. live and canary can both point at 8 during a full rollout, and staging can stay on 9.

Does moving an alias cost credits?

No. Alias moves are free. Building a new version is what costs credits.

What happens to in-flight requests when I move an alias?

They finish on the version they started with. New requests use the new target.

ProductVersions
← PreviousTool output is data, never instructionsNext →One credit per turn, and what a turn is
Point your client at Bluwing.Same tool definitions, same tool_calls. One credit per turn, from $4.50 a month.
Start free

Keep reading

ProductOct 44 min

No tool call is a valid answer

When nothing fits, the most useful thing an engine can do is decline. Bluwing returns no tool call instead of reaching for the closest one.Read →
EngineOct 284 min

Why a long tool list slows everything down

A flat list of two thousand tools asks one model to hold all of them in mind. Bluwing narrows a tree first, so the model sees twelve or fewer.Read →
GuaranteesOct 204 min

Every argument has to come from somewhere

Language models are good at plausible IDs and dates. Bluwing requires each argument value to appear in the request, the conversation, your facts or an earlier tool result.Read →
Start freeBluwing logoBluwing

Explore

  • Why it's cheaper
  • Features
  • How it works
  • Pricing
  • Documentation
  • API Reference
  • Comparisons
  • Blog & Guides
  • Privacy Policy
  • Terms of Service
  • System Status

Talk to us

© 2026 Bluwing · bluwing.si. The tool-calling engine for AI agents.

  • Blog→
  • Product Hunt
  • LinkedIn