zeta-2.1

zeta-2.1

Predicts how the code around your cursor should be rewritten next, from the file context and your recent edits. A model from Zed Industries for people building editor features.

Made by zed-industries on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Zeta 2.1 guesses the next change you will make to your code. Zed Industries built it on Seed-Coder-8B-Base, and the card calls the job next-edit suggestion. You give it code context, a history of edits and an editable region around the cursor, and it writes the new content for that region.

Who it suits: It suits developers who build editor features and want a model that suggests the next change instead of answering chat questions.

Industry | Who uses it | How they use it | Example
Software | Editor and plugin developers | Add next-edit suggestions to a code editor | Send the cursor region and recent edits, then show the returned rewrite
Software | Teams that host their own models | Run a code edit model on their own machine | Download the weights and call them from a Python service
Research | Code model researchers | Study a fine-tune of a coding base model | Compare its rewrites with the base model's output

People who want a chat assistant can skip it, since the card describes only edit prediction for a marked region.

Where to use it: The model has no app of its own. It runs wherever your code can load it and build the prompt.

• Windows, macOS and Linux, with Python for the download
• A code editor or tool that builds the prompt format the card describes
• Python projects built on the transformers library, which the record lists

Use case | Who | What they get back
Next-edit suggestions | Editor makers | Rewritten content for the editable region, wrapped in the same markers
Offline experiments | Researchers | Model output for prompts built from real code and edit histories

How to set it up: You need Python with pip, and enough disk for the weights.

• Python with pip
• About 16.5 GB for the BF16 weights, or about 4.1 GB at 4-bit, which is an estimate
• Code of your own that builds the prompt and reads the answer

1. Install the Hugging Face hub library with pip.
2. Download the repository's files to your computer with the hf command.
3. Load the model in your own code and send it the prompt format below.

pip install -U huggingface_hub
hf download zed-industries/zeta-2.1

How to use it: Build the prompt in the card's suffix, prefix, middle style. Put the code after the region first, then related files, the edit history and the target file. Wrap the editable region in numbered markers and place the cursor marker inside it.

<[fim-suffix]>
code after editable region
<[fim-prefix]><filename>related/file.py
related file content

<filename>edit_history
--- a/some_file.py
+++ b/some_file.py
-old
+new

<filename>path/to/target_file.py
code before editable region
<|marker_1|>
code that
needs to<|user_cursor|>
be rewritten
<|marker_2|>
<[fim-middle]>

The model should answer with the revised content between the same two markers, and nothing wrapped in backticks.

<|marker_1|>
revised content for
the editable region
<|marker_2|>

Tool | What it does
marker_1 and marker_2 | Mark the start and end of the editable region
user_cursor | Marks where the cursor sits inside the region
filename | Introduces a related file, the edit history or the target file
fim-middle | Ends the prompt, so the model writes the region

Example: Put a few lines between the first and second markers with the cursor inside them, add a diff of your latest edit, and send the prompt. The model returns the revised lines wrapped in the same two markers. The card links a sample prompt and a sample output.

For newcomers and experts: If you are new to this, know that it is not a chat model. An editor sends it code and your recent changes, and it guesses the next edit. Start by building the card's short prompt by hand with a small file.

If you know the field, this is an 8.3B coder fine-tune with a suffix, prefix, middle prompt and numbered multi-region markers. Your tool has to parse the marked output, and the editable region limits how much the model can rewrite at once.

The editor gathers code, edits and the cursor spot
A prompt is built with numbered markers
The model writes the revised region
The editor swaps the text between the markers

Good to know: The card lists model version 0323-multi-region-filtered-r3 and gives no other training details.

• License: Apache 2.0, as the card and record state
• Languages: English only in the record
• Other versions: the record counts 28 quantized copies and 0 fine-tuned ones made by other people
• Cost to run: none named
• Data it reaches: the code, edit history and related files you put in the prompt, plus the model files you download from Hugging Face

Title: Weights size in gigabytes
BF16: 16.5 GB
4-bit (estimate): 4.1 GB

On Hugging Face, 14 November 2026

• Task: text generation
• Library: transformers
• Parameters: 8.3B
• Weights: about 16.5 GB in BF16; about 4.1 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 2,797
• Likes: 140
• License: apache-2.0
• Languages: en
• Based on: ByteDance-Seed/Seed-Coder-8B-Base
• Quantized versions: 28
• Tags: transformers, safetensors, llama, text-generation, edit-prediction, next-edit-suggestion

Links

• Model: https://huggingface.co/zed-industries/zeta-2.1
• Files: https://huggingface.co/zed-industries/zeta-2.1/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download zed-industries/zeta-2.1

Then follow the usage in its model card. Nothing in this kit runs by itself.