Meta AI Releases Brain2Qwerty v2: MEG Transcription Typed Sentences for Brain-to-Text Conversion with 61% Word Accuracy

Meta AI recently launched Brain2Qwerty v2. Determining natural sentences from non-distracting mental recordings in real time. The program reads magnetoencephalography (MEG) signals while a person types. It rebuilds what they typed, untethered and unedited. This is a sequel to Brain2Qwerty v1, released in February 2025. Meta also releases the full training code for both versions. The pipeline includes a convolutional encoder, a transformer, and a character-level language model.

The TL;DR

• Brain2Qwerty v2 determines typed sentences from MEG signals non-invasively, without implants or surgery.
• It achieves 61% average word accuracy (39% WER), up from 8% for previous non-invasive methods.
• The best participant achieved 78% word accuracy, with more than half of the sentences with one word error or less.
• The pipeline pairs a convolutional encoder, transformer, and character-level language model, along with fine-tuned LLMs.
• Accuracy scales log-linearly with data; training code for v1 and v2 is released under CC BY-NC 4.0.

What is Brain2Qwerty v2?

Brain2Qwerty v2 is a brain-to-text decoder. It maps immature brain activity to characters, then words and sentences.

Meta trained it on nearly 22,000 sentences from nine volunteer participants. Each participant was recorded for 10 hours while writing continuously.

The recording is from the MEG device. MEG measures the magnetic fields produced by neuronal activity, sampled at high temporal resolution.

The model uses letter, word and sentence level. That layered design allows it to correct local errors using a wider context.

Importantly, this is research, not a product. The decoder is not a consumer device, and has been tested on a small group of volunteers.

The data was collected with the BCBL of Spain (Basque Center on Cognition, Brain and Language). It belongs to that research center.

How the Decoding Pipeline Works

Previous non-invasive systems relied on manual taps to detect neural events. Brain2Qwerty v2 replaces that step with deep end-to-end learning.

According to the Meta repository, the model consists of three parts: a transcoding encoder, a converter, and a character-level language model.

A convolutional encoder reads the raw MEG signals. It reads features directly from the data instead of using engineered event detectors.

Long range structural transformer models for every signal. The character-level language model then limits the output to plain text.

The Meta research team describes three ways in which AI can make a difference. Each map to a concrete engineering decision they will see.

1. Deep learning replaces manual event detection.
2. Large language models have been fine-tuned to extract semantic representations.
3. AI agents have iteratively refined the decoding pipeline through automated code development. The final training configuration is still handpicked by the devs

Fine-tuning large-scale language models in neural data adds semantic context. That context closes the recording of the noisy brain and the corresponding language output.

Basically, the language model rejects sequences of letters that do not make up real words. It pushes the decoder to a sentence that one can write in a way that makes sense.

Here is a diagram showing the published architecture. It mirrors the defined components and is not a direct training code for Meta.

import torch
import torch.nn as nn

class Brain2QwertySketch(nn.Module):
    """Illustrative: convolutional encoder -> transformer -> char-level head.
    Reflects the components Meta describes, not the official implementation."""
    def __init__(self, n_meg_channels=306, d_model=256, n_chars=40):
        super().__init__()
        # 1) Convolutional encoder over raw MEG channels x time
        self.encoder = nn.Sequential(
            nn.Conv1d(n_meg_channels, d_model, kernel_size=7, padding=3),
            nn.GELU(),
            nn.Conv1d(d_model, d_model, kernel_size=5, padding=2),
            nn.GELU(),
        )
        # 2) Transformer models temporal structure
        layer = nn.TransformerEncoderLayer(d_model, nhead=8, batch_first=True)
        self.transformer = nn.TransformerEncoder(layer, num_layers=6)
        # 3) Character-level head; a language model refines this downstream
        self.char_head = nn.Linear(d_model, n_chars)

    def forward(self, meg):           # meg: (batch, channels, time)
        x = self.encoder(meg)         # (batch, d_model, time)
        x = x.transpose(1, 2)         # (batch, time, d_model)
        x = self.transformer(x)       # contextualized features
        return self.char_head(x)      # (batch, time, n_chars)

To work with the original Meta code, match the repository and test both versions:

git clone 
# brain2qwerty_v1/ and brain2qwerty_v2/ hold the training code

Accuracy Numbers

Brain2Qwerty v2 achieves a 61% word accuracy rating. That equates to a word error rate (WER) of 39%.

For the best participant, the model achieves a word accuracy of 78%. For that participant, more than half of the sentences had one or fewer word errors.

The previous premise is important here. Meta reports that some non-invasive methods only achieved 8% word accuracy.

Accuracy also improves logging in line with data volume. Additional recording hours are predicted to increase the accuracy in the reported range.

That scaling behavior is an important claim for builders. It suggests that the gap in surgical coverage can be narrowed by data alone.

These numbers are from volunteers in a controlled condition. There are no clinical implications in brain-injured patients.

v1 vs v2: What's Changed

Brain2Qwerty v1 and v2 report different metrics, so compare carefully. v1 is rated at the character level, v2 at the word level.

v1 also showed the MEG recording was at least twice as good as the EEG system. EEG signals are noisier, which limits accuracy.

Use Cases with examples

• The main motivation is to restore communication. Millions of people have brain lesions that prevent them from speaking or moving.
• Invasive methods such as stereotactic electroencephalography and electrocorticography are already feeding the neuroprosthesis into the AI ​​code. But they require neurosurgery and are difficult to measure.
• A non-invasive decoder can extend access. The patient may be able to type sentences without the implant, using only external recordings.
• For researchers, the extracted code supports replicable neuroscience. The lab can also train the pipeline on its MEG dataset.
• For AI developers, the project is a biosignal decoding template. The convolutional-encoder-plus-transformer pattern applies to other biosignal functions.
• For data scientists, the log-linear regression is a plotting tool. It frames how much new recording data can improve accuracy.

Interactive Descriptor