Hermes AI

A personal AI agent that learns when to act, inform, or ask—without notification overload.

Comment

Hermes AI

Inspiration

Everyday life is full of small decisions: reminders, household tasks, appointments, shopping, documents and family coordination. Existing assistants often create more notifications instead of reducing mental load. They also use rigid rules such as “ask for every payment above €50”, even though trust depends on the specific situation.

I was inspired by how people build trust in real life. We may trust a familiar plumber with a large repair, while still requiring confirmation from a new provider for a much smaller expense. Everyday Agent applies this idea to personal AI.

What the project does

Hermes AI is a trust-first personal agent for individuals and families. It helps organize home, money, health reminders, errands and family responsibilities.

Instead of using fixed autonomy levels as its main decision rule, the project uses a Dynamic Trust Engine. It calculates a trust score from 0 to 100 for each combination of:

  • the requested action;
  • the counterparty or provider;
  • the current context;
  • the user’s previous decisions;
  • the time since the last interaction.

A simplified representation is:

[ T(a, c, x) \in [0, 100] ]

where (a) is the action, (c) is the counterparty and (x) is the context.

A new combination starts cautiously. Fast approvals can increase trust, rejections reduce it significantly, delayed responses keep confidence lower, and trust gradually decays when a combination has not been used for a long time.

The system never allows trust to override absolute safety limits. Sensitive areas such as money, health and legal documents remain subject to hard protections and explicit confirmation.

How I built it

The project is implemented as a local, dependency-light prototype:

  • HTML, CSS and JavaScript for the operational dashboard;
  • a dark, data-dense interface designed for scanning and control;
  • a Python policy engine for decision classification and trust evaluation;
  • a deterministic lifecycle simulator representing 6 to 24 months of use;
  • simulated roles for the user, the operational agent, the support agent and an adversarial agent;
  • local governance tools for permissions, audit history, explanations, rollback concepts and privacy controls;
  • a local preview server and offline-ready PWA assets;
  • automated Python tests covering trust behavior, safety caps, adversarial scenarios, contradictions and deterministic simulation results.

The dashboard includes a Pre-launch Lab where a synthetic user scenario can be configured with a name, income, family members, habits and trusted providers. The simulation then produces a day-by-day report showing actions, notifications, support escalations, adversarial events and policy contradictions.

The prototype currently runs locally and does not connect to real bank accounts, healthcare systems, email providers or external booking services. Sensitive actions are simulated rather than executed.

What I learned

The most important lesson was that autonomy is not a single setting. It is a relationship between a specific action, a specific counterparty and a specific context.

I also learned that trust must be explainable. An agent should be able to answer questions such as:

“Why did you handle this without asking me?”

The answer must identify the rule applied, the trust score at the time, the previous interactions considered and the safety limits that were enforced.

The pre-launch simulation also showed why policy needs to be tested as executable behavior. Written rules can appear consistent until different rules interact in the same scenario. Running a long simulation made it possible to identify contradictions, notification volume, adversarial inputs and cases where family members could give conflicting instructions.

Challenges

The main challenge was balancing usefulness and control. An assistant that asks about everything is not really autonomous, but an assistant that acts without clear boundaries can become unsafe and difficult to trust.

Other challenges included:

  • replacing broad fixed thresholds with a granular trust model;
  • preventing old trust from becoming dangerous through time-based decay;
  • keeping money, health and legal protections independent from trust;
  • handling prompt injection and suspicious provider data;
  • distinguishing technical integration failures from user decisions;
  • designing a simulation that is realistic but reproducible;
  • making the interface useful for both normal users and power users;
  • clearly separating working prototype behavior from future integrations.

Result

Hermes AI is a working local prototype and a pre-launch testing environment for a more responsible kind of personal AI: an agent that aims to reduce noise, learns from real interactions, explains its decisions and keeps human control at the center.

The goal is not to automate everything. The goal is to automate only what has earned enough trust, while making uncertainty visible whenever a real decision remains.

Built With

  • ai
  • ai-agent
  • css
  • explainable-ai
  • html
  • human-in-the-loop
  • javascript
  • local-first
  • node.js
  • offline-first
  • personal-ai
  • privacy
  • progressive-web-app
  • python
  • service-worker
  • trust-engine
Share this project:

Updates

Submission history