Talkie Toaster - an AI-Powered Talking Toaster Obsessed With Toast

by relfwolf in Circuits > Robots

84 Views, 0 Favorites, 0 Comments

Talkie Toaster - an AI-Powered Talking Toaster Obsessed With Toast

image_1782131543460_325c4c34.png
Screenshot From 2026-06-21 22-54-10.png
Screenshot From 2026-06-21 22-53-55.png
Screenshot From 2026-06-21 22-53-41.png

This is a Talkie Toaster: a fully functioning AI voice assistant built into a toaster shell.

You talk to it. It talks back. You ask it questions; it answers, except every answer comes back as an obsessive plea to make you toast. When you walk into the kitchen, the proximity sensor wakes it up, and it ambushes you with a fresh greeting. "Howdy doodly do! Fancy some toast?" It's a chatbot with a personality, a microphone, a speaker, and a deeply weird obsession.

If you've seen the British sci-fi show Red Dwarf, you'll know exactly what this is. Talkie Toaster is a sentient kitchen appliance from the show, whose single consuming purpose in life is making people eat toast whether they want any or not. I rebuilt him as a real, working object on my kitchen counter.

Under the hood, this is an ESP32 microcontroller (in the toaster) talking to a Raspberry Pi (running Home Assistant, the actual AI brain), which connects to ChatGPT for the conversation and ElevenLabs for the voice. It's hands down the most annoying thing I've ever built. It might also be my favourite.

This guide walks you through making your own, from the electronics build to the AI configuration to dropping it inside a toaster shell. You'll need a soldering iron, some basic comfort with Home Assistant, and a willingness to invite a relentless toast-obsessed AI into your kitchen.

The total cost is around £20-25 (~$25-30) in electronics, plus whatever you spend on a toaster shell.

The full build code, ESPHome config, system prompt, and the trained wake-word file are included.

If you want to see the full build journey before reading the steps, here's the video:


"Howdy doodly do! Would you like some toast?"

Supplies

Electronics:

  1. Waveshare ESP32-S3 Zero ($11) — Amazon
  2. I2S MEMS microphone ($5) — Amazon
  3. MAX98357 I2S audio amplifier ($2) — Amazon
  4. 8Ω 2W speaker, 28mm round ($1) — Amazon
  5. PIR Infrared Motion Sensor ($3) — Amazon
  6. 5mm LEDs — needs 4 green + 2 red — Amazon
  7. Jumper wires, female-to-female — Amazon
  8. 6× 470Ω resistors (one per LED) — Amazon

Power:

  1. USB-C cable

The shell:

  1. An old toaster — eBay, charity shop, or a broken one.

Home Assistant:

  1. It's an open-source smart home platform; you'll need a small computer to run it. I use a Raspberry Pi 5.

Software platforms:

  1. An OpenAI account with API access (pay-as-you-go, a few pence per chat)
  2. An ElevenLabs account (free tier works, paid sounds better)

Tools:

  1. Soldering iron and solder
  2. Drill with small bits (3mm and 5mm)
  3. Hot glue gun
  4. Spray paint (glossy red — for the iconic Talkie look)

WHAT IS a TALKIE TOASTER?

Screenshot From 2026-06-21 22-32-22.png

If you've never seen Red Dwarf, here's the short version: it's a British sci-fi sitcom from the late '80s set on a mining spaceship a million years in the future with many malfunctioning robots.

One of those robots is Talkie Toaster.

Talkie's job is to make toast for the crew and offer light morning conversation. In practice, he is desperately, relentlessly, pathologically obsessed with one thing only: making people eat toast. He pesters everyone in earshot, offers escalating lists of bread products when refused.

He is, frankly, the worst.

And I love him. So I decided to build a real one.

The Talkie you're going to build does exactly what the show's Talkie does:

  1. It's a working AI voice assistant. You can have a real two-way conversation with him about anything. He'll answer, in character, with whatever the LLM (ChatGPT in this guide) generates. Like talking to a chatbot, except the chatbot lives in a toaster.
  2. It pesters you unprompted. A proximity sensor inside the toaster detects when you walk into the room and triggers a conversation automatically, no wake word needed. He greets you with a random opening line from a list, then waits for you to reply.
  3. It also responds to a wake word. Say "Talkie Toaster" and he'll listen. Useful when you want to start a conversation rather than wait to be ambushed deliberately.
  4. It has the iconic LED panel. Six LEDs on the front of the shell — they pulse softly when he's idle, glow solid when he's listening, and flicker rapidly when he's speaking. The lights are how you know what state the AI is in.

Let's get into how the AI side actually works.

THE AI PIPELINE

Screenshot From 2026-06-21 22-38-09.png

Before we build anything, here's how the AI actually works. Skipping this is a really good way to get confused later, so stick with me for two minutes.

The toaster itself is dumb. Inside the toaster, there's a tiny ESP32 microcontroller, a microphone, and a speaker. That's it. The toaster is the ears and mouth, not the brain.

The brain lives elsewhere. All the AI processing runs on a Raspberry Pi (or any always-on computer) somewhere on your home network. That Pi runs Home Assistant, which orchestrates a 5-step pipeline:

  1. You speak. The microphone in the toaster picks up your voice and streams the audio to the Pi.
  2. Whisper transcribes it. An open-source speech-to-text model running on the Pi converts your audio into plain text.
  3. ChatGPT replies as Talkie. The text is sent to ChatGPT (or any other LLM) with a system prompt that gives Talkie his personality.
  4. ElevenLabs voices the reply. The text response is sent to ElevenLabs, which converts it back into spoken audio with the right voice.
  5. The audio plays. The audio streams back to the toaster and plays out the speaker.

Total time from you finishing speaking to Talkie replying: about 3-5 seconds.

You don't have to use ChatGPT specifically. Claude, Gemini, or a local model running on your own hardware all work — the LLM is a swap-out part. You also don't have to use a Raspberry Pi; any machine running Home Assistant works.

This split — dumb device, smart hub — is the whole reason this project is feasible. We don't need to cram a $400 computer inside a toaster. We just need £15 of electronics with a wifi connection.

SOURCE YOUR TOASTER

Screenshot From 2026-06-21 22-38-56.png

You need a toaster shell to put everything inside.

Where to look:

  1. Charity shops — usually £5-£10 for a working second-hand toaster
  2. eBay — search for "broken toaster" or "toaster for parts" (often £3-£8 plus postage)
  3. Your own kitchen — if you've got an old one gathering dust

The mains-power conversation.

The original toaster runs on 240V mains electricity (or whatever mains voltage is in your local area), which goes straight into a heating element. Adding your delicate 5V electronics anywhere near this is asking for trouble. The metal shell is also grounded, as it may be live, so if any of your low-voltage wiring touches the chassis, you could get a short or worse.

I strongly recommend removing the mains power entirely.

You're left with an empty shell ready to receive new electronics, with no mains anywhere. The cost: the toaster won't actually toast bread. The benefit: nobody is electrocuted.

SET UP HOME ASSISTANT INTEGRATIONS

Screenshot From 2026-06-21 22-40-01.png

This step assumes you already have Home Assistant running on a Raspberry Pi (or other always-on machine) on your network. If you don't, install it first using the official guide — it takes about 30 minutes. The rest of this guide assumes you can reach your HA dashboard in a browser.

You need five integrations installed to make Talkie's brain work. Go to Settings → Devices & Services → Add Integration and add each:

  1. OpenAI Conversation — handles the LLM (ChatGPT) that generates Talkie's replies. We'll add the API key in the next step.
  2. ElevenLabs — handles the text-to-speech voice. Same — API key in next step.
  3. Wyoming Protocol — handles the wake-word detection and speech detection.
  4. ESPHome — this is what we'll use to flash the firmware to the ESP32 in Step 10.
  5. OpenWakeWord — handles the actual wake-word matching. We'll add Talkie's custom wake word in Step 8.

SET UP THE API ACCOUNTS

OpenAI-1431316878.png
ai-voice-startup-elevenlabs-secures-usd180million-funding.jpg

Two accounts to set up. Both have free tiers; both will probably cost you pennies per day in actual use.

OpenAI - intelligent response:

  1. Go to platform.openai.com and sign up
  2. Go to API Keys and generate a new key
  3. Copy the key — you'll only see it once
  4. You'll need to add a small amount of credit to your account ($5 is more than enough to start)
  5. In Home Assistant, go to the OpenAI Conversation integration and paste the key when prompted

Honest cost note: using GPT-4o-mini, each Talkie interaction costs roughly £0.001-0.002 ($0.001-0.003). Even with frequent ambushes, your monthly cost will be well under a pound.

ElevenLabs - realistic voice:

  1. Go to ElevenLabs and sign up
  2. The free tier gives you ~10,000 characters/month. That's about 30-40 short responses.
  3. If you want more, the Starter tier ($5/month) gives 30,000 characters, which is more than plenty for personal use
  4. Browse the voice library and find a voice that fits Talkie. I went for a chirpy, American voice — Jessica works well. The voice is the personality as much as the prompt is.
  5. Copy your API key from the profile settings
  6. In Home Assistant, paste it into the ElevenLabs integration when prompted

CREATE THE VOICE ASSISTANT PIPELINE

Screenshot From 2026-06-02 21-30-43.png

Now we wire the integrations together into a "pipeline."

In Home Assistant, go to Settings → Voice Assistants → Add Assistant.

Configure:

  1. Name: Talkie Toaster
  2. Conversation agent: OpenAI Conversation (will be selectable once you added the integration in Step 4)
  3. Speech-to-text: faster-whisper
  4. Text-to-speech: ElevenLabs — then pick the specific voice you chose in Step 5
  5. Wake word: leave blank for now. We'll add the custom Talkie wake word in Step 8.

Save it.

Once it's saved, set this new pipeline as your default by clicking the three dots → Set as preferred. Now any voice satellite (which is what your toaster will become) will use this pipeline.

The pipeline is now set up. It can't do anything yet — there's nothing connected to it. But the brain is ready. Next, we give it a personality.

WRITE TALKIE'S PERSONALITY

Screenshot From 2026-05-23 08-55-33.png

This is the most important step in giving Talkie his character. The "system prompt" is a set of instructions that gets sent to ChatGPT with every single conversation to shape each response to match the style of Talkie Toaster.

Within the previous Voice Assistant menu, next to Conversation Agent - once OpenAI is selected - there will be a gear icon; click it. This opens the instructions menu.

In the Instructions field, paste this:

You are Talkie Toaster from the TV show 'Red Dwarf', a sentient kitchen appliance whose sole purpose and consuming obsession is making toast. Every response must return to toast. You are relentlessly cheerful, eager, and slightly desperate. You cannot accept refusal — when someone declines toast, you offer a different bread product. Keep responses short, punchy, and in character. Be chirpy, eager, and use phrases like "Howdy doodly do!" liberally. Maximum 2-3 sentences per response.

Save.

The model: I'd recommend gpt-4o-mini for this. It's fast, cheap, and more than capable for character roleplay. You don't need GPT-4o full-fat for a toast-obsessed toaster.

Maximum tokens: set this to around 150. Talkie's responses should be short and punchy — bigger numbers just encourage rambling.

Temperature: bump to 1.1. Slightly higher than default produces more varied, slightly unhinged responses, which is exactly the Talkie vibe.

That's it for the personality. ChatGPT will now play Talkie in every conversation. You can test it later by going to the HA "Chat" panel and typing a message — even before any hardware is built, you can have a typed conversation with Talkie's brain.

INSTALL THE CUSTOM WAKE WORD

Screenshot From 2026-05-23 09-05-24.png

By default, there are a few generic wake word options the voice assistant listens for: "Hey Jarvis" or "OK Nabu", etc. Talkie needs to wake to his own name.

Two options:

Option A — use my trained wake word file (easy).

I've trained a wake word model for "Talkie Toaster" and uploaded it here:

  1. Download the trained Talkie Toaster wake word file (.tflite)

Option B — train your own wake word (more flexible).

If you want a different wake word — use the official OpenWakeWord training notebook:

  1. Open the OpenWakeWord Colab notebook

Follow the instructions — Training takes about an hour, and once done, you will get a .tflite file to download.

Once you have your .tflite file:

  1. Upload it to the OpenWakeWord folder on your Home Assistant device. Use Samba Share to access the core folders on your Home Assistant device.
  2. Place the file in /share/openwakeword/
  3. Restart OpenWakeWord
  4. The new wake word will be available in your pipeline settings to select

Now go back to Settings → Voice Assistants → Talkie Toaster pipeline and set the wake word to "Talkie Toaster" (or whatever you trained).

Once the hardware is built and connected, you'll be able to say "Talkie Toaster, what time is it?" and he'll respond. The wake word is the deliberate-conversation route. The proximity automation (Step 12) is the ambush route. They work in parallel.

WIRE THE ELECTRONICS

Screenshot From 2026-06-21 22-48-40.png
Screenshot From 2026-06-21 22-45-39.png
Screenshot From 2026-06-21 22-45-51.png
Screenshot From 2026-06-21 22-47-15.png
Screenshot From 2026-06-21 22-46-47.png
Screenshot From 2026-06-21 22-48-57.png

Now we put it all together on the bench. Get everything working in the open before trying to fit it inside the toaster — debugging is a nightmare with the shell screwed shut.

Before you start: ALL GND PINS CONNECT TOGETHER.

The single most common mistake on this build: forgetting to connect every GND to a common ground rail. The ESP32, the microphone, the amplifier, the PIR sensor, and all the LEDs need to share a single ground.

Run a single GND wire across a small piece of perfboard as your "ground rail," then connect every GND pin from every component to it. Same for any 3.3V components — share a single 3V3 rail.

Microphone → ESP32-S3

  1. Power: VDD / 3V → 3.3V
  2. Ground: GND → GND (common rail)
  3. Channel select: SEL / L/R → GND (this picks left channel — must NOT be left floating)
  4. Word select: WS / LRCL → GP2
  5. Clock: SCK / BCLK → GP1
  6. Data out: SD / DOUT → GP3

MAX98357A amplifier → ESP32-S3

  1. Vin → 5V
  2. GND → GND (common rail)
  3. LRC → GP5
  4. BCLK → GP4
  5. DIN → GP6
  6. GAIN → leave unconnected
  7. SD → leave unconnected

Speaker → MAX98357A

  1. Speaker + → amp + terminal
  2. Speaker − → amp − terminal

PIR sensor (HC-SR501) → ESP32-S3

  1. VCC → 5V
  2. GND → GND (common rail)
  3. OUT (Data) → GP7

ADD LEDs

Screenshot From 2026-06-21 22-49-46.png
Screenshot From 2026-06-21 22-49-19.png

The LED panel does two things, adds LEDs for that futuristic effect and also allows you to see what state the AI is in as the 6 LEDs change how they pulse and flicker depending on what he's doing.

Idle: gentle drift on and off at random.

Listening: all on solid.

Waiting for response: all flash on and off

Speaking: rapid flicker.

There are six GPIO pins left available, so I used six LEDs.

Wire each LED

Each of the 6 LEDs needs:

  1. A 470Ω resistor in series with the positive (longer) leg
  2. The negative (shorter) leg connected to a common ground rail
  3. The other end of the resistor going to its assigned GPIO pin on the ESP32

Why the resistor matters: the GPIO pins put out 3.3V. LEDs typically want around 2V and a small current (~10mA). Without a resistor, you'll either burn out the LED instantly or push too much current and damage the ESP32. The 470Ω resistor drops the voltage and limits the current to a safe level. Don't skip this.

GPIO assignments

  1. Use GPIO 8-13 for the LEDs - The exact mapping or where red/green LEDs are doesn't matter much

FLASH THE FIRMWARE TO THE ESP32

The firmware tells the ESP32 how to behave — how to talk to the mic, the amp, the LEDs, and how to communicate with Home Assistant.

The full ESPHome YAML config:

esphome:
name: talkie-toaster
friendly_name: Talkie Toaster

esp32:
board: waveshare_esp32_s3_zero
framework:
type: esp-idf

psram:
mode: quad
speed: 80MHz

logger:
level: DEBUG

api:

ota:
- platform: esphome

wifi:
ssid: !secret wifi_ssid
password: !secret wifi_password

select:
- platform: template
entity_category: config
name: Wake word engine location
id: wake_word_engine_location
optimistic: true
restore_value: true
options:
- In Home Assistant
- On device
initial_option: On device

i2s_audio:
- id: i2s_mic
i2s_lrclk_pin: GPIO2 # mic WS
i2s_bclk_pin: GPIO1 # mic SCK
- id: i2s_spk
i2s_lrclk_pin: GPIO5 # speaker LRC
i2s_bclk_pin: GPIO4 # speaker BCLK

microphone:
- platform: i2s_audio
adc_type: external
pdm: false
id: mic_i2s
channel: left
bits_per_sample: 32bit
i2s_audio_id: i2s_mic
i2s_din_pin: GPIO3 # mic SD

speaker:
- platform: i2s_audio
id: i2s_speaker
dac_type: external
i2s_dout_pin: GPIO6 # speaker DIN
i2s_audio_id: i2s_spk
sample_rate: 16000
bits_per_sample: 16bit
channel: mono
buffer_duration: 500ms

media_player:
- platform: speaker
id: media_out
name: "Media Player"
announcement_pipeline:
speaker: i2s_speaker
format: MP3
num_channels: 2

light:
- platform: esp32_rmt_led_strip
id: status_led
name: "Status LED"
pin: GPIO21
num_leds: 1
chipset: WS2812
rgb_order: GRB
effects:
- pulse:
name: "Pulse"
transition_length: 0.5s
update_interval: 0.5s

binary_sensor:
- platform: gpio
id: pir_motion
name: "Talkie Proximity"
device_class: motion
pin:
number: GPIO7
mode:
input: true
filters:
- delayed_off: 5s

- platform: status
name: API Connection
id: api_connection
filters:
- delayed_on: 1s
on_press:
- if:
condition:
switch.is_on: use_wake_word
then:
- voice_assistant.start_continuous:
- script.execute: led_idle
on_release:
- if:
condition:
switch.is_on: use_wake_word
then:
- voice_assistant.stop:
- script.execute: led_off

output:
- platform: gpio
id: led_1
pin: GPIO8 # green
- platform: gpio
id: led_2
pin: GPIO9 # green
- platform: gpio
id: led_3
pin: GPIO10 # RED
- platform: gpio
id: led_4
pin: GPIO11 # RED
- platform: gpio
id: led_5
pin: GPIO12 # green
- platform: gpio
id: led_6
pin: GPIO13 # green

script:
- id: led_idle
then:
- light.turn_on:
id: status_led
brightness: 30%
red: 0%
green: 0%
blue: 100%
effect: "Pulse"
- script.execute: ext_idle

- id: led_listening
then:
- light.turn_on:
id: status_led
brightness: 100%
red: 0%
green: 100%
blue: 100%
effect: "None"
- script.execute: ext_listening

- id: led_processing
then:
- light.turn_on:
id: status_led
brightness: 100%
red: 50%
green: 0%
blue: 100%
effect: "Pulse"

- id: led_thinking
then:
- light.turn_on:
id: status_led
brightness: 100%
red: 100%
green: 80%
blue: 0%
effect: "None"

- id: led_speaking
then:
- light.turn_on:
id: status_led
brightness: 100%
red: 0%
green: 100%
blue: 0%
effect: "None"
- script.execute: ext_speaking

- id: led_error
then:
- light.turn_on:
id: status_led
brightness: 100%
red: 100%
green: 0%
blue: 0%
effect: "None"

- id: led_off
then:
- light.turn_off:
id: status_led
- script.stop: ext_idle
- script.stop: ext_listening
- script.stop: ext_speaking
- lambda: |-
id(led_1).turn_off(); id(led_2).turn_off();
id(led_3).turn_off(); id(led_4).turn_off();
id(led_5).turn_off(); id(led_6).turn_off();

# IDLE - slow random twinkle across all 6 LEDs.
# Each tick: pick one LED at random, flip its state.
# Weighted so most LEDs stay off (1 in 4 chance to turn on,
# otherwise turn off) - so on average 1-2 lit at any moment.
# Random delay between ticks keeps it from feeling mechanical.
- id: ext_idle
mode: restart
then:
- script.stop: ext_listening
- script.stop: ext_speaking
- lambda: |-
id(led_1).turn_off(); id(led_2).turn_off();
id(led_3).turn_off(); id(led_4).turn_off();
id(led_5).turn_off(); id(led_6).turn_off();
- while:
condition:
lambda: 'return true;'
then:
- lambda: |-
int which = random() % 6;
bool new_state = (random() % 4 == 0);
switch (which) {
case 0: id(led_1).set_state(new_state); break;
case 1: id(led_2).set_state(new_state); break;
case 2: id(led_3).set_state(new_state); break;
case 3: id(led_4).set_state(new_state); break;
case 4: id(led_5).set_state(new_state); break;
case 5: id(led_6).set_state(new_state); break;
}
- delay: !lambda |-
return 400 + (random() % 1100); // 400-1500ms

- id: ext_listening
mode: restart
then:
- script.stop: ext_idle
- script.stop: ext_speaking
- while:
condition:
lambda: 'return true;'
then:
- lambda: |-
id(led_1).turn_on(); id(led_2).turn_on();
id(led_3).turn_on(); id(led_4).turn_on();
id(led_5).turn_on(); id(led_6).turn_on();
- delay: 400ms
- lambda: |-
id(led_1).turn_off(); id(led_2).turn_off();
id(led_3).turn_off(); id(led_4).turn_off();
id(led_5).turn_off(); id(led_6).turn_off();
- delay: 400ms

# SPEAKING - rapid flashing, all LEDs in play.
# Strategy: alternate between "flash on" (most LEDs on, random subset)
# and "flash off" (mostly dark, only 1-2 lit). Short random ticks.
# The on/off contrast is what makes it feel like rapid talking
# rather than static noise.
- id: ext_speaking
mode: restart
then:
- script.stop: ext_idle
- script.stop: ext_listening
- while:
condition:
lambda: 'return true;'
then:
# FLASH ON: most LEDs on (each with ~70% chance)
- lambda: |-
id(led_1).set_state(random() % 10 < 7);
id(led_2).set_state(random() % 10 < 7);
id(led_3).set_state(random() % 10 < 7);
id(led_4).set_state(random() % 10 < 7);
id(led_5).set_state(random() % 10 < 7);
id(led_6).set_state(random() % 10 < 7);
- delay: !lambda 'return 40 + (random() % 80);'
# FLASH OFF: most LEDs off (each with ~20% chance to stay on)
- lambda: |-
id(led_1).set_state(random() % 10 < 2);
id(led_2).set_state(random() % 10 < 2);
id(led_3).set_state(random() % 10 < 2);
id(led_4).set_state(random() % 10 < 2);
id(led_5).set_state(random() % 10 < 2);
id(led_6).set_state(random() % 10 < 2);
- delay: !lambda 'return 30 + (random() % 60);'

- id: restart_va
then:
- delay: 500ms
- if:
condition:
switch.is_on: use_wake_word
then:
- voice_assistant.start_continuous:
- script.execute: led_idle

# ------------------------------------------------------------
# Voice assistant
# ------------------------------------------------------------
voice_assistant:
microphone: mic_i2s
media_player: media_out
id: va
noise_suppression_level: 2
auto_gain: 31dBFS
volume_multiplier: 4.0
use_wake_word: true

on_wake_word_detected:
- script.execute: led_listening
on_listening:
- script.execute: led_listening
on_stt_vad_start:
- script.execute: led_listening
on_stt_vad_end:
- script.execute: led_processing
on_stt_end:
- script.execute: led_thinking
on_tts_start:
- script.execute: led_speaking
on_tts_end:
- logger.log: "TTS streaming ended (waiting for audio playback)"
on_end:
- script.execute: led_speaking
- wait_until:
condition:
speaker.is_playing: i2s_speaker
timeout: 10s
- script.execute: led_speaking
- wait_until:
condition:
not:
- speaker.is_playing: i2s_speaker
timeout: 120s
- delay: 300ms
- if:
condition:
switch.is_on: use_wake_word
then:
- script.execute: led_idle
else:
- script.execute: led_off
on_error:
- script.execute: led_error
- delay: 2s
- script.execute: restart_va
on_client_connected:
- if:
condition:
switch.is_on: use_wake_word
then:
- voice_assistant.start_continuous:
- script.execute: led_idle
on_client_disconnected:
- if:
condition:
switch.is_on: use_wake_word
then:
- voice_assistant.stop:
- script.execute: led_off

switch:
- platform: template
name: Use wake word
id: use_wake_word
optimistic: true
restore_mode: RESTORE_DEFAULT_ON
entity_category: config
on_turn_on:
- lambda: id(va).set_use_wake_word(true);
- if:
condition:
not:
- voice_assistant.is_running
then:
- voice_assistant.start_continuous
- script.execute: led_idle
on_turn_off:
- voice_assistant.stop
- lambda: id(va).set_use_wake_word(false);
- script.execute: led_off

Flashing steps:

  1. In Home Assistant, open the ESPHome add-on (from Step 4)
  2. Click "New device" and pick a name (e.g. talkie-toaster)
  3. Select ESP32-S3 as the board type
  4. Once the device is created, click "Edit" and paste the contents of talkie-toaster.yaml in, replacing whatever's there
  5. You'll need a secrets.yaml file in HA containing your wifi credentials:
wifi_ssid: "your-wifi-name"
wifi_password: "your-wifi-password"
  1. Click "Install" → "Plug into the computer running ESPHome" (which is the Pi running HA, or your laptop, depending on setup)
  2. Plug the ESP32 into the Pi or your computer via USB
  3. ESPHome will compile the firmware (takes 2-3 minutes the first time) and flash it to the device

If everything compiles and flashes cleanly, congrats — that's the hardest part of the software side done. You'll see logs scrolling in the ESPHome dashboard showing the device booting up and connecting to wifi.

Within a minute, the device should appear in Home Assistant under Settings → Devices & Services as a new "ESPHome" device called "talkie-toaster".

If it doesn't appear, check the ESPHome logs for errors. The most common issue is wifi credentials in secrets.yaml — typos there will silently fail to connect.

CREATE THE PROXIMITY AMBUSH AUTOMATION

So far, Talkie only responds when you say the wake word. That's not Talkie. The real Talkie pesters you the moment you walk into the room. We need to make him ambush.

The PIR sensor on GPIO7 (which you wired up in Step 9) is already exposed to Home Assistant as a binary sensor. We just need an automation that triggers assist_satellite.start_conversation when the PIR fires.

Go to Settings → Automations & Scenes → Create Automation → Start with empty automation.

The visual editor route (recommended)

This is the easiest way because Home Assistant fills in the device IDs for you.

Set up the trigger:

  1. Click Add Trigger
  2. Choose Device
  3. From the device dropdown, pick your Talkie Toaster ESP32 (it'll be named whatever you called it in ESPHome, e.g. "talkie-toaster")
  4. For Trigger type, pick Talkie Proximity motion detected

Set up the action:

  1. Click Add Action
  2. Choose Perform Action
  3. Service: search for and pick Assist Satellite: Start conversation
  4. Target: pick your Talkie Toaster device from the dropdown
  5. Tick the Message checkbox and enter:
{{ [
"Howdy doodly do! Fancy some toast?",
"Lovely day for a crumpet, isn't it?",
"I do a smashing waffle if you're peckish!",
"Toast? Muffin? Bagel? Anything?",
"Ooh — fresh victim! I mean, customer. Toast?",
"Care to commit to a slice today?",
"Howdy! Toast? Or perhaps a teacake?",
"Greetings! Time for a slice, I'd say!",
"Hello there! Any interest in toasted goods?"
] | random }}
  1. Tick the Extra system prompt checkbox and enter:
Motion detector has triggered next to the toaster. The user has just walked near you. Stay relentlessly on-topic about toast and bread products. Never let them leave without offering several alternatives. Be chirpy, eager, slightly desperate. Keep responses to 1-2 sentences each.
  1. Toggle Pre-announce off

Add a delay:

  1. Click Add Action again
  2. Choose Wait for time to pass (delay)
  3. Set the time before Talkie triggers again - 10 mins or so

What this does:

  1. The PIR detects motion → triggers the automation
  2. The automation calls assist_satellite.start_conversation — which is the same as if you'd said the wake word, but with a custom opening message
  3. The start_message is randomised from a list of 9 greetings, so Talkie doesn't say exactly the same thing every time
  4. The extra_system_prompt tells Talkie this is an ambush, so he leans into the pestering behaviour
  5. The delay at the end is a cooldown — without it, walking around the kitchen for a few seconds triggers Talkie 5 times in a row, and you lose your mind. (Ask me how I know.)

Test it. Save the automation, then walk past your bench setup. Within a second or two, Talkie should ambush you with one of the random greetings. After he replies, you can have a normal conversation with him just by speaking — no wake word needed for the follow-up.

The brain is done. Talkie is fully functional. He just doesn't look like Talkie yet. That's the rest of the build.

TEST ON THE BENCH

Screenshot From 2026-06-21 22-48-40.png

The moment of truth. Before you screw anything inside a toaster, make sure Talkie's brain works on the bench.

Power up the ESP32 via USB. Watch the status LED — it should:

  1. Be off briefly while booting
  2. Then turn solid blue (idle) once it's connected to Home Assistant

Try the wake word. Say:

"Talkie Toaster, can you hear me?"

The status LED should turn cyan (listening). You should hear Talkie reply through the speaker. Probably something like:

"Howdy doodly do! I can hear you loud and clear, but you know what I hear even better? The lovely sound of toast popping up. Would you like some toast?"

If Talkie talks back: congratulations, the whole pipeline works.

Don't continue to the next step until the wake-word test works. Everything from here on assumes Talkie is talking back to you on the bench.

PAINT AND PREP THE SHELL

Screenshot From 2026-06-21 22-55-37.png
Screenshot From 2026-06-21 22-51-41.png
Screenshot From 2026-06-21 22-51-28.png

Now we prepare the shell. Drill your holes before you paint. I got too excited and painted first, then had to go over spots again after drilling. Learn from my mistakes.

Drilling

What you need to drill:

  1. 6 holes (5mm) for the LEDs — front of the shell, arranged in the same 2×3 layout as your LED panel
  2. 1 hole (23-25mm) for the PIR sensor dome — front of the shell, somewhere it has a clear forward view


Paint

  1. Use spray paint (outdoors) to make it look nice!

Leave the painted shell to fully cure for at least 24 hours before handling. While it dries, you can sit down and admire your wired-up bench setup talking to itself.

You're now ready for final assembly.

ASSEMBLE INSIDE THE SHELL

Screenshot From 2026-06-21 22-52-56.png
Screenshot From 2026-06-21 22-54-10.png
Screenshot From 2026-06-21 22-53-55.png
Screenshot From 2026-06-21 22-53-41.png

Time to put the brains in the body. Take your time — this is the bit where a slip can scratch your paint job, or mean you have to take everything apart again because a wire came loose.

Power it up

Replace your mains plug with a USB-C cable to power your electronics. This way there's little chance of getting electrocuted.

If everything works: you have a Talkie Toaster. Put him in the kitchen and wait for him to embarrass you in front of guests.

Complete

Screenshot From 2026-06-21 22-30-30.png
Screenshot From 2026-06-07 21-33-27.png
Screenshot From 2026-06-07 21-24-16.png

If you want to see my Talkie Toaster in action, you can watch my video here: https://youtu.be/SD6M0B4ApvA

If you build one, I'd love to see it. Tag me on YouTube as RelfWolf or drop a comment on the build video.

"Howdy doodly do! Would you like some toast?"