tag

in English: Git tag

advancedwidespread

A tag is a named, local marker in Git version control that records a specific state of the code – typically a released version.

In plain terms

Imagine working on a thick manuscript for months and rewriting something in it every day. When you send a version to the printer, you insert a bookmark with a label: 'first edition'. No matter how much you write afterwards, you can always flip back to that bookmark. A tag is exactly such a bookmark in the code.

Git identifies every save (commit) with a long, unmemorable string of letters and numbers. A tag adds a human-readable name to this, such as "v2.1.0". Thus, you do not have to say "the 9f3a7c1 state," but rather "version 2.1".

It differs from other markers in Git in that it does not move. The branch moves along with the work, but the tag stays where you put it. This is why it is used to mark releases: everyone understands exactly the same code under a version number.

How it works

The developer selects a saved state of the code (a commit) to mark—usually the one ready for release.
You give it a name, usually a version number (for example, v1.4.2). There are two types of tags: a simple one with just a name, and an annotated one that also stores the creator, date, and a short description.
A label with an annotation can also be digitally signed, so it can later be verified that it was really added by the person whose name appears on it.
The tag initially exists only on the developer's own machine; it must be uploaded separately to a shared repository (for example, GitHub) for others to see.
Uploaded tags often trigger automated workflows: testing begins, a deployable package is created, and a downloadable release appears.

An everyday example

You update an app on your phone and see in the description: "version 3.2.0". Behind the scenes, developers likely tagged the code with v3.2.0, and the package you downloaded was built from that state. If you report a bug, they can retrieve exactly that code based on the version number.

Who is affected

developerYou mark releases with a tag, so you can return at any time to an earlier version that is known to work. → Code

entrepreneur, executiveTags show when each version reached customers, which is valuable in case of errors, complaints, and audits.

industrial worker, engineerFor software on devices and equipment, the version number running on the device can be traced via the tag back to the source code from which the program was built. → Industry

everyoneBehind the version numbers of your apps there is usually such a tag, which is how you know what you got with an update.

A common misconception

MythA tag is the same as a hashtag or labeling in social media: a keyword used to group content.

In realityA Git tag is not a topic label but the name of a single specific code state. It does not categorize but records: it states exactly which snapshot was, for example, version 1.0.

Limits and risks

By default, the label is not uploaded to the shared storage automatically: if you forget to send it separately, it exists only on your machine.
Technically, it can be deleted and moved. However, rewriting an already published tag later is bad practice: the old version remains on others' machines, causing confusion, and anyone referencing the tag name may unknowingly receive different code.
The tag itself does not guarantee that the code is good or secure; it only records which state it is in.
With an unsigned tag, it cannot be reliably verified who created it: a simple (lightweight) tag does not even store a creator, and any name can be entered into an annotated one. Therefore, in sensitive projects and alongside automatically working coding agents, it is advisable to require signed tags.

Similar, but not the same

branch – The branch advances with the work on every new save, while the tag does not move on its own: it points to the same state until someone intentionally moves it.
commit – The commit itself is the saved state, while the tag is just a memorable name you attach to it.
release – A release is a package for users, with a description and downloadable files; it is typically built on a tag, but is more than that.

Related concepts

Broader

Git, version control, software development

Narrower

annotated tag, lightweight tag, signed tag

On the edge

commit, branch, release, semantic versioning, repository

A brief history

Git, the version control system, was created by Linus Torvalds in 2005 for Linux kernel development, and tagging was part of it from the start because kernel releases needed to be clearly marked. The solution became the general labeling method for software releases with the spread of GitHub and similar services.

Where things stand

By the end of 2026, tags are the established method for marking software releases and are found in almost every project using Git. Coding agents routinely read and create them, while supply chain security increasingly requires signed tags in more places.

Status: 2026 November

In the news

Appears in 3 Agent Age stories; the curve shows weekly occurrence in the news magazine.

Linux kernel may drop AI-code labels as Torvalds uses AI tooOct 19, 2026 · Code
Influencer marketing legal risks in 2026: #ad tag no longer enough for AI-generated content and virtual influencersAug 27, 2026 · Marketing
ANA, TAG and Fiducia quantify 'AI slop' in the digital ad supply chain for the first timeAug 10, 2026 · Marketing

Also known as

tag · Git tag · Git tag · tag · version label · release tag · annotated tag · tagging

Sources

This entry was machine-edited and has undergone machine expert review; the “In the news” section updates automatically from Agent Age stories.