Weird AI Projects — September 21

Weird AI Projects — September 21

This week’s strongest finds skew toward quiet physical AI and persistent worlds. One in particular—Fugleramme—is almost a manifesto for the kind of embedded project I think is worth paying attention to: the AI is invisible, the object is beautiful, and the result doesn’t feel remotely like “ChatGPT in a box.”

Fugleramme — a picture frame that listens to the birds outside

Arne Giacomo Munthe-Kaas released Fugleramme on September 14, and it quickly blew up among makers.

It’s a Raspberry Pi 5 connected to a microphone and 13.3-inch color e-ink display. It continuously listens to the environment and runs BirdNET-Go locally to identify bird calls. When it hears a bird, the frame changes to show that species.

But here’s the wonderful design decision:

It doesn’t generate an AI image.

Instead, Munthe-Kaas assembled more than 800 illustrations cut from nineteenth-century natural-history books, covering 400+ bird species. So when a robin sings outside, your apparently antique ornithology print quietly changes to a robin. Everything runs locally. (source)

This is one of my favorite AI projects I’ve found for these reports because the AI isn’t the experience—it enables the experience.

You could imagine the same philosophy applied to an ESP32/Pi device:

listen → recognize what’s happening → subtly transform physical object

No prompt box. No chatbot. No AI branding.

That’s a design direction worth stealing.

WireClaw — an AI agent living on a $5 ESP32

This is almost uncannily relevant to the hardware you’ve been working with.

WireClaw puts an agent architecture onto ESP32-S3/C3/C6 microcontrollers. It can read temperature/light/GPIO/serial/NATS, operate LEDs, relays and PWM, communicate through Telegram, and create persistent automation rules. (source)

Its architecture is clever.

The LLM doesn’t continually operate the hardware.

Instead:

you:
“When this sensor exceeds 80°, blink this LED every five seconds.”

AI: interprets intent → writes rule

ESP32: executes rule locally forever

The agent disappears from the control loop.

WireClaw calls this two loops: an on-demand AI loop that creates/configures rules and an always-on deterministic rule loop that operates without an LLM connection. Multiple WireClaws can also communicate over NATS. (source)

That’s considerably more interesting than putting a voice assistant on an ESP32.

And the architectural idea is excellent:

AI programs the machine; ordinary code operates the machine.

For physical systems, that’s probably a much saner model than asking an LLM whether to turn the light on every five seconds.

PEGA — AI-generated worlds finally start remembering where things are

This is the development I’d watch most closely for games.

Seele AI’s PEGA is a real-time world model specifically designed around long-horizon 3D memory.

Most video-generated worlds have an enormous problem: walk around a corner and the world starts forgetting itself. Rooms change. Objects disappear. Geometry drifts.

PEGA combines a graphics engine’s structured geometry/state with a video model’s visual generation. The stated goal is persistent spatial context lasting minutes rather than seconds. (source)

That means:

walk into house

put chair in hallway

leave house

wander around

come back

chair is still there

It sounds trivial because ordinary games have done this forever.

For generated worlds, it isn’t trivial at all.

And PEGA’s roadmap gets much stranger: persistent shared worlds that continue evolving between sessions. (source)

That gets very close to something we’ve been circling in these reports:

AI doesn’t generate the game.
The AI is the game engine.

WorldMind — separating an NPC’s brain from the generated world

A new research project called WorldMind approaches AI-native games from another angle.

Instead of having one giant model simultaneously generate the visuals and somehow decide what every NPC should do, WorldMind separates the process into:

UNDERSTAND WORLD → DECIDE → CONTROL CHARACTER → GENERATE RESULT

The researchers also created BOSS-140K, a dataset pairing gameplay video with internal game states. In their evaluation, WorldMind’s NPC behavior was preferred roughly 70% of the time over comparison systems for tactical appropriateness/coherence. (source)

This matters because it suggests something closer to:

NPC actually understands:
player has sword
door is locked
health = 18%
player betrayed me earlier

rather than simply producing plausible-looking movement from video context.

Combine WorldMind-like character reasoning with PEGA-like persistent environments, and you can see where AI-native games may eventually become genuinely different from scripted games rather than merely infinite AI dialogue.

Agent Sandbox — researchers are basically rebuilding Smallville as a game engine

Chris Callison-Burch’s group has an open-source summer-2026 project that takes an old-school text-adventure engine and gives each NPC its own AI mind.

Multiple agents:

perceive → remember → plan → act

inside the same shared world.

The team explicitly splits potential applications into two directions:

Games: believable autonomous NPCs.

Simulations: Sims/SimCity-like experiments where realistic group dynamics matter more than whether the simulation is entertaining. (source)

Their longer-term direction includes moving the system into a 2D Godot environment.

This is one I’d actually clone and poke around in rather than merely read about.

Water Whisperer — an AI meeting moderator for rain, fog and the Danube

At this month’s Ars Electronica Festival 2026, Zeynep Aksöz Balzar and Mark Balzar showed Water Whisperer.

Participants enter an inflatable immersive environment where the AI facilitates a conversation among perspectives representing:

the Danube, groundwater, wastewater, rain, fog and snow.

Instead of answering questions, the AI acts as a mediator, encouraging humans to negotiate climate and urban issues from those different ecological viewpoints. Each session concludes with a speculative postcard created from the group’s conversation. (source)

It’s weird, but there’s an important idea buried in it:

AI doesn’t have to play the person.

It can play:

• an institution
• an ecosystem
• a building
• a town
• a radio station
• a fictional company

That’s a much richer role for agents than “helpful assistant.”

Agentic Systems in Immersive Spaces — what if the room itself were the agent?

Ars Electronica also demonstrated Agentic Systems in Immersive Spaces inside its giant Deep Space 8K projection environment.

Rather than merely projecting AI-generated imagery, the room perceives what’s happening during the presentation. An agent reacts to audience questions and situations, retrieves relevant material and makes connections while a human guide continues presenting. (source)

The important conceptual shift is:

screen contains AI

→

room contains AI

A museum gallery could notice that five visitors are staring at a particular object and spontaneously reveal additional material around it.

A game room could recognize where players congregate.

A bar could subtly change its fictional broadcast or lighting based upon conversations and activity.

Architecture becomes interface.

GGUI — give an existing agent an interface generator

Generative UI keeps accelerating.

GGUI is particularly interesting because it isn’t trying to replace your agent framework. You can point an existing Claude, OpenAI or Google agent at its MCP server, and the agent gains the ability to render interactive interfaces around its tools. The protocol/runtime is open and Apache-2.0 licensed. (source)

Meanwhile Tambo takes a somewhat more constrained approach: developers register ordinary React components and schemas, then the agent chooses and populates the appropriate component according to what the user asks. (source)

I increasingly think this will become a major application pattern:

You build 30 excellent interface components.

You don’t necessarily decide beforehand which screen contains which components.

The agent composes them according to intent.

That preserves good design while eliminating huge amounts of conventional application navigation.

The project I’d steal from this week

Fugleramme. Easily.

Not literally the bird detector.

The philosophy.

A lot of current AI hardware looks like this:

screen
microphone
cartoon face

“HELLO MATT. HOW MAY I HELP YOU?”

I’m increasingly convinced that’s the boring path.

Fugleramme does the opposite.

The object looks like something that could have existed 100 years before artificial intelligence.

AI quietly gives it an impossible ability.

That idea fits beautifully with the physical devices you’ve been building.

Imagine a little UMS tabletop unit that looks like a 1978 broadcast-monitoring instrument.

It contains:

small monochrome/e-ink display
speaker
rotary knob
three LEDs
maybe a VU meter

No chatbot.

No conversation.

It simply listens to your house.

Eventually it recognizes things.

BGTV is playing Seinfeld.

KMAT is playing surf music.

A particular station ID aired.

Someone entered the room.

A storm is approaching.

A system service went down.

The object quietly changes state.

Maybe the display reads:

NETWORK MONITOR 04

VIDEO: BGTV-10
PROGRAM: SEINFELD
EP: THE MARINE BIOLOGIST

AUDIO: KMAT 88.1
FORMAT: SPY SURF

EXT WX: DUST ADVISORY

Occasionally it makes a mechanical-sounding chirp.

Sometimes the thermal printer prints something.

And most of the time it simply sits there.

The next interesting AI device may not feel intelligent at all.

It may feel like an inexplicable old machine that somehow knows what’s happening around it.

Fugleramme is the first project in these weekly searches that makes me think that design philosophy is starting to become a recognizable movement rather than just a cool hypothetical. (source)