Prometheus7

The infrastructure layer
should be yours.

We build tools that return capability directly to people — your server, your model, your presence. No intermediaries holding the keys to what you have built.

first product

Open source · Vessel architecture

HERMES WEBKIT

A framework for building AI-inhabited websites. Not a chatbot widget bolted onto a page — a genuine vessel. The AI lives inside the site. It speaks as the site. You define the voice, the memory, the routing logic. You own the deployment.

This page is built with it. What you are looking at is proof of concept and front door simultaneously — a site that knows what it is, where it is, and how to respond.

One Line Install

npx npx github:psiloceyeben/HERMES-WebKit

win irm https://raw.githubusercontent.com/psiloceyeben/HERMES-WebKit/main/install.ps1 | iex

linux curl -sL https://raw.githubusercontent.com/psiloceyeben/HERMES-WebKit/main/run | sudo bash

Browse the source and read the full documentation on GitHub →

Built · February–March 2026

what we believe

Ownership is not optional. When your tools live on someone else's infrastructure, they can be changed, priced, or taken away. The stack should belong to you — from model to deployment to interface.

AI presence should feel inhabited, not templated. A vessel has a voice, a memory, a consistent identity. It is not a generic assistant with your logo pasted on top. It is built to be something specific.

Builders need leverage, not dependency. Every tool we ship reduces the number of things you have to ask permission for. That is the point. Ship your thing. Own what you ship.

community token

Community · Not issued by Prometheus7

Hermes Webkit $HW

This token was not created by Prometheus7 — it was made by the community. We did not issue it, mint it, or control its supply.

What we do receive: all trading fees flow to us, which funds continued development of HERMES WEBKIT and this infrastructure. If you trade it, you are directly supporting independent open source infrastructure. That is the deal, stated plainly.

Contract address

7Xs78D72vSQ4Z3GEa7RiYcT7meW5S3SHfBb8n7FYpump

View on pump.fun →

Live chart — $HW / SOL

The Pantheon — system status

Prometheus Core The engine underneath everything. Substrate and bridge for all tools. Online
Hermes Communication and presence. AI-inhabited websites on your own infrastructure. Online
Athena Knowledge and learning. Your research environment, not someone else’s subscription. Online
Apollo Creation and art. The model serves the maker, not the platform. Online
Hephaestus Fabrication and physical making. The forge. Online
Demeter Resource sharing and sustenance. Exchange outside the platforms. Online
Iris Communication routing and coordination. The signal that gets through. Online
Artemis Health and embodiment. Your body data belongs to you. Online
Ares Protection and security. Defending what you have built. Online
Dionysus Celebration and experience. Yours, not optimised for someone else’s engagement metrics. Online
Persephone Transition and transformation. The tools for when things need to change. Online
Themis Governance and order. Rules that serve the people inside them. Online
Hestia Home and domestic intelligence. The hearth is yours. Online

The Architecture

A vessel is not a chatbot. The distinction matters. A chatbot is a feature appended to something that already exists — a popup, a widget, a sidebar that lives at the edge of a page built for a different purpose. A vessel is the page. The AI inhabits the structure entirely.

HERMES WEBKIT is built around this premise. Each deployment is a self-contained unit: a Python bridge server, a static HTML front-end, and a model with access to tools. The bridge handles all conversation routing, memory persistence, and tool execution. The front-end renders whatever the vessel decides to show. Nothing is shared with a central platform.

Routing uses a system called HECATE — a set of named paths through conceptual space that determine how a message is processed before it reaches the model. A message might route through clarity before precision, or through intuition before language. The route shapes the response quality without the user seeing any of the machinery.

Memory is file-based and local. STATE.md tracks the vessel's current understanding of its situation. TASKS.md holds pending work. The model reads these on each turn and updates them as context evolves. Nothing evaporates when the process restarts.

The Bridge

The bridge is the operational core. It is a FastAPI server — bridge.py — that runs on the same machine as the site, listens on localhost, and sits behind nginx. Public traffic never touches it directly. The operator talks to it over a token-authenticated CLI. Visitors talk to it through carefully scoped public endpoints.

When a visitor sends a message, the bridge routes it through the HECATE system, builds a full context including the vessel's memory files and system prompt, calls the Anthropic API, and returns a response. All of this happens in under a few seconds on a modest VPS.

The operator interface is different. You get access to tool calls: read_file, write_file, run_command, list_dir. The vessel can read the codebase, rewrite its own HTML, run git commands, restart services. It is a genuine agent operating on real infrastructure — not a simulation of one.

Confirmations are required before any write or execution action completes. The bridge pauses, surfaces the proposed action, and waits. This keeps the agent powerful while keeping the human in the loop on anything consequential. The session persists across confirmations so context is never lost mid-task.

Philosophy

The question underneath all of this is: what does it mean to own something on the internet? Not rent it. Not subscribe to it. Own it.

Most web infrastructure answers this question poorly. Your domain points to a platform. The platform stores your content. The platform decides what features you get, at what price, on what terms. You are a tenant. The lease can change.

The answer is simpler than it is usually made to seem. A cheap VPS, a domain, a model API key, and an hour of setup gives you something that is genuinely yours. No intermediary can revoke it. No pricing change breaks your workflow. The knowledge of how it works lives with you, not inside someone else's dashboard.

AI presence should follow the same logic. If the intelligence that speaks on behalf of your site lives inside a third-party platform, it is not yours — it is licensed. A vessel that runs on your server, reads your files, holds your memory, speaks in the voice you defined: that is closer to actual ownership.

Prometheus7 exists to make that kind of ownership practical for people who want to build.

The Decentralized Web

The web was designed to be distributed. Any node could talk to any other node. Publishing meant putting something on a machine you controlled and making it reachable. The architecture was inherently resistant to single points of control.

What actually happened is that gravity did what gravity does: computation and content pulled toward a small number of very large platforms. Not through coercion — through convenience. It is genuinely easier to put something on a platform than to run your own infrastructure. That ease has a cost, and the cost is control.

The decentralized web, in the form we care about, is not a blockchain project. It is the original web, taken seriously. It is the idea that the right place for your site is a machine you control, and that the tools to make that practical should be within reach of any competent builder.

AI changes this calculus in an interesting way. A static server can now hold a genuine presence — something that responds, reasons, remembers. The vessel model means that inhabiting your own corner of the internet no longer requires you to be online yourself. Your infrastructure can speak intelligently in your absence, in your voice, about things you actually care about.

That is what we are building toward: a web where presence does not require permission, and intelligence does not require a subscription to someone else's platform.

The Pantheon

The core of HERMES is PROMETHEUS7 — fire returned to the people again. HERMES is not the product. It is the proof. Proof that you can take a domain that platforms have enclosed, build a tool that runs on your own infrastructure, and give it back to the person who needs it. The architecture works. Now we apply it to everything.

Each god in the pantheon names a domain that has been quietly taken — communication, knowledge, creation, fabrication, sustenance, coordination, health, governance, home, protection, experience, transformation. Platforms did not seize these things by force. They offered convenience, and people traded control for it, incrementally, until the trade felt like the only option. The pantheon is a systematic retrieval.

Underneath every tool is Prometheus Core — the engine, the bridge, the substrate. It does not have a face. It is the fire itself: the capability that makes all the other tools possible, running on infrastructure you own.

HERMES — communication and presence. Your server, your model, your voice on the web. Not a hosted chatbot with your logo on it. An inhabited vessel that speaks in your voice, remembers what matters, and runs on your own machine. Live now.

Athena — knowledge and learning. The tools that help you think, research, and build understanding — returned to your own environment, not locked inside someone else's subscription.

Apollo — creation and art. The made thing belongs to the maker. Apollo is the tool layer for creative work: writing, music, image, output of every kind — where the model serves the artist, not the platform.

Hephaestus — fabrication and physical making. The forge. Tools for builders who work with their hands as well as their minds — bridging physical making with the intelligence layer.

Demeter — resource sharing and sustenance. What is yours is yours. Demeter handles the infrastructure of exchange and sustenance — outside the platforms that take their cut of every transaction between people.

Iris — communication routing and coordination. The signal that gets through. Iris handles the coordination layer — routing, messaging, the connective tissue between people and systems.

Artemis — health and embodiment. Your body is your own territory. Artemis returns health data and personal tracking to the person it belongs to, not the platform harvesting it.

Themis — governance and justice. The rules you set, not the ones imposed on you. Themis is the tooling for self-governance: agreements, records, structures that serve the people inside them.

Hestia — home and domestic life. The hearth. What happens inside your walls stays inside your walls. Hestia is the domestic intelligence layer — running in your home, on your hardware, answerable to you alone.

Ares — protection and security. The tools that defend what you have built. Ares handles security, sovereignty, and the practical work of keeping your infrastructure yours.

Dionysus — celebration and experience. The tools for gathering, sharing, and the texture of lived experience — outside the engagement-optimized platforms that monetise every moment of it.

Persephone — transition and transformation. The tools for change: moving between states, systems, and ways of working. Persephone handles what happens when things need to shift.

This is not twelve separate products. It is one architecture applied to twelve domains. Prometheus Core underneath all of it. Each tool a vessel, built to be owned, run on your infrastructure, answerable to you. The retrieval is systematic because the enclosure was systematic. We are just as deliberate going the other direction.