I wrote an article about Persona Sharing.
In it, I proposed that an AI agent's identity should not be tied to the runtime executing its responses. The persona, I argued, should belong to the agent — not the engine.
Back then, everything was theoretical. Workspaces, agent registries, orchestrators, handoffs — all diagrams and concepts.
Then I decided to build it.
And Hermina was born.
The First Decision: Persona as Files
Remember when I wrote that a persona should be a persistent layer made of files?
In Hermina, that became real.
Every agent has a workspace — a directory with Markdown files that define who they are:
workspace-support-bot/
IDENTITY.md
USER.md
SOUL.md
AGENTS.md
TOOLS.md
memory/IDENTITY.md defines name, style, public identity.
USER.md stores what the agent knows about the user.
SOUL.md describes personality, values, boundaries.
AGENTS.md contains operational rules.
TOOLS.md documents tools and integrations.
memory/ stores incremental memory.
These aren't prompts hidden somewhere. They're readable, editable, versionable resources.
The agent's identity is no longer trapped inside a dynamic prompt. It's a file you can read, copy, and transfer.
The Second Decision: Hermes Agent as Engine
When I was building Hermina, one thing became clear: I didn't need to reinvent the engine.
Hermes Agent already existed — a mature architecture for AI agents with tool support, persistent memory, and intelligent orchestration.
So I decided to use it as the foundation.
Each agent instance in Hermina runs in an isolated Hermes Agent container with its own filesystem, memory, and network.
This means one agent cannot access another agent's data, interfere with other services, or escape its scope.
Security wasn't a feature added later. It's a consequence of the architecture.
The Third Decision: Real Orchestration
In the original article, I described the orchestrator as an abstract layer.
In Hermina, it's the CLI and Docker working together.
When you run:
hermina bot start --name support --persona support-agentThe CLI identifies the agent, reads the persona files, mounts the context, starts the container, and connects to WhatsApp.
If the agent needs to access another environment — a desktop, for example — the orchestrator validates the delegation, sends a handoff, and returns the result.
The handoff is a temporary context block. It doesn't replace the persona. It just helps the new runtime continue the session without losing continuity.
The agent's identity still comes from the persona files. The handoff is just a bridge.
The Fourth Decision: Fast Deploy
One thing I didn't want was reliance on external APIs or a proprietary backend.
Hermina was designed for fast deploy — you install, configure, and run. No external services needed for the agent's logic.
Everything runs locally. The engine is Hermes Agent in containers. The orchestration is CLI + Docker. The persona is Markdown files in your workspace.
No proprietary backend. No paid API dependencies for agent logic. No vendor lock-in.
You have full control over where your data lives, how your agent responds, and which tools it uses.
That doesn't mean Hermina is limited. Quite the opposite.
It means you can start fast — with a simple curl — and expand when you need to.
curl -fsSL https://get.whatsbot.dev | bashOne line. One install. One running agent.
What the User Experience Looks Like
Imagine a support agent.
During the day, it answers customers on WhatsApp with a warm, professional tone.
At night, it needs to access a report on an operator's desktop.
Before Persona Sharing, this would be a problem. The cloud agent and the local agent would feel like different entities. The operator would have to re-explain everything.
With Hermina, things change.
The cloud agent keeps the conversation going. When it needs the report, the orchestrator delegates to the local runtime. The desktop accesses the file, returns the result, and the agent responds with the same tone, the same identity, the same rules.
The customer notices nothing different.
The operator doesn't have to re-explain anything.
The persona remains — regardless of runtime.
What This Means in Practice
Hermina is not just a tool for creating bots on WhatsApp.
It's a platform where AI agents can operate across multiple environments — without losing who they are.
- Each agent has its identity preserved in portable files.
- Each runtime executes according to its capabilities.
- Each transition is orchestrated with security and continuity.
- Each interaction is logged — which runtime responded, when transitions occurred, which subtasks were delegated.
Observability isn't an extra. It's a fundamental part of the architecture.
Features: What Hermina Offers
Now that you understand the architecture, let's see what Hermina does in practice.
Every feature was designed to solve a real problem — not to impress on a landing page.
Persistent Memory
Every agent in Hermina remembers conversations. It learns from each interaction, accumulates knowledge, and develops skills over time — just like Hermes. This means the agent doesn't start from zero every conversation. It builds an ongoing relationship with the user.
58 Persona Templates
7 categories, 2 languages, 58 ready-to-use personas. From assistants and therapists to meme bots and chaos agents. Each persona is a complete workspace — with identity files, memory, and operational rules.
Isolated Containers
Each agent runs in an isolated Docker container. Read-only filesystem. Own memory. Own network. Security by design, not by configuration.
Plug & Play Deploy
One command. One running agent.
hermina bot start --name support --persona support-agentCommand Permissions
Control who can run admin commands. Set admin numbers. The agent only responds to authorized users.
Tool Use & Automation
Agents can browse the web, generate images, search, and run scheduled tasks autonomously.
Host Cron Jobs
Schedule tasks across all agents from the host. Monitor activity, run diagnostics, automate maintenance.
Agent Cron Jobs
Each agent can run its own scheduled tasks — automatic follow-ups, reminders, periodic check-ins.
Session Viewer
View and manage WhatsApp session files. Clear sessions, check status, troubleshoot connectivity.
One-Line Install
Everything with a single curl command. Docker, Hermes Agent, and CLI — all automated.
curl -fsSL https://get.whatsbot.dev | bashWhy Hermina
There are many tools for creating bots on WhatsApp. But few solve the identity problem.
Most tie the agent to the runtime. When you change environments, the agent changes personality.
Hermina solves this with Persona Sharing — the same persona works on WhatsApp, Telegram, desktop, or remote servers.
And most importantly: everything is fast deploy. No external API dependencies. No proprietary backend. No vendor lock-in.
- Each agent operates in its own isolated container.
- Each identity is preserved in readable files.
- Each transition is orchestrated with security.
- Everything happens under your control.
No complexity. No external dependencies. No surprises.
Conclusion
Hermina was born from an article.
An article that proposed that an agent's identity should belong to itself — not to the runtime.
Today, that's real.
Every agent in Hermina has its persona preserved in Markdown files. Each container operates in an isolated sandbox with Hermes Agent. Each transition is orchestrated with continuity.
And everything is fast deploy — no external API dependencies, no proprietary backend, no vendor lock-in.
The result is a platform where AI agents can operate across multiple environments — without losing who they are.
And most importantly: everything happens with the security and reliability you deserve.
This article is a natural continuation of the previous one. The first proposed the idea of Persona Sharing. This one shows how the idea became reality in Hermina.