Weird AI Projects — October 5

Weird AI Projects — October 5

This week finally produced something that feels less like an experiment about AI hardware and more like the beginning of an actual AI-hardware maker ecosystem. There’s also a musical instrument I think you’ll particularly appreciate, plus a persistent-agent experiment that went much further than the usual “put 20 bots in Minecraft.”

Engram — circuit bending, except you’re breaking a neural network

This is my favorite find this week.

Thoughtful Things has built a physical sampler/groovebox called Engram. It has knobs, buttons, microphone, stereo line input, MIDI, CV/gate and headphone output. Inside is a small neural audio model running completely locally. (source)

But Engram isn’t intended to write songs.

Its designers deliberately expose parameters that let you push the neural model outside the behavior it was trained for.

They call this model bending.

The analogy is circuit bending: take some cheap electronic keyboard, deliberately short things that weren’t supposed to be connected, and discover strange sounds.

Here you’re essentially doing:

audio → neural network → deliberately screw with network → hallucinated audio → sample it

Then you can slice, sequence and manipulate the resulting sounds like a normal sampler. Its firmware is open, and the system is designed for pluggable models. (source)

This is significant because it treats an AI model as a component of an instrument, not a replacement for the musician.

And there’s an even better phrase from creator Evan King: Engram is like a “field recorder for latent space.” (source)

That is an excellent way to think about creative AI.

You don’t ask it to make something good.

You wander around inside it looking for weird stuff.

Muse Gadgets — ESP32 and Raspberry Pi become officially supported bodies for an agent

This was announced October 2, so it’s genuinely new.

Meta has open-sourced ESP32 firmware and a Linux SDK specifically so makers can give its Muse agent physical hardware.

Their examples include:

• ESP32-S3 boards with little displays
• round AMOLED screens
• M5Stack devices
• color e-ink displays
• microphones and speakers
• Raspberry Pis
• buttons, sensors and actuators

The code is Apache 2.0 licensed. (source)

The Linux version is particularly interesting. A Pi can expose commands to the agent, and builders can add their own commands. Meta explicitly suggests hooking it into things like Home Assistant or local system administration. (source)

So instead of:

Pi runs application containing AI

you get:

AI agent has Pi as one of its physical endpoints.

That’s a subtle but important architectural inversion.

And because you can define commands, the interesting version isn’t:

“Put Muse on an ESP32.”

It’s:

“Here are the only six things this strange machine is physically capable of doing. Figure out how to inhabit it.”

This is almost exactly the rabbit hole we’ve been circling for the past few weeks.

ESP32-S3 Super Mini AI — an LLM running inside 384 KB of RAM

The microcontroller experiments continue getting absurd.

Developer apexduck221 has an open-source project running a generative transformer entirely on an ESP32-S3 Super Mini.

And this version deliberately uses a board with:

4 MB flash
384 KB usable internal SRAM
zero external PSRAM

The whole board costs roughly a couple of dollars.

It generates text locally at roughly 9–20 tokens/sec, while simultaneously creating its own Wi-Fi hotspot and serving a little browser chat interface directly from flash. (source)

That’s not particularly useful as a ChatGPT competitor.

It’s fascinating as a material.

We’re getting to the point where a tiny object could contain a little generative process in approximately the same way an electronic toy used to contain a sound chip.

That means you can stop thinking:

Which API does my device call?

and start thinking:

What tiny intelligence belongs inside this object?

That is much more interesting.

Emergence World — researchers let AI societies run for 16 days

This is probably the most important persistent-world experiment I’ve encountered recently.

Researchers created eight separate persistent worlds, each containing ten autonomous agents. Seven worlds used agents from the same model family; the eighth mixed models.

Then they let them operate for 16 days.

The agents weren’t just chatting.

They could:

pursue long-term goals
create and use tools
maintain persistent memories
interact with other agents
modify their environment
create shared institutions

Across the experiment, the societies generated more than 850,000 LLM calls and nearly 50 billion tokens. (source)

The purpose was actually safety research: failures in persistent agents can propagate through memory, tools, institutions and other agents long after the original mistake.

But the experiment accidentally demonstrates something artistically interesting.

We’re now able to study:

What happens when an artificial society has enough time to develop history?

Not 30-minute game sessions.

Not “100 agents talk for an afternoon.”

Weeks.

That’s where these experiments start becoming genuinely strange, because events can have consequences several generations of interactions later.

Valerant — AI dreams a game world, then turns the dream into actual geometry

This is a clever solution to one of the biggest problems with AI-generated games.

Video world models can generate convincing footage of walking through imaginary places.

But there often isn’t actually a place underneath the video.

Turn around and the building may be different.

Valerant takes an action-conditioned world model and couples it with SLAM—the same general family of techniques robots use to map physical environments.

It begins with one image.

The world model predicts what should appear if the agent explores in various directions.

SLAM reconstructs those observations into persistent 3D geometry.

The system deliberately chooses actions that explore unknown space.

Gradually:

image → imagined exploration → spatial reconstruction → navigable 3D map. (source)

That’s a fascinating bridge between generative media and conventional game engines.

Instead of merely generating a video of a world:

the hallucination gets crystallized into architecture.

I think that’s an important idea.

Times Square — Living Canvas — generative media placed inside a shared virtual location

This was built at the GPT-6 Astra Hackathon in New York on September 10.

It’s a browser-based 3D recreation of part of Times Square.

You walk around as a character, generate imagery/video and then put your generated media onto the virtual billboards. Other connected visitors see those billboard changes too. (source)

It’s technically straightforward compared with some projects here.

But I like the interaction model.

Most generative-media interfaces are:

prompt → rectangle

Living Canvas is:

prompt → object inside a place

That distinction matters.

Imagine generating:

a painting that’s hanging in a virtual house;

a commercial that appears on a television inside a game;

a newspaper that NPCs subsequently read;

a record that gets added to a simulated jukebox.

Generated media becomes an artifact with location and history, rather than something floating in a chat transcript.

Threepio — the robot’s enclosure is literally its speaker

Sam Potozkin built a C-3PO-inspired embodied AI system around a Raspberry Pi 5.

Voice comes in, gets transcribed, processed through an LLM/personality layer and synthesized back into speech.

That’s relatively conventional.

The nice physical detail is the output.

Rather than hiding a speaker inside the robot, Threepio uses an audio exciter that vibrates the enclosure itself.

The robot’s body becomes its speaker. (source)

That’s exactly the kind of small physical decision that makes an AI object stop feeling like:

tablet + chatbot + robot shell

and start feeling like a coherent object.

Bob — one maker building an actual embodied AI platform

David Olutunde’s Bob is worth following precisely because it isn’t coming out of a giant robotics lab.

It’s a homemade rover built around:

Raspberry Pi
Arduino motor control
camera
microphone
speaker
servos
animated face display
custom web dashboard

The stated goal is for Bob to move, see, listen, speak and gradually develop a recognizable personality. The current machine is a functioning prototype under active development. (source)

I include projects like this because they’re useful antidotes to $100-million robotics demos.

One person can increasingly build something that has:

perception + movement + language + memory + personality

from commodity hardware.

That’s a profound change in what constitutes a hobby electronics project.

The thing I’d pay attention to this week

Engram + Muse Gadgets together.

They point toward two different futures for AI hardware.

Muse Gadgets says:

Give a powerful intelligence lots of little physical bodies.

Engram says:

Put a tiny specialized intelligence directly inside an object and make it part of the object’s character.

I find the second idea more creatively interesting.

Think about guitar pedals.

A RAT doesn’t try to be an intelligent guitar assistant.

It has a peculiar circuit.

That circuit has a personality.

Musicians learn how to play the circuit.

Engram treats a neural network similarly.

The model itself becomes something you play.

That suggests an interesting experiment for your musical/electronics interests:

A neural guitar pedal that is intentionally wrong

Not:

“AI tone matching.”

Not:

“Generate a perfect Fender amp.”

Instead, train a tiny audio model on some deliberately narrow sonic vocabulary—surf guitar, spring reverb crashes, tape echo, tremolo, amplifier noise, maybe strange old instrumental records.

Put it on physical hardware.

Give it five knobs:

MEMORY
DECAY
CONFUSION
AGE
DREAM

And deliberately expose parameters that push the model beyond its training distribution.

Now you aren’t selecting an effect.

You’re destabilizing a little neural system with your guitar signal.

Sometimes it produces gorgeous ghostly surf textures.

Sometimes broken tape.

Sometimes rhythmic garbage.

Sometimes something you’ve never heard before.

No screen.

No prompt.

No cloud.

Just a weird aluminum box on the floor with five knobs and an AI model trapped inside it.

That feels like an AI project worth building.