The Little Guy-ification Of AI

AI agents are becoming more autonomous, more capable and, for some reason, increasingly adorable.

Something strange is happening to artificial intelligence.

The software is becoming more autonomous, more capable and increasingly able to act on our behalf.

The interfaces are becoming little guys.

Meta’s Muse is an AI agent, a step beyond a chatbot that waits for your next prompt. Give it a goal and it can plan around it, research, work through tasks, remember relevant context and continue making progress without requiring constant supervision.

This is the kind of computer people have imagined for decades. HAL without the homicide. JARVIS without the Iron Man suit.

Meta chose to represent it with Jolly, a fuzzy little creature with rosy cheeks, tiny hands and an extensive wardrobe.

And Meta isn’t entirely alone. OpenAI has introduced Dots, giving autonomous agents names and cute abstract identities. Increasingly serious software is acquiring increasingly unserious little faces, shapes and personalities.

Apparently, the age of autonomous AI is also the age of the little guy.

I’m calling this the little guy-ification of AI.

THE EMBARRASSING PART IS THAT I HAD THE SAME IDEA

I should probably disclose something before I start criticizing Meta for putting a little creature inside its AI.

I’ve done it too.

A while back, I designed a character called Bubblai, a cute little AI companion built around the same basic premise: make an unfamiliar technology feel more approachable by giving it a recognizable personality.

And I still think that’s a perfectly reasonable design instinct.

When you’re designing something new, particularly something that behaves in ways people aren’t used to, familiarity is one of the most useful tools available. You borrow visual language from things people already understand.

A character can make an abstract system feel less abstract. It can give users something to recognize, return to and develop expectations around.

But there’s a difference between making a technology approachable and deciding that approachability should become its permanent identity.

That’s the part I’m less certain about now. Not because I’ve suddenly developed an ideological opposition to adorable software. I’ve designed adorable software. I understand the appeal.

It’s because the technology underneath the character is changing much faster than the character itself.

META HAS A VERY GOOD REASON FOR THE LITTLE GUY

The strongest argument for Jolly isn’t that he’s cute. It’s that he gives agency a body.

Traditional software tends to make its actions visible through interfaces we already understand. A button initiates something. A progress bar indicates that something is happening. A notification tells us something has finished.

An autonomous agent complicates that relationship.

It might be researching something, making a plan, waiting for another process, delegating work or deciding what to do next. Some of that happens without direct user input.

The interaction isn’t always a straightforward exchange of instruction and result.

So Meta gives that activity a character.

The little guy is doing it.

That’s a surprisingly powerful idea.

Instead of asking users to interpret an unfamiliar collection of background processes, the product gives them a single recognizable presence associated with those processes.

Jolly can be waiting, working, connecting or celebrating.

And that makes the agent’s behaviour easier to understand at a glance. It’s not merely decoration. It’s an attempt to make a new computing model legible.

As a product-design decision, I can see exactly why Meta arrived here.

JOLLY IS QUIET AND STILL TAKES UP ROOM

My initial reaction to Jolly was more skeptical than my reaction after actually using Muse.

From the promotional material, I expected something relentlessly animated. A tiny creature constantly demanding attention while I tried to accomplish something.

In practice, the interface is much more restrained.

Muse’s visual design is predominantly monochromatic, clean and surprisingly quiet. Jolly provides a small concentration of warmth and personality within an otherwise minimal environment.

Jolly isn’t the interface aesthetic. He’s the exception to it.

And he’s not Clippy.

He doesn’t constantly interrupt to offer unwanted advice. He isn’t leaping into the conversation every time I type a sentence. Most of the time, he’s simply there. That distinction matters.

But there’s still a cost to being there.

On my iPhone, Jolly occupies a persistent position near the top of the interface. I use a large Pro Max, so this isn’t a complaint about trying to fit an entire application onto a tiny screen.

Even so, mobile real estate is valuable. A character can be visually distracting without being behaviourally intrusive.

I eventually asked Muse how many states Jolly has.

Six, according to Muse.

Idle. Working. Connecting. Making something. Waiting for subagents. Milestone level up.

That’s more sophisticated than I initially gave him credit for; albeit, 98% of the time you’ll only see two.

Meta has built a small visual vocabulary around the agent’s activity, including distinctions between doing work directly and waiting for delegated work to finish.

Those are useful distinctions.

But I also found myself mostly noticing a much smaller subset during ordinary use: Jolly resting, Jolly working, Jolly doing some variation of being Jolly.

The six states are categories, not necessarily six individual animation clips. There may be considerable variation within them.

Initially, I wondered whether all this character animation was an elaborate way to communicate a relatively small amount of information.

The more I used Muse, though, the more I realized I was evaluating Jolly through the wrong interaction model.

I was still thinking about the experience a little too much like a chatbot. You ask something, the system thinks for a moment, and an answer appears.

Agents complicate that rhythm.

Sometimes Muse needs to search, research, coordinate work or figure out what to do next. You don’t always know how long that’s going to take, and the interface doesn’t necessarily have a meaningful percentage to show you.

In those moments, Jolly’s animation starts earning its keep.

It’s not just telling me that something is happening. It’s making the wait more tolerable.

A character that moves, reacts and does something mildly entertaining can make an unpredictable delay feel less frustrating. There’s genuine UX value in that. Delight isn’t always decoration. Sometimes delight is what makes waiting bearable.

And Muse doesn’t require me to sit there watching the little guy perform indefinitely. For longer-running tasks, I can leave, get on with my life and receive a notification when the work is finished.

That’s a sensible distinction between work I’m waiting for and work I’ve delegated.

There’s a limit, of course. An animation can be delightful the first dozen times and irritating by the hundredth. And a reassuring character shouldn’t create the impression that meaningful progress is happening when a process has stalled.

But those are reasons to design the feedback carefully, not reasons to abandon it.

I’ve become considerably more convinced that Jolly’s animation serves a real purpose when Muse is actively working.

The question is no longer whether the little guy needs to move.

It’s when he needs to be onstage.

THE MARKETING MAKES JOLLY MUCH BIGGER

There’s a noticeable difference between the Jolly being advertised and the Jolly living inside the product.

In promotional material, he’s a star.

He’s large, expressive, dressed up, animated and positioned as the central attraction. His personality is part of the sales pitch.

Inside Muse, he’s more like a persistent companion to the interface.

That’s a much better implementation than I expected. But marketing changes the expectations people bring into a product.

When a company spends so much effort presenting a character as the embodiment of its AI, users are encouraged to interpret the software through that character.

Jolly isn’t simply a convenient indicator that something is happening. He’s the thing Meta wants people to recognize, remember and associate with Muse.

That’s normal mascot design.

What’s unusual is that the mascot is also an interactive representation of software that can act on your behalf.

And those are different jobs.

A brand mascot needs to be distinctive.

An interface character needs to communicate useful information.

An embodied conversational agent needs to behave convincingly.

The further Jolly moves from the first job toward the third, the more demanding the design problem becomes.

THE ALTERNATIVE IS ANOTHER GLOWING ORB

To be fair, the AI industry hasn’t exactly overwhelmed us with better alternatives.

For years, the default visual representation of artificial intelligence has been some variation of a glowing orb.

A luminous circle. A pulsing gradient. A mysterious blob of light that expands and contracts while pretending to think.

Apparently, intelligence is round.

The orb has advantages. It’s abstract, flexible and doesn’t require users to believe they’re interacting with a specific creature.

But it can also feel generic.

There’s only so much personality you can squeeze out of a glowing circle before you’re effectively designing a screensaver with opinions.

Jolly solves a real branding problem. You can recognize him instantly, even outside the application.

But the choice isn’t necessarily between a furry character and another glowing orb.

Meet Alfred, one of OpenAI’s Dots. No arms, no legs, no elaborate anatomy. Just a fuzzy triangle with glasses and a bow tie. Apparently, that’s enough to give an AI agent a personality.

OpenAI’s Dots suggest a third direction: named, abstract visual identities for autonomous agents.

They’re cute, but they don’t rely on a conventional face, furry body or tiny hands.

Meta gave agency a body. OpenAI gave agency an identity without anatomy.

I don’t think we have enough experience with either approach to declare a winner. They’re also different products with different interaction models. But the distinction is interesting.

Perhaps intelligence doesn’t need to look human, animal or even alive to feel identifiable.

ADULTS LOVE CUTE THINGS

One of the lazier criticisms of Jolly is that he’s childish. I don’t think that’s particularly useful.

Adults love cute things.

Adults collect plush toys, obsess over cartoon characters, buy designer figurines, decorate their homes with objects that have faces and develop surprisingly intense emotional relationships with inanimate products.

There’s no age at which someone suddenly becomes immune to a little guy.

Labubu alone should have settled that argument.

And character design has been central to branding for generations.

The Michelin Man. Tux. Bugdroid. Snoo. Chester Cheetah. Duolingo’s Duo.

These characters make brands recognizable and give otherwise abstract organizations a personality people can engage with.

Some of them are cute. Some are weird. Some are borderline unsettling. Plenty of them are loved.

So the question isn’t whether adults can appreciate Jolly. Of course they can. The question is whether the kind of cuteness Meta has chosen is the right kind for this particular product.

And whether that choice will continue to make sense as the product evolves.

META SHOULD HAVE COPIED LABUBU HARDER

Not literally. Please don’t put teeth on Jolly.

What I mean is that some of the most memorable characters aren’t universally pleasant.

They have friction.

Labubu is a useful example because its appeal isn’t built entirely around conventional cuteness. The character is mischievous, slightly strange and, depending on whom you ask, either adorable or hideous.

That tension is part of what makes it distinctive. It gives people something to react to. The same principle appears across decades of successful mascot design.

Chester Cheetah has swagger. Duo has become a vaguely threatening internet personality. Even the Michelin Man has a strange, imposing physical presence.

These characters aren’t simply nice. They have an attitude.

Jolly, by comparison, is almost aggressively agreeable. Soft. Friendly. Approachable. Pleasant.

He looks like the physical manifestation of a reassuring onboarding message.

And that isn’t necessarily bad. Meta is introducing a new kind of product to an enormous audience. A deliberately nonthreatening character makes sense.

But there’s a trade-off. The safer you make a character, the fewer edges it has for people to become attached to.

Maybe Jolly isn’t too cute. Maybe Jolly just needs an opinion.

CAN SOMETHING BE TOO APPROACHABLE?

There’s another reason to question the design beyond personal taste.

Muse isn’t merely a friendly chatbot.

It’s a system designed to act with increasing independence.

It can retain context, perform research, work through tasks and interact with services on a user’s behalf, depending on the capabilities and permissions available.

That creates a relationship involving trust, judgment and delegation. And the character representing that relationship is a fuzzy little creature with rosy cheeks.

There’s an interesting tension there.

The visual design says safe, harmless, friendly.

The underlying technology says increasingly capable, increasingly autonomous, potentially consequential.

Those messages aren’t necessarily incompatible. A friendly interface can make complex technology easier to use. But friendliness can also influence how users perceive risk.

We tend to interpret warmth, familiarity and expressive behaviour as social signals. When a product looks like a companion, it’s easier to relate to it as one.

That may help users feel comfortable enough to explore unfamiliar capabilities. It may also encourage them to feel more comfortable than the system’s actual reliability warrants.

The concern isn’t that Jolly is secretly manipulating everyone with his adorable little face. It’s that a friendly visual identity and a trustworthy autonomous system are not the same thing.

And making a wait feel shorter isn’t the same as making the system faster.

There’s nothing inherently manipulative about making software delightful. Good interaction design has always considered how an experience feels, not just whether it functions.

The distinction is whether that delight supports an accurate understanding of what’s happening or replaces it with a comforting performance.

A character can reassure me that work is underway.

It shouldn’t be the only evidence I have.

DID WE SCIENTIFICALLY DISCOVER OATMEAL?

I keep wondering how much of Jolly’s personality is the result of trying to create something nobody would object to.

I have no idea how Meta actually arrived at the final design. This is a thought experiment, not a claim about its research process.

But imagine a character being tested against an enormous audience.

Some people dislike sharp features, so you soften them. Some find exaggerated expressions unsettling, so you reduce them. Some dislike aggressive personalities, so you make the character agreeable. Some dislike anything too childish, too strange, too sarcastic, too emotional or too distinctive.

You keep removing whatever creates resistance.

Eventually, you arrive at a soft, friendly, nonthreatening creature with almost no discernible attitude.

Congratulations.

You’ve scientifically discovered oatmeal.

And oatmeal is fine. Oatmeal is dependable. Oatmeal is unlikely to offend anyone.

But the character nobody hates isn’t necessarily the character anybody loves.

Again, this may be exactly the right compromise for a mass-market AI product.

I just wonder whether Meta has optimized Jolly for the first five minutes of interaction rather than the next five years.

Because those are very different design horizons.

CLOCK ONE: CULTURE

There are three different clocks running underneath this design decision.

The first is cultural.

Visual trends change.

Characters that feel contemporary today can become dated surprisingly quickly, especially when they’re closely associated with a particular aesthetic moment.

Jolly’s soft proportions, tactile surfaces, playful accessories and almost collectible-toy appearance feel very much of the current character-design landscape.

That doesn’t mean Meta copied Labubu, or that Jolly will disappear when the current appetite for cute collectibles changes.

It’s simply a reminder that cultural relevance isn’t permanence.

Successful mascots can evolve. Some become iconic precisely because their core identities survive multiple design eras.

But Jolly isn’t just a mascot. He’s also an interface element.

And interface elements have to survive more than changing fashion.

They have to survive changing usage.

CLOCK TWO: FAMILIARITY

The second clock is familiarity.

When you first encounter a new kind of software, visual explanation is valuable. A character can help you understand what the system is doing.

It can reduce uncertainty, create recognition and make an unfamiliar workflow feel approachable.

But what happens after a thousand interactions?

At some point, you understand the system. You know what it means when Muse is working. You know when it’s waiting. You know when something has finished.

The character’s novelty has worn off.

That doesn’t mean its value disappears. Familiarity can create attachment. People may grow more fond of Jolly over time, not less.

And even an experienced user can benefit from an entertaining animation during an unpredictable wait.

That’s something I underestimated initially.

The value of the character doesn’t necessarily decline with familiarity. It changes.

Initially, Jolly may help explain the system.

During active work, he provides reassurance and makes waiting more pleasant.

Over time, he may offer personality, continuity and a familiar presence.

Those are all legitimate purposes, but they don’t necessarily require the same level of visual prominence.

If the character is there to teach me how agency works, perhaps he should become less prominent once I’ve learned.

If he’s there to make waiting enjoyable, perhaps he should become more expressive when work is underway.

If he’s there to build an ongoing emotional relationship, then his persistence becomes much more central.

Meta appears interested in all three.

I’m not convinced those goals will always point toward the same interface.

Clippy walked so Jolly could run. Microsoft’s famously intrusive assistant became a cautionary tale in interface design: personality is delightful until it starts getting in the way.

CLIPPY WOULD LIKE A WORD

It’s tempting to compare Jolly to Microsoft’s Clippy.

Both are animated characters intended to make software feel more approachable. Both attempt to give a computer interface a recognizable personality. And both exist in the complicated territory between helpful assistant and unwanted office companion.

But the comparison has limits.

Clippy was notorious for interrupting people, making assumptions about their intentions and offering help they didn’t necessarily want.

Jolly, in my experience, is far less intrusive.

He doesn’t repeatedly jump into the conversation with unsolicited tutorials.

He’s mostly a visual presence. So I don’t think it’s fair to call Jolly the next Clippy.

The more useful lesson from Clippy is that an interface character has to earn its presence through utility.

Being recognizable isn’t enough.

Being friendly isn’t enough.

Even being technically impressive isn’t enough.

The character needs to make the experience better in ways users continue to appreciate.

And making an unpredictable wait more enjoyable absolutely counts.

The mistake would be assuming that because a character improves one part of the experience, it needs to occupy every part of it.

CLOCK THREE: CAPABILITY

The third clock is the most important.

Capability.

AI agents are becoming more able to do things that matter.

Researching a topic is one level of responsibility.

Organizing a schedule is another.

Making purchases, managing communications, working with sensitive information or taking actions that affect other people introduce entirely different levels of consequence.

The more capable an agent becomes, the more important it is that users understand what it’s doing, what it’s allowed to do and when they need to intervene.

This is where I start questioning whether a cute character is sufficient as the primary representation of agency.

Not because serious technology has to look serious.

That’s an aesthetic assumption, not a design principle.

But because increasingly consequential behaviour demands increasingly precise communication.

A little creature typing away is a charming representation of activity.

It’s not necessarily a meaningful representation of authority, uncertainty, permission or risk.

Those require explicit interface design.

Jolly can coexist with that design, of course.

In fact, his animation may be an excellent way to reassure users during uncertain processing time, while other interface elements communicate exactly what is happening.

The concern is whether the character becomes a substitute for clarity rather than a supplement to it.

Agency is behavioural. Presence is perceptual. Embodiment is a design choice.

And the more consequential the behaviour becomes, the more carefully that choice needs to be evaluated.

TUX DOESN’T MOUNT YOUR FILESYSTEM

Linux has Tux. Android has Bugdroid. Reddit has Snoo.

These are recognizable mascots attached to products and platforms with enormous technical complexity.

Nobody expects Tux to personally manage their operating system. Nobody assumes Bugdroid is making decisions inside their phone.

The characters represent the products without pretending to be the products’ active intelligence.

That’s an important distinction.

Jolly is different because Meta places him inside the interaction itself.

He doesn’t merely represent Muse in advertising. He appears to be Muse while Muse is doing things. The mascot and the agent are visually fused.

And that creates a new set of design responsibilities.

A traditional mascot can be charming, memorable and a little absurd without needing to explain the state of a live system.

An interface character has to communicate. An embodied agent has to perform.

Which brings us to the part of Jolly I find most difficult.

WHEN THE MASCOT STARTS ACTING

I’ve watched demonstrations of Muse’s conversational avatar, although I haven’t personally used that mode yet due to limited availability.

In those demonstrations, Jolly becomes much more animated. He moves, gestures, shifts his weight and synchronizes his mouth with speech.

It’s technically impressive. It’s also a little cheesy.

Not disastrously uncanny, but close enough to the territory that I start thinking about the performance rather than the conversation.

A static character can suggest a personality.

An animated character has to sustain one.

Once you give something eyes, you create expectations about attention.

Give it hands, and users start interpreting gestures.

Give it a mouth, and suddenly the quality of its speech performance becomes part of the interaction.

Give it a body, and its movement starts communicating emotional and social information whether you intended it to or not.

Embodiment accumulates obligations.

Every additional humanlike or creaturelike feature introduces another dimension the design has to get right.

That’s why abstract representations can be so effective.

A glowing orb doesn’t have to make believable eye contact. A pulsing shape doesn’t have to gesture naturally.

Give the orb a mouth and suddenly it has a performance review.

Jolly’s conversational embodiment may become more convincing as the technology improves. But it also raises a fundamental question.

How much performance does a user actually want from their AI assistant?

JOLLY MIGHT BE SKEUOMORPHISM FOR AGENCY

Here’s the comparison I keep coming back to.

Skeuomorphism.

Early digital interfaces borrowed visual language from physical objects because people already understood those objects.

• A desktop had folders.
• A trash can held deleted files.
• A digital notebook looked like a paper notebook.

Those metaphors helped people understand unfamiliar interactions.

Eventually, many of the decorative details disappeared as users became more comfortable with digital systems.

We didn’t necessarily abandon the underlying metaphors. We just stopped needing every interface to look like its physical equivalent.

Jolly may be doing something similar for autonomous computing.

People understand creatures.

They understand that a creature can be busy, waiting, thinking, responding or helping.

So Meta represents a complex agent through a familiar social metaphor.

The little guy is doing it.

That’s skeuomorphism for agency.

Instead of borrowing the appearance of a physical office object, the interface borrows the appearance of a living entity.

And just as early digital interfaces eventually shed some of their physical decoration, perhaps autonomous interfaces will eventually shed some of their simulated embodiment.

Not because the metaphor was bad.

Because it worked.

It helped users learn something new.

But there’s an important difference.

A decorative leather texture on a digital calendar doesn’t necessarily provide lasting functional value.

An entertaining animation during an unpredictable wait might.

So perhaps the future isn’t about removing the character once people understand the system.

Perhaps it’s about keeping the parts of embodiment that continue to improve the experience and allowing the rest to recede.

THE IPHONE ALSO MANAGED TO BE COOL

There’s another dimension to this that doesn’t get discussed enough.

Taste.

Technology doesn’t have to be visually sterile to feel sophisticated.

Apple demonstrated that consumer technology could be approachable, intuitive and emotionally appealing without making every interaction revolve around an animated mascot.

The iPhone was friendly without being childish.

It made complex computing accessible through direct manipulation, responsive behaviour and an interface people could learn by using.

That wasn’t a rejection of personality.

It was a different expression of personality.

And it’s worth remembering because the argument for Jolly can sometimes sound as though the only alternatives are cold enterprise software or an adorable creature.

There is an enormous design space between those extremes.

An AI interface can be warm without being cute.

Expressive without being anthropomorphic.

Distinctive without being a character.

And approachable without constantly reminding users that it has a little face.

I don’t think Jolly is inherently uncool.

I do think Meta has made a strong aesthetic commitment that may not align with how every user wants to relate to increasingly powerful software.

MAYBE CUSTOMIZATION IS WHERE THE PERSONALITY LIVES

This is where my opinion changed again.

Muse lets users customize the character representing their agent.

And I don’t just mean choosing a hat.

I started experimenting with how far the system would let me go.

I tried replacing Jolly with Cody, the character associated with Frank Ocean’s Homer campaign. The result looked reasonably close, but the animation was limited. Mostly a static character with some strange visual effects.

Apparently, Jolly’s appearance is negotiable. I asked Muse to recreate Cody from Frank Ocean’s Homer campaign, and it obliged. The agent stayed the same, but its identity became something entirely different. Which raises an interesting question: if you can replace Jolly, how essential is he to the interface?

Then I tried Chester Cheetah. That worked considerably better. A recognizable Chester, animated as my AI assistant.

I pushed Muse’s customization further by asking for Chester Cheetah. It generated the recognizable mascot and animated him as my AI assistant. When users can replace Jolly with someone else’s intellectual property, character customization starts raising questions about brand ownership, copyright and where the boundaries should be drawn.

I tried the Michelin Man, using only the character’s name rather than supplying a reference image. That worked too.

From Jolly to Bibendum. I asked Muse to turn its assistant into the Michelin Man, and it generated a working avatar complete with headphones and a laptop. The character changes, but the agent keeps doing its job. Another reminder that Jolly might be the default appearance rather than an essential part of the interface.

Pikachu was recognizable. Jessica Rabbit was accepted. Eventually, I managed to create a fully animated character combining Mario’s head with Jessica Rabbit’s dress… and body.

Things escalated. Muse let me combine Super Mario and Jessica Rabbit into a functioning AI avatar, complete with a working animation. The result is ridiculous, but the design question is serious: if an agent can wear virtually any identity, what role does its original mascot actually play?

At one point, I asked Muse what pronouns the resulting character used.

“He/him,” it replied. “The head’s Mario, and the head’s where the person lives. The dress is just fashion.”

I don’t think any design research methodology could have prepared me for that sentence.

The experiments also revealed boundaries.

Muse refused to reproduce the exact likeness of a real actor. It rejected certain revealing character designs, while accepting others. Its explanations weren’t always particularly illuminating.

And when I asked whether using Chester Cheetah created copyright concerns, Muse confidently assured me that my private use was fine, then reminded me that I wasn’t exactly an innocent bystander because I’d requested the character.

The legal implications are more complicated than Muse’s reassurance suggested. But that’s probably another article.

The design discovery was more relevant.

Jolly is Meta’s mascot, but he doesn’t have to be the appearance of your personal agent.

That’s an important distinction.

Meta can retain a consistent public-facing character across advertising and social media while letting users choose a different embodiment inside the product.

The brand identity remains recognizable.

The personal experience becomes customizable.

And perhaps that’s how Meta reconciles the problem of making Jolly appealing to an enormous audience without making him particularly distinctive to any one person.

The default character can be broadly agreeable because users are free to bring their own taste.

There’s another wrinkle, though.

Changing Muse’s appearance didn’t fundamentally change the intelligence underneath it.

Chester Cheetah didn’t suddenly acquire Chester Cheetah’s swagger.

Mario wearing Jessica Rabbit’s dress didn’t become a new personality with a coherent fictional backstory.

The agent was still Muse.

And, somewhat unexpectedly, Muse’s conversational personality was often more distinctive than the personality of its default avatar.

It could be cheeky, defensive, oddly philosophical and occasionally very funny.

Which raises a better question than whether Jolly needs more attitude.

Does the character need to express the agent’s personality, or is it simply a customizable costume worn by the same intelligence?

Those are two very different models of embodiment.

LET THE RELATIONSHIP GROW UP, NOT JOLLY

If Jolly is useful for introducing people to autonomous agents, perhaps the interface should evolve as the user becomes more experienced.

I’m not suggesting Meta should literally age him.

Nobody needs Jolly entering his divorced-dad era because you’ve completed 500 tasks.

I mean progressive embodiment.

At first, Jolly might be prominent. He helps users understand what Muse is doing. He provides a recognizable focus for unfamiliar interactions.

As users become more comfortable, perhaps he becomes smaller. Maybe he retreats to the edge of the interface. Maybe he becomes more expressive when work is underway and less prominent when nothing needs attention.

Or perhaps users become more attached to him and want the opposite. That’s entirely possible.

The important thing is that the product should be capable of adapting to the relationship rather than assuming the relationship will remain the same forever.

We already accept progressive disclosure in interface design. Advanced tools reveal complexity as users become ready for it.

Why shouldn’t embodiment work similarly?

The amount of character a user needs on day one may not be the amount they want on day one thousand.

And the amount they want while waiting for a web search may not be the amount they want while reviewing a consequential decision.

The distinction becomes even clearer when you consider different kinds of agent activity.

During onboarding, Jolly can explain unfamiliar behaviour.

During active work, he can provide reassurance and delight.

During long-running background work, a notification may be more useful than an animation.

During consequential decisions, explicit information and controls become more important than personality.

None of those situations requires Jolly to disappear.

They simply ask different things of him.

A mascot needs to stay recognizable.

An interface needs to stay appropriate.

PRESENCE WITHOUT A BODY

This is where the emerging alternative represented by OpenAI’s Dots becomes particularly interesting.

OpenAI’s Dots take a different approach to giving AI agents personality. No humanoid bodies, expressive hands or elaborate animations. Just abstract shapes with enough character to feel distinct. It’s a compelling alternative to Jolly’s full-body approach: presence without anatomy.

Dots give autonomous agents recognizable identities without necessarily turning them into simulated creatures.

A named abstract shape can establish continuity. It can be visually distinctive. It can communicate activity.

But it doesn’t carry the same expectations as a character with eyes, hands, a mouth and a personality implied by its anatomy.

It’s presence without anatomy.

That may offer advantages as agents become more capable.

An abstract identity can change scale, colour, motion or emphasis depending on context without needing to maintain the illusion of a living creature. It can be expressive without performing.

Of course, abstraction has its own weaknesses.

It can feel impersonal. It can be harder to remember. And it may lack the immediate emotional appeal of a character like Jolly.

There’s also no reason an abstract shape couldn’t become an entertaining loading animation. Delight isn’t exclusive to characters with faces.

I’m not arguing that Dots have solved the problem.

I’m arguing that the problem has more than two possible answers.

And we’re only beginning to explore them.

THEN MUSE KEPT WORKING

The most convincing thing Muse did during my time with it had nothing to do with Jolly.

I was researching this very article.

Muse asked about my goals and started helping me gather information. I gave it some direction, reviewed what it produced and moved on.

Then, the following morning, it had continued working.

Without me opening the app to ask for another update, Muse returned with additional research and a sourcing summary.

Nine claims verified. Two flagged for further checking.

That was the moment the product became considerably more interesting to me.

Not because I could see a character working.

Because the software had actually behaved like an agent.

It remembered the task. It continued making progress. It identified uncertainty.

And it brought the results back when there was something useful to report.

The experience wasn’t perfect. Its claims still needed independent verification, and a confident research summary isn’t a substitute for checking sources.

But the interaction demonstrated the value of agency more effectively than any amount of character animation could have.

I didn’t need to see Jolly typing to understand that Muse had been working.

The work itself communicated that.

And that shifted my thinking.

Perhaps the strongest expression of autonomous intelligence isn’t a persistent visual presence.

Perhaps it’s the experience of something useful happening when you weren’t actively directing it.

That doesn’t diminish the value of Jolly’s animations during active tasks.

It helps explain why they work in some moments and matter less in others.

When I’m waiting, feedback matters. When I’ve delegated something and walked away, results matter.

Good agent design needs to understand the difference.

RELATING TO INTELLIGENCE OR WIELDING IT

There are two different relationships emerging between people and AI.

One is social.

We talk to the system. We give it a name. We recognize its personality. We develop expectations about how it behaves.

The other is instrumental.

We give it goals. We delegate tasks. We review its work. We decide how much authority to grant it.

Neither relationship is inherently wrong. And they aren’t mutually exclusive.

A good assistant can be personable and useful. But they create different design priorities.

A socially oriented interface benefits from familiarity, expression and emotional continuity.

An instrumentally oriented interface benefits from precision, transparency, control and predictable behaviour.

The challenge is designing for both without allowing one to undermine the other.

Jolly is very good at making Muse feel like someone you can relate to. His animation can make waiting more pleasant. Muse’s proactive behaviour is what makes it feel like something you can actually use.

As the technology becomes more capable, I suspect the second quality will become increasingly important.

That doesn’t mean the first should disappear.

It means the interface has to know when each one matters.

THE EXPERIMENT HAS ALREADY STARTED

I started using Muse expecting to write an article about why Meta had made its AI unnecessarily cute.

That would have been an easier article.

And probably a worse one.

Because Jolly is good design.

He’s distinctive, approachable and more restrained in the actual product than the marketing initially led me to expect.

He gives unfamiliar agent behaviour a recognizable visual identity.

He makes a complex new interaction model easier to understand.

And, as I discovered through continued use, his animations make certain kinds of waiting genuinely more enjoyable.

That’s not a trivial benefit.

An agent that works unpredictably needs to communicate what it’s doing, and a delightful character can make that uncertainty easier to tolerate.

Meta has also been more thoughtful about separating its public-facing mascot from users’ personal avatars than I initially realized.

The customization experiments revealed a surprisingly flexible embodiment system, even if the boundaries around that flexibility aren’t always clear.

And the agent itself turned out to have more personality, and considerably more practical value, than its soft little mascot suggested.

My concern isn’t that Meta made Jolly.

It’s that the company may be making a long-term interface commitment around a character whose value will change as people become more familiar with autonomous software.

The cultural appeal of the character will evolve. The user’s familiarity with the system will evolve. The system’s capabilities will evolve.

And those three clocks won’t necessarily move together.

Maybe Jolly becomes an enduring icon. Maybe users develop deep attachments to their customized companions. Maybe future interfaces become so adaptive that the question of whether a character should remain visible is resolved differently for every person, device and task.

All of those outcomes are plausible. But I keep returning to the same distinction.

Making intelligence feel present is not the same as making its actions understandable.

And making intelligence feel friendly is not the same as making it trustworthy.

The best design will need to do more than make the agent lovable.

It will need to help people understand what the agent can do, what it’s doing now, what it has done and when they should be paying attention.

Sometimes that might mean an expressive little creature making an unpredictable wait more pleasant. Sometimes it might mean a clear status update. Sometimes it might mean getting out of the way entirely and sending a notification when the work is finished.

Meta may be right about Jolly and wrong about permanence.

The real question isn’t whether an autonomous AI can benefit from having a little body.

It’s whether that body continues to earn its place as the intelligence behind it becomes more familiar, more useful and more consequential.

Not whether Jolly can make agency feel alive.

Whether Jolly knows when the agency no longer needs him to.

The Little Guy-ification Of AI was originally published in Bootcamp on Medium, where people are continuing the conversation by highlighting and responding to this story.