AI Tamagotchi ⚡ OATs Turn Objects Into Pets Now12 min read2,445 words

AI Tamagotchi ⚡ OATs Turn Objects Into Pets Now

Discover AI Tamagotchi-style OATs: object-linked AI with E Ink avatars, sensors, and AI habit tracking—plus insights on battery life and trust.

AI TamagotchiOATsobject-linked AIanthropomorphic AIAI habit tracking
AI Tamagotchi ⚡ OATs Turn Objects Into Pets Now

What Happens When Your Houseplant Gets an AI Pet?

You meant to water the plant. You forgot. Now a small screen on its pot shows a little drooping character that looks disappointed - until you water the soil, and the expression perks up. That's the basic setup behind OATs, short for Object Agent Twins: tiny E Ink displays that pair with sensors and show an animated "avatar" for everyday objects.

Created by Carnegie Mellon PhD student Daehwa Kim, OATs have been tested with plants, skateboards, coffee machines, and dumbbells. The inspiration nods to Tamagotchi, but the twist is that the "pet" lives on things you already have at home. Instead of opening another app, you get a signal right where the relevant action happens.

That idea isn't just cute. It raises real product questions: Can personality-style cues actually change a habit? What kind of hardware and upkeep would you need for this to be usable, not just a demo? And where does an expressive interface start encouraging the wrong kind of trust? Here's what the project does, where it could help, and what teams should watch for.

What are OATs and how do they work?

OATs are small devices with sensors that attach to an everyday object and show an animated character on an E Ink screen. The character's expression changes based on selected conditions - movement, temperature, humidity, light, or moisture. A plant avatar might look unhappy when soil is dry, and a skateboard character might seem "lonely" after days without movement.

The interaction is intentionally straightforward. You set up an OAT through a web portal: name the object, describe it, and choose which sensors to use. The system suggests rules for when the avatar should behave positively or negatively, and then you can tweak those rules for the specific object. A plant that prefers dry conditions shouldn't be treated like one that needs consistently damp soil.

It's also not a tiny chatbot, and it's not continuously "thinking" about the world. Sensors provide the readings, and the configured conditions determine when the avatar changes. Google's Nano Banana image-generation service is used to create the sprite set with different expressions for different states. So while there's AI involved in generating the visuals, the device's core behavior is sensor-driven feedback - not independent agency.

That distinction matters. "Agent" can sound like something that plans and acts on its own. OATs, as described, do something more limited: they make an object's state visible through a character. A simple view of the loop looks like this:

  1. Sense: A selected sensor records a condition, like motion or moisture.
  2. Interpret: A configured rule maps the reading to a state.
  3. Express: The display shows the corresponding avatar expression.
  4. Respond: You decide what to do, like watering the plant or using the dumbbell.

The hardware is meant to stay modest, too. The main module was described as costing around $20, and the display uses E Ink rather than a bright screen. That supports a low-effort, glanceable interface attached to the object. It still requires power, setup, and sensor calibration - but it avoids turning every interaction into yet another phone notification.

The key design choice, then, isn't "add AI to an object." It's putting the feedback loop where the related behavior happens. A phone reminder competes with messages and apps. A small expression on the skateboard or plant pot is harder to miss - and it may feel more connected to the action you're actually trying to prompt.

What problems can object-linked AI pets solve?

OATs are most interesting as a behavior-design interface, not as a general-purpose AI assistant. In Kim's experiments, people tended to use them in three main ways: showing whether an object is being used, warning people nearby, and tracking the user's own habits. Each use has its own goal - and needs a different definition of success.

Making use visible

A coffee machine display could change its expression when the machine starts grinding beans. The point isn't that the machine needs emotional support. The avatar makes activity legible to someone nearby without forcing them to open an app or hunt through a dashboard.

This could work for shared equipment, household routines, or objects that are easy to overlook. The real question is whether the screen tells you something you actually need to know. If it only makes the scene entertaining, the value probably fades once the novelty does.

Giving a local warning

A display attached to a 3D printer could update while the printer runs. That could help alert people in the same room that the machine is operating. This is the kind of "physical signal" that can make sense, because the information is relevant at the location.

Still, an avatar shouldn't be treated as a substitute for a safety system. If you're warning about fumes or other hazards, the warning needs to be accurate, clear, and obvious - and it can't rely on someone interpreting a playful face the "right" way. For higher-risk settings, the avatar might add an extra layer, but it shouldn't replace established safety controls or instructions.

Nudging personal habits

A dumbbell that shows a cheerful character after use - or looks "sad" after long inactivity - turns a quiet habit into something you can see. A skateboard could use motion data in a similar way. Because the feedback is immediate and tied to the object, you don't have to remember to log it elsewhere.

That can help as a gentle prompt. But it can also add pressure. A user might respond to avoiding a character's "disappointment" instead of pursuing a personal goal. Whether that's acceptable depends on the context, the user, and how strong the cue is. A playful nudge someone chose for themselves is different from a system designed to make them feel guilty.

Key takeaways for product teams:

  • Put feedback where the relevant action already happens.
  • Use a character when it helps people notice or understand the state.
  • Keep the user in control of the goal and what's being tracked.
  • Treat safety signals as higher-stakes, not as decoration.
  • Measure whether it changes behavior over time, not just whether people like the demo.

OATs point to a broader design hypothesis: a physical, expressive signal might feel more immediate than a notification buried in a phone. That's something to test - not a guarantee. The best measure is sustained, voluntary use and a real improvement in the task, not the number of people who smile at a prototype.

What are the technical and product limits?

Battery life is the clearest constraint in the OATs prototype. In typical use, the devices last around three to four days, and pairing with a sound-level sensor can bring that down to about a day. They recharge via USB-C, but frequent charging changes the day-to-day experience: a device meant to make a habit easier can end up becoming another item you have to keep working at.

That's not a small engineering detail. It affects where the device can be attached, how often someone will check it, and whether they'll keep using it after the first week. A prototype can get away with hands-on charging and tinkering. A consumer product has to fit into a routine with minimal explanation. If users have to remember to charge the reminder, you may end up recreating the exact maintenance burden you were trying to avoid.

Sensor choice adds another trade-off. More sensors can make the avatar feel more responsive, but they also increase complexity. Moisture readings can help separate "dry" from "watered," but they still don't automatically tell you what that specific plant needs. Temperature, light, and humidity depend heavily on the object and its environment. If your rules are too generic, the character can confidently communicate the wrong state.

For a real product, setup would need to make those assumptions obvious. Users should be able to see which sensor drives which behavior, adjust thresholds, and turn off prompts that don't help. That's especially important when the object's needs don't match the default suggested by its name. Customization isn't just a nice-to-have; it can prevent a simple interface from hiding an overly simplistic model.

There's also a durability and deployment question. A device on a skateboard has different physical demands than one on a plant pot or a stationary 3D printer. Attachment methods, sensor placement, and exposure to moisture or impacts all affect reliability. The low-cost module is promising for experimentation, but module price alone doesn't define the cost of a finished product. A product has to cover enclosure, assembly, charging, support, and replacement.

Before taking an object-linked device beyond a demonstration, a team should test the whole operating loop:

  • Setup: Can a new user pair the device and choose behaviors without specialist help?
  • Accuracy: Do the sensors and rules correctly identify the states that matter?
  • Maintenance: How often does it need charging, cleaning, or recalibration?
  • Retention: Does the signal stay useful once the novelty fades?
  • Failure behavior: What happens when a sensor is wrong, disconnected, or out of power?

A prototype can make the interaction easy to understand. It can't prove the system is robust, safe, or ready for widespread adoption. OATs are best read as exploring a design space, not as a finished consumer product.

What does anthropomorphism mean for AI trust?

Putting a face on an object changes how people interpret it. A plant's needs are usually inferred from leaves, soil, and experience. Add a sad character and the same signal can start to feel like a kind of social appeal. That emotional layer might make the prompt more memorable - but it can also encourage people to treat the system as if it understands more than it actually does.

This shows up in AI design more broadly. Human terms like hallucination or dreaming can feel like convenient shorthand, but they can also suggest perception, intention, or inner experience that isn't there. And when a system uses expressive language or a humanlike face, people may overestimate what it knows and how reliable it is. Making the interface friendly doesn't automatically fix that.

OATs keep the interaction limited to expressive states on an E Ink display rather than open-ended conversation. That's an important boundary: a small set of visible reactions is easier to interpret than a character that "speaks" as if it has feelings, needs, or independent goals. Even so, the simplicity doesn't remove the need to explain what a reaction means and which sensor caused it.

The product question isn't whether anthropomorphism is always good or always bad. It's whether the social cue helps a user understand a real condition without misrepresenting what the system is capable of. Naming a bicycle or a car can be harmless. But using apparent disappointment to steer someone's exercise routine is more consequential, because it's directly shaping behavior.

A responsible design should make that influence clearer - and keep it limited. In practice, that means:

  • Describe the system plainly: A sad face means a configured condition was detected; it doesn't mean the device feels sad.
  • Let users control the nudge: People should be able to change the behavior, mute it, or stop tracking.
  • Avoid manipulative stakes: Don't imply the user is hurting or neglecting a sentient being.
  • Show the basis for the signal: When possible, make the relevant reading or rule understandable.
  • Use stronger safeguards for consequential advice: A playful avatar isn't an adequate interface for medical, financial, or safety-critical decisions.

For product teams, there's also a business angle. Emotional engagement can increase repeat use, but trust is hard to rebuild when a system misleads users about what it knows or feels. The real opportunity isn't to make every object seem alive. It's to use a small amount of personality to make useful feedback clearer - while keeping the system's limits visible.

Conclusion: Make the behavior useful before making it cute

OATs show how a small display, a few sensors, and an expressive avatar can pull digital feedback off the phone and onto the object it relates to. That idea could be useful for habit tracking, shared equipment, and local status signals.

But the real test isn't whether people find the avatar charming during a demo. It's whether the signal stays accurate, understandable, and genuinely helpful - without turning into a charging chore or an emotional pressure campaign. If you're building something similar, start with the behavior and the feedback loop. Add personality only when it helps people act, and make sure users can tell what the system actually knows.

Frequently Asked Questions

OAT stands for Object Agent Twin. It refers to a small device that pairs an everyday object with a sensor-linked avatar shown on an E Ink display. The character’s expression changes according to configured conditions, such as movement or moisture, rather than acting as a general-purpose conversational AI.
The project was presented as a research prototype by Carnegie Mellon student Daehwa Kim. Although people encouraged Kim to sell kits, she had not decided whether to pursue it as a business. The described hardware and setup demonstrate a concept, not a confirmed retail product or supported consumer service.
OATs use selected sensors, such as moisture, temperature, humidity, light, occupancy or motion. A web portal lets users configure behaviors based on readings. The device then changes the avatar’s expression when a rule is triggered; it does not necessarily understand the object’s needs beyond those configured conditions.
AI is used to generate avatar sprites, while the described interactions rely on sensor readings and configured rules. That distinction matters: an AI-generated character does not mean the device is independently reasoning about a plant, workout or machine. The behavior depends on the sensors and thresholds selected during setup.

Related articles