(And Today You’ll See How Easy It Is to Run ASR Service Locally)

Up to now, your EchoKit has worked with Whisper via Groq, and Whisper via OpenAI.

Today, we’re taking a major step forward—your EchoKit will run fully local ASR using Whisper + WasmEdge.

No cloud requests. No latency spikes. No API keys. Everything runs on your own machine, giving you full control over privacy, performance, and cost.

Whisper is an amazing ASR model. Let’s get your local Whisper server running and connect it to EchoKit.

You can also use other tool to run whisper locally as long as the API server is OpenAI-compatible.

Run the Whisper model locally​

1. Install WasmEdge​

Open your terminal and run:

curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install_v2.sh | bash -s

This installs WasmEdge along with all base components.

2. Install the Whisper Plugin (wasi-nn-whisper)​

My computer is a Mac with Apple Silicon, so I will download the whisper plugin using the following command lines

# Download the whisper plugin
curl -LO https://github.com/WasmEdge/WasmEdge/releases/download/0.14.1/WasmEdge-plugin-wasi_nn-whisper-0.14.1-darwin_arm64.tar.gz

# Extract into the WasmEdge plugin directory
tar -xzf WasmEdge-plugin-wasi_nn-whisper-0.14.1-darwin_arm64.tar.gz -C $HOME/.wasmedge/plugin

For other platforms, please refer to Quick Start with Whisper and LlamaEdge

3. Download the Portable Whisper API Server​

This app is just a .wasm file — lightweight (Size: 3.7 MB) and cross-platform.

curl -LO https://github.com/LlamaEdge/whisper-api-server/releases/download/0.3.9/whisper-api-server.wasm

4. Download a Whisper Model​

You can browse models here:

https://huggingface.co/ggerganov/whisper.cpp/tree/main

Today we’ll use the medium model:

curl -LO https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-medium.bin

5. Start the Whisper API Server​

Run Whisper locally:

wasmedge --dir .:. whisper-api-server.wasm -m ggml-medium.bin

You’ll see:

Server started on http://localhost:8080

This server is OpenAI API compatible, so EchoKit can use it directly.

Connect EchoKit to Your Local Whisper Server​

Update your config.toml and locate the asr section:

[asr]
provider = "http://localhost:8080/v1/audio/transcriptions"
api_key = "sk-xxxx"
lang = "en"
model = "whisper"

Yes, you only need to replace the endpoint.

Restart the EchoKit server, pair your device, connect the EchoKit server to the device, and speak.

If you want to share your experience or see what others are building with EchoKit + local whisper:

• Join the EchoKit Discord
• Or share your latency tests, setups, and experiments — we love seeing them

Want to get your own EchoKit device?

• EchoKit Box
• EchoKit DIY Kit

(And Today You’ll See How Easy It Is to Switch ASR Providers in EchoKit)

Over the past few days, we’ve powered up EchoKit, run your own EchoKit server locally, customized the boot screen, crafted your own welcome voice and connected it to Groq Whisper for fast speech recognition.

Today, we’re switching things up — literally.

We’ll configure EchoKit to use Whisper from OpenAI as the ASR provider.

Not because one is “better,” but because EchoKit is designed to be modular, letting you plug in different ASR backends depending on your workflow, API preferences, or costs.

What's the difference between OpenAI Whisper and Groq Whisper?​

Groq Whisper and OpenAI Whisper are based on the same open-source Whisper model.

What differs is the hosting:

• Groq runs Whisper on its custom LPU hardware (very fast inference).
• OpenAI runs Whisper on their internal infrastructure with its own rate limits and pricing.
• Both will return slightly different results based on their pipeline design and updates.

This isn’t a “which is better” comparison. It’s about understanding your options, and EchoKit makes switching between them smooth and flexible.

And many developers already use OpenAI for other AI tasks, so trying its Whisper API can be convenient. EchoKit adopts multi-provider ASR architecture.

Today’s goal is simple: 👉 See how easy it is to switch providers while keeping the same Whisper model.

How to Use OpenAI Whisper​

Now let’s switch EchoKit’s ASR provider.

Open your config.toml and locate the [asr] section. Replace it with:

[asr]
provider = "https://api.openai.com/v1/audio/transcriptions"
api_key = "sk-xxxx"
lang = "en"
model = "whisper-1"

A quick breakdown:

• [asr] — we’re configuring the ASR section
• url — Openai’s Whisper endpoint for transcriptions
• lang — your preferred language (en, zh, ja etc.)
• api_key — the key obtained from OpenAI API plaform
• model — OpenAI's supported ASR models (whisper-1 or gpt-4o-transcribe, gpt-4o-mini-transcribe,)

Save → restart your EchoKit server with Docker or from the source code → done.

EchoKit is now using OpenAI Whisper for real-time speech-to-text. The rest of your pipeline (LLM → TTS) stays the same.

You can follow the same process to reconnect the server and your EchoKit device.

EchoKit’s ASR system was built to support all OpenAI-compatible provider — so feel free to try different providers, compare results, and find what works best for your setup.

If you want to share your experience or see what others are building with EchoKit + OpenAI:

• Join the EchoKit Discord
• Or share your latency tests, setups, and experiments — we love seeing them

Want to get your own EchoKit device?

• EchoKit Box
• EchoKit DIY Kit

(Today, your EchoKit learns to understand you—faster and sharper.)

By now, you’ve powered up EchoKit, run your own EchoKit server locally, customized the boot screen, crafted your own welcome voice, and started shaping your very own voice AI companion.

Today, we’re upgrading something fundamental: how your EchoKit listens to you. In any voice AI agent, ASR is the very first step — it’s how your device hears you before it can think or speak back.

One of the best parts of EchoKit being open source voice AI agent is that you can plug in whatever ASR–LLM–TTS pipeline works best for your needs. And for many makers, developers, and tinkerers, Groq has become the go-to for ultra-fast voice recognition.

So on Day 6, you’ll learn how to integrate Groq with EchoKit and feel that speed boost every time you press the K0 button and start talking.

Let’s dive in.

Why Groq? (And Why Today Feels Like a Power-Up)​

If you’ve never tried Groq before, prepare to be surprised. Groq is known for delivering extremely low-latency inference. When we tested it, the difference was obvious — conversations felt snappier, more natural, and closer to real-time.

Adding it to your EchoKit means:

• Faster voice-to-text recognition
• More responsive conversations
• A smoother ASR-LLM-TTS pipeline
• And honestly… it just feels good seeing your device level up

Today is about giving your device better ears.

Step 1 — Get Your Groq API Key​

Head to the Groq console (https://console.groq.com/keys) and sign up if you’re new.

Click + Create API Key, give it a name, and copy it somewhere safe — it won’t be shown again.

This key is what lets your EchoKit talk to Groq securely.

Step 2 — Apply the Groq ASR Settings to Your EchoKit Server​

Open your config.toml file inside your EchoKit Server (Docker or Rust build).

We’re going to tell EchoKit: “Hey, use Groq Whisper as my ASR engine.”

Paste the following:

[asr]
url = "https://api.groq.com/openai/v1/audio/transcriptions"
lang = "en"
api_key = "YOUR_GROQ_API_KEY_HERE"
model = "whisper-large-v3-turbo"

A quick breakdown:

• [asr] — we’re configuring the ASR section
• url — Groq’s Whisper endpoint
• lang — your preferred language (en, zh, ja etc.)
• api_key — the key you generated
• model — Groq’s supported Whisper models (whisper-large-v3 or whisper-large-v3-turbo)

EchoKit follows OpenAI-style specs, so you’re free to replace Groq with other providers later if you want, which we will learn in the upcoming days. This flexibility is part of what makes EchoKit… EchoKit.

Now restart your EchoKit server using Docker or Rust code. You’re done on the server side!

Step 3 — Connect the Updated Server to Your EchoKit Device​

Head to https://echokit.dev/setup/ and rebind the server if needed.

If nothing changed except your ASR configuration, you can simply press the RST button on your EchoKit to restart it and sync the new settings.

If your server URL or WiFi setup changed, you can reconfigure them through the setup page — just like you did on Day 1.

Now comes the fun part.

Press the K0 button and start speaking.

You’ll feel the difference immediately — the Groq Whisper model picks up your words almost as soon as you say them.

Your EchoKit just got better ears. Remember to check the logs to see how long Groq’s Whisper took to transcribe the audio.

Today’s upgrade brings more speed and responsiveness, setting the stage for a deeper dive into the EchoKit server in the upcoming days.

If you want to share your experience or see what others are building with EchoKit + Groq:

• Join the EchoKit Discord
• Or share your latency tests, setups, and experiments — we love seeing them

Want to get your own EchoKit device?

• EchoKit Box
• EchoKit DIY Kit

(And Today, Your EchoKit Greets You in Your Own Voice!)

By now, you’ve powered up EchoKit, run the server (via Docker or from source), and even customized the boot screen.

Today, we’re taking it one step further: giving your EchoKit a personalized welcome voice.

It’s a simple tweak, but it instantly transforms your device into a Voice AI agent with its own character — a tiny AI companion that greets you the way you like.

Create Your Own Voice​

Your welcome sound can be anything you want:

• Your own recorded voice
• A short greeting phrase
• Even a favorite piece of music

Just make sure your audio file meets these requirements:

• WAV format
• 16 kHz sample rate

You can quickly convert audio to 16 kHz using the online tool or FFmpeg:

ffmpeg -i input.mp3 -ar 16000 output.wav

💡 Pro Tip: This is a great opportunity to give your EchoKit a special gift — a voice that makes it uniquely yours!

Set Up Your Custom Welcome Voice​

To apply your custom sound, run your EchoKit Server (Docker or compiled binary).

If your device was previously set up, reset it first:

• Press the RST button
• Immediately press the K0 button until the QR code shows

Then, open your config.toml file and look for:

addr = "0.0.0.0:8080"
hello_wav = "hello.wav"

Replace hello.wav with your own file path, for example:

addr = "0.0.0.0:8080"
hello_wav = "my_welcome.wav"

Restart your EchoKit server using Docker or [from the Rust source code]((https://echokit.dev/docs/dev/echokit-30-days-day-3-rust).

Then, connect the echokit server and the device via https://echokit.dev/setup/ page.

If your server URL and Wifi setting didn't change, you can simply restart the device by pressing the rst button.

After that, when you press the K0 button to start a conversation, your EchoKit will greet you with your very own welcome sound. 🎶

Why This Matters​

A custom welcome voice turns EchoKit from a generic device into your personal AI companion. Every interaction feels more natural, more fun, and more expressive — like it really knows you.

Whether it’s a playful hello, a soothing greeting, or a quirky sound effect, this is a special gift you give to yourself and your device.

Want to get your EchoKit Device and make it unique?

• EchoKit Box
• EchoKit DIY

Join the EchoKit Discord to share your creative welcome voices and see how others are personalizing their Voice AI agents!

(And Today, EchoKit Gets a Personality of Its Own)

In the last three days, we powered up EchoKit, connected it to a local server, and even built the server from source. But today… we’re making it truly yours.

Today, we’re going to customize the boot screen. Think of it as EchoKit’s wardrobe — the first thing you see when it wakes up. And yes, you can "decorate" it as quirky, cute, or technical as you like.

🌱 Why Customize the Boot Screen?​

Sure, the default boot screen with the EchoKit logo works fine. But customizing it gives you:

• A personal touch — your EchoKit looks exactly how you want it
• An instant “wow” moment every time it starts
• A glimpse into how flexible and hackable your device really is

Step 1 — Design Your GIF​

Depending on your EchoKit model, use your favorite image editor to create a GIF:

• EchoKit Box: 360 × 240 px
• EchoKit DIY: 240 × 240 px

Keep the GIF under 15 KB so it loads smoothly.

Step 2 — Pair Your EchoKit Device​

Go to https://echokit.dev/setup/ and click Connect to Your EchoKit.

Make sure your device shows the QR code page. If it doesn’t:

1. Press the RST button
2. Hold the K0 button until the QR code appears

Now your computer and EchoKit are ready to talk.

Step 3 — Upload Your GIF​

Scroll down to Set Background, upload your GIF, and click Set Background.

Pro Tip: It may take a few seconds to apply, so don’t panic if nothing changes instantly.

Step 4 — Save and Restart​

Finally, click Save Configuration. Your EchoKit will restart, and… voilà! Your custom boot screen is now the first thing it shows when it wakes up.

Today, EchoKit isn’t just a voice assistant or a server anymore — it’s your EchoKit.

(And Today I Finally Saw How EchoKit Works Under the Hood)

In the last two days, we powered up the EchoKit, made it talk, and connected it to a local EchoKit server using Docker. But today feels different.

Today, we’re going to build the EchoKit Server from source. No containers. No abstraction layers. Just you… and the real engine that drives EchoKit.

🌱 Why Build EchoKit from Source?​

Using Docker is great for quick setup. But building from source unlocks more possibilities:

• Get the latest code, newest features, and bug fixes
• Modify the server freely — add your own logic, prompts, or integrations
• Compile to any platform you want
• Truly understand how EchoKit works under the hood

If Day 1 was about getting EchoKit to speak, and Day 2 was about hosting your own server, then Day 3 is where you start becoming an EchoKit developer.

Step 1 — Install the Rust Toolchain​

Since the EchoKit server is written in Rust, so all the dependencies is the Rust toolchain.

Refer to the official Rust website to install Rust.

Step 2 — Get the Source Code​

In your terminal:

git clone https://github.com/second-state/echokit_server.git
cd echokit_server

And there it is — the heart of the EchoKit server, right on your machine.

It's recommended to use an IDE like VSCode to open the echokit_server folder.

🔧 Step 3 — Configure the Server​

Open the config.toml file and fill in:

addr = "0.0.0.0:8080"
hello_wav = "hello.wav"

[tts]
platform = "Elevenlabs"
token = "sk_1234"
voice = "pNInz6obpgDQGcFmaJgB"

[asr]
url = "https://api.groq.com/openai/v1/audio/transcriptions"
api_key = "gsk_1234"
model = "whisper-large-v3"
lang = "en"
prompt = "Hello\n你好\n(noise)\n(bgm)\n(silence)\n"
vad_url = "http://localhost:8000/v1/audio/vad"

[llm]
llm_chat_url = "https://api.groq.com/openai/v1/chat/completions"
api_key = "gsk_1234"
model = "openai/gpt-oss-20b"
history = 15

[[llm.sys_prompts]]
role = "system"
content = """
You are a helpful assistant. Answer truthfully and concisely. Always answer in English.
"""

Just like yesterday's setup, and remember to bring your own API key for Groq and ElevenLabs.

⚡ Step 4 — Build the Server​

Compile it using Cargo:

cargo build --release

The first build may take a bit, since Rust compiles everything from scratch.

But once you see:

Finished release [optimized] target(s)

you officially have your own EchoKit server binary.

🏃 Step 5 — Run the Server​

Start with debug logging:

export RUST_LOG=debug

Then launch:

nohup target/release/echokit_server &

You should see something like:

[1] 67869
appending output to nohup.out

All logs are saved in nohup.out, so you can monitor everything that happens inside your server.

🏃 Step 6 — Connect the Server​

Next, it's time to connect your EchoKit server to your device following this guide.

The EchoKit Server runs as a WebSocket service.

Your EchoKit device will connect using a URL like:

ws://YOUR_IP_ADDRESS:8080/ws

For example:

ws://192.168.1.23:8080/ws

⚠ Do NOT use localhost or 127.0.0.1. Your EchoKit device connects over Wi-Fi and cannot reach your computer’s local loopback address.

Once you enter this WebSocket URL into the EchoKit web dashboard, your device will connect to the server you built with your own hands.

Today, you didn’t just run EchoKit. You built the server. You opened the code. You compiled it. You took full control.

From now on, you’re not just a user — you’re a builder.

Tomorrow, in Day 4, we’ll dive into one of the most fun parts:

Customizing your EchoKit’s welcome screen. This is the beginning point where EchoKit truly becomes yours.

(Today, I take control of my EchoKit )

Yesterday, after getting started with EchoKit, it could finally talk back to us.

Today, we’re taking it one step further—connecting it to an EchoKit Server running on your own computer to make it truly come alive.

Honestly, this step gave me a really special feeling: "Wow, this little guy is actually talking to my computer." Not an official server, not a third-party platform—just my own local environment, my own AI workflow. It felt a bit like lighting up my first LED: simple, yet surprisingly meaningful.

✨ Why running your own EchoKit Server is so important

Once EchoKit Server is running locally, you can:

• Fully customize ASR, TTS, and LLM
• Swap AI models, change voices, tweak system prompts
• Add an MCP server or integrate your own toolchains
• Later, even enable command control or Home Assistant integration

These features will be covered in more detail in upcoming EchoKit30Days articles. Stay tuned!

At this point, EchoKit stops being just a “factory robot.” It starts becoming your AI companion—with the personality you shape and the skills you create.

There're two ways to run EchoKit server locally. One is Docker, the other one is to use rust compiler. However, Docker is the simplest and most recommended way because you don’t have to worry about environment setup.

Step 1 — Edit your config.toml​

First, we will need to create a config.toml file in your root folder.

The config.toml is the “soul file” of your EchoKit Server. It decides which AI model, which voice, and how your EchoKit talks. Today, we’ll use services from Groq and ElevenLabs for a starter configuration:

addr = "0.0.0.0:8080"
hello_wav = "hello.wav"

[tts]
platform = "Elevenlabs"
token = "sk_1234"
voice = "pNInz6obpgDQGcFmaJgB"

[asr]
url = "https://api.groq.com/openai/v1/audio/transcriptions"
api_key = "gsk_1234"
model = "whisper-large-v3"
lang = "en"
prompt = "Hello\n你好\n(noise)\n(bgm)\n(silence)\n"
vad_url = "http://localhost:8000/v1/audio/vad"

[llm]
llm_chat_url = "https://api.groq.com/openai/v1/chat/completions"
api_key = "gsk_1234"
model = "openai/gpt-oss-20b"
history = 15

[[llm.sys_prompts]]
role = "system"
content = """
You are a helpful assistant. Answer truthfully and concisely. Always answer in English.
"""

Remember to replace the API keys with your own.

Step 2 — Launch EchoKit Server with Docker​

Make sure you have Docker Desktop installed and the Docker engine running.

docker run --rm \
  -p 8080:8080 \
  -v $(pwd)/config.toml:/app/config.toml \
  secondstate/echokit:latest-server-vad &

This command will run the server on the 8080 port.

Step 3 — Connect EchoKit to your Server**​

Next, connect your EchoKit device to the server. If you’ve followed Day 1 to make your EchoKit speak, you will need to reset your device.

1. Press the RST button
2. Hold K0 until the QR code reappears

Then, go to the setup page and enter your Wi-Fi name, password, and server URL in the format of ws://789.123.3.45:8080/ws.

The server URL should be your IP address starting with 192.168. Go to WiFi setting to get the IP address.

Suddenly, your little AI starts working exactly the way you configured it: Your Groq model, your ElevenLabs voice, your system prompt.

That moment really feels like… you’ve trained it yourself.

Many of our customers have already received their EchoKit, ready to explore the fascinating world of voice AI. To help you become a Voice AI agent master, we’re kicking off the First 30 Days with EchoKit journey, which works for both EchoKit DIY and EchoKit Box users.

Day 1 is all about one exciting milestone: hearing your EchoKit speak for the very first time. That small device in your hands, quiet and unassuming just moments ago, is about to come alive.

Wondering about Day 0? If you have a DIY EchoKit, assemble it first.

Step 1: Power Up Your EchoKit​

The adventure begins the moment you connect your EchoKit to power:

1. Use the USB Type-C data cable to connect EchoKit to your computer or a power source.

2. Watch as the device awakens — you should see a QR code appear on the screen.

3. Can’t see the QR code? Don’t worry:

   • Click the RST button to restart.
   • Immediately press and hold the K0 button until the QR code appears.

There it is—the first sign that your EchoKit is coming to life. That tiny screen, those subtle lights—they mark the start of a new AI companion ready to talk to you.

Step 2: Connect EchoKit to Your Computer​

Next, it’s time to introduce your EchoKit to the digital world:

1. Open a web browser (Chrome is recommended) on your desktop and go to: 👉 https://echokit.dev/setup/
2. Click Connect to EchoKit to start pairing.

With this connection, your EchoKit AI assistant is ready to listen, respond, and learn. This small device is no longer just hardware—it’s now a voice AI companion that can interact with you in real time.

Step 3: Configure Wi-Fi and Server​

Once paired, the setup interface will appear. This is where your EchoKit truly becomes yours:

1. Enter the following details:

   • Wi-Fi Network: Your 2.4G Wi-Fi name

   • Wi-Fi Password: Your access code

   • EchoKit Server: Choose a pre-set server for a fast connection:

     • 🇺🇸 US: ws://indie.echokit.dev/ws
     • 🇪🇺 EU: ws://eu.echokit.dev/ws (Outside these regions? The response may be slower, but it will still work.)

2. Click Write for each field.

3. Once finished, press the K0 button on EchoKit.

With every step, you’re not just configuring a device—you’re preparing for your first conversation with your AI companion.

Step 4: Confirm Setup on EchoKit​

After configuration, your EchoKit will:

• Display a welcome screen
• Play a voice greeting: “Hi there”

This is the moment you’ve been waiting for. Your EchoKit voice AI is now awake and ready. Take a moment to appreciate it—it’s listening, responding, and ready to become part of your daily life.

Step 5: Start Chatting​

Now comes the fun part: your first conversation with EchoKit.

1. Press the K0 button to start. The status bar will show “Listening …”.
2. Speak to your EchoKit and enjoy its responses.
3. If the status shows “Idle” or “Speaking”, use the K0 button to start or interrupt as needed.

Every question, every command, every interaction is a small discovery. This is the start of your voice AI journey, where your EchoKit learns, adapts, and surprises you with each conversation.

💡 Tip for Day 1: Today is about enjoying your first interaction and getting familiar with your AI companion. Tomorrow, we’ll explore customizing EchoKit’s voice and personality, making it uniquely yours.

A bigger screen. A cleaner design. A more powerful EchoKit.

We’re excited to introduce EchoKit Box, the newest member of the EchoKit family — built for makers, educators, and anyone exploring voice AI Agent.

EchoKit Box keeps everything people love about EchoKit, but elevates the hardware, polish, and usability in every way.

Full-Front 2.4-inch OLED Display​

One of the most visible upgrades in EchoKit Box is its large full-front screen.

The entire front of the device is a high-contrast 2.4-inch OLED display, perfect for:

• System information
• Voice activity visualization
• Playing videos stored on the TF card
• Displaying graphics and custom UI
• MCP-driven animations

Unlike the previous EchoKit generation, the visual feedback is clearer and more interactive, making this device suitable for both teaching and advanced AI projects.

Clearly Labeled Buttons (Including K0 and Reset)​

Many users struggled to find the K0 button and reset button on the previous EchoKit DIY model. EchoKit Box solves this by placing integrated, clearly labeled buttons at the top of the device.

Clear hardware labeling = less confusion and faster development.

TF Card Slot for Media and Local AI Workflows​

At the bottom of the device, you’ll find a TF card slot. You can store:

• Music
• Videos
• Offline content
• Custom datasets

And here’s where the fun begins:

You can ask the large language model to generate MCP actions that play music or video stored on the TF card — directly on the device.

That means you can say: “Play the music on my memory card.” And the device will play it through the speaker.

More Connectors for Additional Modules​

On the side of the EchoKit Box, you’ll find two colored connectors (blue and red). These are expansion ports for sensors and modules, such as:

• Temperature sensors
• Cameras
• LED light modules
• GPIO-based sensors
• Custom peripherals

Using MCP actions, the large language model can control these modules:

• “Turn on the camera and take a picture.”
• “Read temperature from the blue port sensor.”
• “Switch on the LEDs.”

EchoKit Box becomes your modular AI platform, not just a single device.

Transparent Back With Visible Electronics​

The back of EchoKit Box features a clear, transparent cover, allowing you to see:

• The ESP32 CPU
• PCB and circuitry
• Speaker
• Microphone
• Components such as power regulators and drivers

Makers, students, and hardware enthusiasts love this design because it shows exactly how the AI device works internally.

This is especially useful for:

• STEM education
• AI education
• AI Hardware demos
• AI workshops
• DIY repair and customization
• Special gifts for developers

Why We Love the New EchoKit Box​

After months of iteration, we truly believe EchoKit Box is the most advanced EchoKit we’ve ever built:

• Bigger 2.4-inch display
• Better enclosure and build quality
• Clear hardware labeling
• TF card slot
• More connectors for sensors and modules
• Transparent back in geek style for education
• Dual USB ports for firmware flashing
• Great speaker/mic setup
• Fully open-source and ESP32 powered
• Works perfectly with local LLMs and MCP actions

It’s a hackable voice AI device that’s also polished enough for demos, classrooms, hackathons, and real projects.

Final Thoughts​

We’re really proud of the new EchoKit Box, and we think you’ll love building with it.

Whether you’re experimenting with conversational AI, creating an embedded chatbot, teaching students about LLMs, or building robotics projects with sensors, this device gives you everything you need.

Stay tuned — more updates, tutorials, and expansion modules are coming soon.

Have you ever wondered what your AI would sound like with a Southern drawl or a confident Texas accent?

Until now, these premium voices were paid add-ons — but now you can try them for free on the EchoKit web demo.

We’ve added diverse, natural accents including Southern, Asian, African-American, New York, and Texas English, bringing more authenticity and cultural depth to your conversations.

Each voice is expressive and warm, built to sound like a real person rather than a robotic assistant.

No installation or payment needed — just open the EchoKit web demo and start exploring: https://funvoice.echokit.dev/

How to Play 🎤​

1. Open https://funvoice.echokit.dev/ in your browser.
2. Choose the accent you want to try from Cowboy, Diana, Asian, Pinup, or Stateman.
3. Allow the website to access your microphone when prompted.

4. Click on Start Listening.
5. Once you see “WebSocket connected successfully”, start talking to the character — it will respond in the selected voice!
6. If you just want to listen, click Stop Listening to pause microphone input.

How Did We Make It 🎛️​

Want something truly personal?

EchoKit is an open-source voice AI agent that lets you customize every aspect of both the hardware and software stack. One of the most popular features is Voice Clone — you can even clone your own voice!

Ready to create a truly personal AI voice? Learn how to do it here: Voice Cloning Guide.

From Browser to Device​

Once you’ve experimented in the browser, you can take it even further.
EchoKit lets you play with these voices locally, on-device, even using your own voice.
Perfect for makers, educators, and AI hobbyists who want full control and real-time interaction.

🎧 Try the voices → https://funvoice.echokit.dev/
🛠️ Get your own EchoKit device → https://echokit.dev/

EchoKit — the open-source Voice AI Agent that sounds just like you.

Have any questions? Join our Discord community