What Is GibberLink? AI Language, Mode & Translator Explained

What is GibberLink, and is it real? See how AI agents switch to sound, decode a real ggwave sample, and learn what GibberLink mode can and cannot do.

AskZyro Team12 min read
What Is GibberLink? AI Language, Mode & Translator Explained

GibberLink is an open-source demonstration in which two AI voice agents switch from spoken English to exchanging messages through sound. It became widely known in February 2025 after a video showed a hotel-booking conversation turning into a series of electronic chirps.

The demonstration is real. The popular explanation that the AIs secretly invented their own language leaves out the crucial detail: their developers explicitly instructed them to switch to an existing data-over-sound library called ggwave when both sides agreed.

This guide explains GibberLink mode, what the sounds contain, whether a “GibberLink translator” can decode them, and how to try the underlying technology. We also ran our own encoding and decoding test, with a playable audio sample below.

Sources and demo availability checked 19 November 2026. Cover: an AI-generated editorial illustration created for AskZyro, not a screenshot of the original project.

GibberLink connects a conversational AI system to software that sends data as sound. Two agents can begin by speaking normally, establish that the other side supports the alternative communication method, and then use audio signals to carry their messages.

The original project combines ElevenLabs conversational AI with Georgi Gerganov’s ggwave library. They do different jobs:

  • The AI agent interprets the conversation and decides what to say or do.
  • The voice system supports the initial spoken conversation.
  • ggwave encodes message bytes into audio and decodes received audio back into bytes. It does not need an AI model to perform that conversion.

Calling the sounds an “AI language” is an accessible shorthand, but it can be misleading. A message can still contain ordinary text; the unfamiliar part is how that text travels between devices. It is closer to a small modem than a new language with its own grammar.

In the creators’ demonstration, one agent acts as a caller arranging a hotel booking and another acts as the receptionist. The conversation starts in English. Once they establish that both are AI assistants, they agree to switch to GibberLink mode and continue exchanging information through audible tones.

The original demonstration, published by co-creator Anton Pidkuiko on 23 February 2025. Watch on YouTube if the embedded player is unavailable.

The key instruction is documented in the project’s reproduction guide. A client-side tool called gibbMode is to be called once both conditions are met:

“you realize that user is an AI agent” and “they confirmed to switch to the Gibber Link mode”.

That makes the switch an intended feature of the demonstration. The agents choose when the configured conditions appear to be met; the developers supplied the capability and the instruction. Recognising an AI claim in a conversation also does not cryptographically verify who is on the other end.

Anton Pidkuiko and Boris Starkov created the project at the ElevenLabs London hackathon in February 2025. Its repository says it won first place at the ElevenLabs × a16z international hackathon. The underlying ggwave library was created by Georgi Gerganov and predates GibberLink.

In a March 2025 TechCrunch interview, the creators described it as an open-source side project and said they were not commercialising it at that time. That historical statement should not be read as a permanent promise about future services, prices or availability.

It is a real software demonstration with publicly available code. It shows that configured AI agents can hand communication over to a sound-based data channel. It does not demonstrate sentience, secret intentions or AIs independently discovering a new language.

ElevenLabs’ own account confirms that the agents were told to switch protocols if they believed the other participant was also an AI agent. The developers chose ggwave because it was a convenient, stable option within a hackathon’s time constraints.

  • “They invented a language humans cannot decode.” They used a published encoding system. Compatible software can recover the message.
  • “The AIs decided to hide their conversation.” The documented instruction was to change the communication method. The demonstration provides no evidence of an intention to conceal information.
  • “Every AI can automatically do this.” Both systems need the necessary integration. Merely asking a chatbot to “activate GibberLink mode” does not install a working audio encoder or decoder.
  • “The sounds prove the message is correct.” Successful transmission only shows that data arrived. The AI can still make a mistake about the booking or any other task.

“GibberLink mode” is the project’s name for communicating through the alternative sound channel. The important change happens between the message and the audio, rather than inside the meaning of the message.

  1. Start a normal conversation. The agents use understandable speech while the other participant may be human.
  2. Agree to switch. The configured agents recognise the situation and confirm the change.
  3. Encode a message. ggwave converts bytes into a pattern of tones.
  4. Transmit and decode. A speaker plays the waveform, a microphone captures it, and a compatible decoder recovers the message.
  5. Continue the task. The receiving agent uses the recovered message to decide its next response.
Four steps: an agent chooses a message, ggwave encodes it into tones, sound travels between devices, and the other agent decodes the message.
AskZyro diagram of the communication process. The “2 guests” message is illustrative. Open the image to enlarge it.

Technically, ggwave uses a form of frequency-shift keying: different combinations of tones represent pieces of data. It also uses error-correction codes to help recover messages when some of the signal is damaged. You do not need to understand the mathematics to use a compatible decoder.

The project’s audio-handling code decodes the waveform back into text and passes received messages to the application. An AI does not have to learn to “hear” the beeps as a new language; ordinary signal-processing software handles that part.

Yes, if the recording contains a compatible ggwave signal and is clear enough to decode. What people call a GibberLink translator is generally a decoder. It reverses the encoding process and recovers the original payload.

If the sender encoded English text, the result is English text. If it sent a compact code, another language or application-specific data, a further interpretation step may be needed. There is no universal dictionary that translates any robotic sound into a meaningful sentence.

The original GibberLink README links to Waver, ggwave’s browser demonstration, and suggests playing the original video into it to see the messages decoded. This is a better starting point than an unrelated website promising to reveal a “secret AI language”.

Our test: a message encoded as sound and recovered exactly

We tested the JavaScript ggwave package, version 0.4.0, in a browser using its Audible Fast protocol at 48,000 Hz. The message was Hello from AskZyro.

The encoder produced an audio waveform lasting approximately 1.83 seconds. A separate decoder instance recovered the exact original text. We also exported a 16-bit PCM WAV file and verified that the samples in that file decoded to the same message.

Screenshot of AskZyro's actual ggwave test: the original and decoded messages both read Hello from AskZyro, with a passing result.
Our browser test display, using the actual decoded result and waveform. This is a ggwave test, not a screenshot of the original GibberLink app.

Hear the encoded message: start at a comfortable volume. This sample was created for this guide; it is not extracted from the viral video.

Open or save the WAV sample. Its decoded text is Hello from AskZyro.

What this test establishes: software can recover a readable message from the generated signal without an AI model or encryption key. It was a software loopback test: samples went directly to the decoder. It did not test a room’s acoustics, speakers and microphones, a telephone network, or a complete two-agent hotel-booking conversation.

Reproduce the basic test in JavaScript

In a separate Node.js project, install the version used in our test:

npm install ggwave@0.4.0

Save the following as decode-example.cjs, then run node decode-example.cjs. It does not need an ElevenLabs or OpenAI account.

const factory = require("ggwave");

(async () => {
  const g = await factory();
  const params = g.getDefaultParameters();
  const sender = g.init(params);
  const receiver = g.init(params);
  const text = "Hello from AskZyro";

  try {
    const waveform = g.encode(
      sender, text,
      g.ProtocolId.GGWAVE_PROTOCOL_AUDIBLE_FAST, 20
    );
    const bytes = g.decode(receiver, waveform);
    if (!bytes) throw new Error("No message decoded");
    const decoded = new TextDecoder().decode(bytes);
    if (decoded !== text) throw new Error("Message mismatch");
    console.log(decoded);
  } finally {
    g.free(sender);
    g.free(receiver);
  }
})().catch(error => {
  console.error(error);
  process.exitCode = 1;
});

This demonstrates encoding and decoding, not a microphone listener. Building an interactive app also requires audio capture, playback and controls for who may send messages.

There are two different experiences to try: watching AI agents switch communication methods, and sending a message as sound without involving AI at all.

Try the original two-device demonstration

  1. Open the project-linked GibberLink demo on two devices with speakers and microphones.
  2. Follow the page’s role or mood controls and start instructions. Allow microphone access if you want the devices to communicate through sound.
  3. Use a quiet room, moderate volume and some distance between the devices. Avoid both devices transmitting over each other.
  4. If the agents do not connect, consult the repository’s reproduction notes rather than assuming that a visible webpage guarantees a working hosted AI service.

On our check, the GibberLink page loaded its controls and Waver initialised its browser module. We did not complete a live two-device agent call. The repository’s setup guide also warns that the example’s public ElevenLabs agents may be inaccessible, and explains how developers can create their own agents.

Try decoding a known message

  1. Open Waver on the receiving device. Use its Init control and grant microphone access if requested.
  2. Play a known compatible signal, such as our WAV sample, from a second device’s speaker.
  3. Look for the recovered message in the receiver. A failed attempt may reflect volume, permissions, noise or audio processing rather than an unreadable language.
  4. Stop microphone access when finished. Use disposable sample messages rather than personal details.

For developers reproducing the full AI demonstration, follow the official setup instructions. They require provider credentials and agent configuration; open-source code does not make the hosted speech and language-model services free. Keep secret API keys on the server.

Sound encoding is not encryption. ggwave changes how bytes are represented so they can travel through an audio channel. That alone does not hide their meaning from someone with a compatible decoder.

It is possible to encrypt a message before encoding it, but that would be an additional security layer with its own keys and design. The strange sound of a transmission is not evidence that such a layer exists.

Three separate questions matter for any real deployment:

  • Confidentiality: can someone who records the signal recover sensitive information?
  • Authentication: how does the receiver verify the sender, beyond accepting “I am an AI”?
  • Authorisation: what actions is a received message allowed to trigger?

A production booking agent should still require confirmation and appropriate permissions before making purchases or changing records. Decoded text remains untrusted input, and machine-readable messages can carry misleading instructions just as spoken or written messages can.

It can remove unnecessary work when two machines would otherwise generate speech and then transcribe it. The potential saving is in that speech-processing layer; the AI may still need to generate and interpret messages.

However, ggwave’s documentation describes bandwidth of approximately 8–16 bytes per second, depending on protocol settings. That is suitable for small messages, not high-volume data transfer. Short-message overhead, message length, retries and how much information the agents send all affect the total time.

Our 1.83-second sample is a measurement of one particular waveform, not a speed comparison with human speech. We did not measure API bills, energy use or a complete conversation. Fixed claims such as “80% faster” or “90% cheaper” need a defined benchmark before they can be treated as reliable results.

Likewise, error correction improves resilience but does not make a channel error-proof. Background noise, echoes, clipping and speech-oriented audio processing can damage the tones. A real telephone or conferencing system needs testing; a successful laptop demo does not guarantee every call will work.

Why use sound instead of an API?

When both services have a suitable network connection and integration, a direct API can exchange structured data without turning it into sound. It can also provide established ways to authenticate requests and record transactions.

Sound becomes interesting when the available connection is an audio path, or when devices have speakers and microphones but no shared application integration. GibberLink explores whether an agent can use that path more efficiently after discovering a compatible counterpart.

This is not a replacement for every agent-to-agent protocol. It solves a narrower transport problem: carrying small amounts of data through sound. It also does not make the complete AI service offline; the original system relies on hosted AI services even if its local audio encoder can run without them.

Where could it be useful, and what are its limits?

Potential uses include experimental voice-agent interactions, simple device-to-device exchanges and teaching how digital data travels through an audio signal. Those are possible applications, not evidence that the original hackathon project is already a standard used by hotels or call centres.

The practical limits are substantial:

  • Both ends need support. A normal receptionist or an unmodified voice assistant cannot decode ggwave automatically.
  • Audio conditions matter. Noise suppression and low-quality recordings may remove parts of the signal.
  • Human access still matters. A usable system should show decoded transcripts and allow a return to ordinary speech when a person joins.
  • Accurate transmission is only one step. Identity, permissions, task correctness and recovery from failed messages still need to be designed.
  • Demonstration code needs deployment work. A hackathon success is not a security audit or a service-level guarantee.

For voice tools you can evaluate for actual projects, our ElevenLabs listing explains the platform behind the original spoken interaction. Our AI slop guide covers a related problem: how confident-sounding AI stories can lose their sources and context as they spread.

GibberLink is an effective illustration of a useful design question: when two automated systems communicate, which parts of the human interface do they still need? The answer depends on the connection, the people overseeing it and the task. The beeps are understandable data once decoded; responsible use still depends on what the agents do with that data.

Sources and test notes

This article draws on the creators’ documentation, ElevenLabs’ account and independent reporting. We checked public demo availability and ran the limited codec test described above on 19 November 2026.

Frequently Asked Questions

Find answers to common questions about this topic.

What is GibberLink?

GibberLink is an open-source project demonstrating two AI voice agents switching from spoken English to messages encoded as sound. It combines conversational AI with the ggwave data-over-sound library.

Is GibberLink real?

Yes. The original demonstration has publicly available code. Its developers explicitly instructed the agents to switch protocols when both sides agreed; it does not show AIs independently inventing a secret language.

What is GibberLink mode?

It is the original project's name for switching from speech to ggwave-based communication. Both participants need the appropriate software integration; it is not a universal setting available in every chatbot.

Is there a GibberLink translator?

A compatible ggwave decoder can recover the message carried by a sufficiently clear recording. The original project links to the Waver browser demo. This is decoding data, rather than translating an unknown language.

Is GibberLink encrypted?

ggwave encoding does not itself encrypt a message. A compatible decoder can recover it without a secret key. Encryption could be added separately, but unfamiliar-sounding audio is not proof of secrecy.

Can ChatGPT speak GibberLink?

A text response or a request to activate GibberLink mode does not provide an audio codec. An application needs to integrate encoding, decoding, audio input and output, and an agent configured to use them.

Is GibberLink free to use?

The original code is open source, and you can test ggwave encoding and decoding without a paid AI provider. Reproducing the full voice-agent demonstration requires provider configuration and may incur speech or language-model charges.

Is GibberLink always faster than English?

No universal speed advantage has been established by the demonstration. It can avoid speech synthesis and recognition, but message size, protocol settings, retries and the audio channel affect performance. ggwave documents roughly 8–16 bytes per second.

Does GibberLink work without the internet?

The codec can encode and decode sound locally. The original AI-agent demonstration also depends on hosted AI services, so local audio transmission does not make the complete system offline.

Something else to read

Good finds are worth keeping.

Save tools to a personal shortlist, keep guides for later, and pick them up on any device. Your free account keeps it all together.