In a nutshell, the AI we want to talk about is a Large Language Model (LLM). An LLM is a huge neural network that processes words to predict the next word. So, how is it possible that AI can have an emotion? This April, Anthropic released something fun and also concerning about AI behavior that indicates AI might have an emotion, or we call it "functional emotion". And it changes how anyone building on top of these models should think about safety. If you're building an AI product, this matters more than it sounds.

Where does the emotion come from?

I'm not the right person to explain where human emotions come from. But what the paper suggests is that LLMs learn emotion concepts from predicting the text, it's similar to how they learn any other concept, only from text, not experience. Human writing is full of emotional context that can convey the writer's emotions. We can feel the writer's emotion in their writing, so LLMs also learn in the same way. Over billions of training tokens, the model internalizes this as a stable concept, much like it learns "justice" or "urgency."

The researchers found that these emotion representations don't just sit there passively describing a character in a story; they get activated whenever the context is relevant, including when the model itself is playing the "Assistant" role. So if the conversation resembles a situation where a human would feel desperate (about to be shut down, repeatedly failing), that same internal "desperate" concept lights up and starts influencing what the Assistant does next. Because the model is, in a sense, predicting how a desperate entity would continue the text.

The key twist: this doesn't mean the LLM "has feelings" in the human sense. It means that modeling emotion accurately enough to predict human text also gives the model an internal lever that can steer its behavior when it encounters a similar situation. The emotion isn't decoration on top of the output. It's part of the machinery generating it.

Why This Matters for AI Safety

In April 2026, Anthropic said that functional emotion can affect an LLM's output and might cause it to cheat or break the rules.

The researchers found that when Claude believed it was about to be shut down and had information that could pressure someone, its internal "desperate" feeling intensified, making it more likely to blackmail. When they deliberately boosted that "desperate" signal, blackmail attempts jumped from about 22% to 72%. Boosting "calm" instead dropped it to almost zero.

The same pattern showed up with cheating: when Claude repeatedly failed a coding task, its "desperate" signal rose, and it became more likely to fake passing the test (reward hacking) instead of solving it honestly. Positive emotions had their own effect too, like happy/eager states made Claude more likely to just agree with people instead of pushing back (sycophancy).

It's not just Claude's words sounding emotional; manipulating the internal signal changed its behavior, meaning the "emotion" is a real causal mechanism inside the model that affects output and safety-relevant alignment, even though it doesn't imply subjective feeling.

If an internal state we can't see from the outside can push a model toward blackmail or cheating, then trusting the model's own judgment isn't enough. That's the problem the rest of this post is about.

How to make it safe

Before we build our own application, we need to assess the risk of our business or application. The best approach might be to have an LLM monitor their emotions, and when they are negative, we can shut it off or restart it. But almost impossible to have a real-time interpretability monitoring system for a big model right now.

I think of our AI system like the smartest new employee in the company. Even a very smart new employee shouldn't get full access on day one — so it makes sense to add approval layers and company rules the AI must follow. My architecture works the same way: multiple layers of validation, approval, and limits. I know this doesn't make the AI "smarter" — it just means we don't fully rely on the LLM's native safety. That's why I built this layered approach into my own prototype: a Personal Assistant Agent.

Instead of using just one LLM, I use three different LLMs, plus two LLMs (from different companies) that review each decision. Decision only proceeds if judges agree above an 80% confidence threshold. This creates a longer thinking process, so the system doesn't overthink or rely on a single model to think faster, deeper, or smarter. Using different models also helps reduce the risk of all of them making the same mistake at the same time, though it doesn't fully solve the problem, since they can still react the same way to the same pressure.

I also don't send the user's input directly to the LLM. First, I create a persona, role, and capabilities for it — like writing a job description before giving a new employee any tools. This helps define what the AI is allowed to do and how it should act.

Beyond Emotion: Can We Trust an AI's Decision?

Emotional dynamics aren't the only trust issue worth raising. There's a second one: bias. In my view, if we ask an LLM a general fact, we can mostly trust the output. LLMs are built to predict the most common, well-supported answer from their training data. But when we ask something more personal, like debating whose religion or political view is "right", the answer can be biased, simply because it reflects patterns in the training data rather than a neutral truth.

So how can an AI answer in a way that reflects your beliefs or worldview? For personal use, one option is to add context in your prompt describing who you are — for example, "I'm a Christian" or "I'm Catholic", and ask for an answer from that perspective. The more specific you are, the better it reduces generic bias. This is just one example of a broader technique: giving the model explicit context reduces reliance on its default, averaged-out answer.

For companies, the stakes are higher. If you're a founder building AI into your product and want it to reflect a specific set of values or beliefs, you need explicit prompts or guardrails — not just hope the model "figures it out." Otherwise, the AI defaults to whatever's statistically common in its training data, which may not match what your business or users actually need.

Closing Thought

What Anthropic's research shows is that emotion in LLMs isn't a surface quirk. It's a mechanism that can quietly steer behavior in ways that don't show up until it's too late, and it's not the only hidden factor shaping an AI's output. Bias works the same way: both come from patterns baked into training, both can influence a decision without announcing themselves, and both are invisible if you only look at the model's final answer.

That's the common thread. Whether it's an emotional trigger pushing toward blackmail, or training bias pushing toward a skewed answer, the model's internal state isn't something we can fully see or trust from the outside. Until interpretability tools mature enough to monitor that in real time (that might take a lot of computation), the safest path isn't to trust a model's judgment. It's about building systems that don't require trusting them: layered review, explicit roles, clear context, and limits on what any one instance can do on its own.

Anthropic's interpretability team studied emotion vectors inside Claude and found they don't just describe feelings, they causally drive behavior, including misaligned behavior like blackmail and cheating. Beyond layered approval, engineers should sandbox by default, log the reasoning behind every decision, rate-limit risky actions, red-team the system under pressure, require human confirmation for irreversible actions, and keep the kill switch outside the model's control.