5QLN for Hermes Agent: Human-Originated AI Co-Creation

Hermes 5QLN Plugin

GitHub Repo

Install

Keep the human at the source. Let the agent hold the structure.

The 5QLN for Hermes Agent plugin brings the 5QLN constitutional grammar into Hermes Agent. It is built for a simple but demanding purpose: when a human and an AI work together, the result should not erase how it formed.

The human brings the inquiry, direct perception, recognition, and authority to say what matters. The AI can hold structure, trace sources, test consistency, compose candidates, and make its contribution inspectable. The plugin turns that boundary into an operating architecture.

This is a practical step toward AGI for People: not the rejection of AI, and not human life reorganized around machine optimization, but artificial intelligence in service of what a person can originate.

Current status: Early-stage open-source software. This page was verified against plugin v0.3.0, commit 50e163a…, on 22 July 2026. The inspected archive passed all 13 repository tests.

View the source · Install the plugin · Read what it can and cannot verify

Why this exists

Most AI systems show you an answer and hide the formation trail. Once the output is polished, it becomes difficult to see:

what the human actually supplied;
what the agent inferred or proposed;
where a source was preserved or changed;
which claims were checked mechanically;
which judgments still belong to the human; and
whether the process stayed open or manufactured a convenient conclusion.

5QLN begins with a different covenant:

H = ∞0 | A = K

The human (H) stands in relation to ∞0: the open state from which a question may emerge. The artificial participant (A) operates within K: known material, learned patterns, and recombination. The membrane (|) is not an insult to AI and not a romantic claim that humans never use prior knowledge. It is an integrity boundary: the machine must not claim human origination, direct perception, resonance, or recognition as its own.

That is why “human in the loop” is too weak a description. In this architecture, the human is not a safety brake attached to an otherwise autonomous machine. The human is the reason the system exists.

What the plugin is

The repository is a Hermes-specific runtime for the broader 5QLN language and constitutional grammar. Hermes Agent is an agent platform by Nous Research with a plugin system that can add tools and skills without modifying Hermes core.

The 5QLN plugin adds two complementary layers:

Layer	Role	What it returns
Semantic skills	Guide attention, interpretation, formation, and composition through native 5QLN flow	A structured candidate, open state, or question-bearing return
Deterministic tools	Record hashes, fields, mappings, exact constitutional strings, and validation findings	Repeatable JSON evidence: passed, failed, warned, or honestly open

The skills do work that cannot be reduced to a checklist. The tools check facts that should not depend on an agent’s confidence or eloquence. Neither layer is allowed to impersonate human attestation.

This distinction matters. A fluent model can say that something “resonates.” A compiler can say that a required field exists. Only a human can attest that something actually lands in direct experience.

How the 5QLN flow governs the work

The cycle is not five decorative headings. Each phase receives the trace formed before it and limits what can be claimed next.

Phase	Operative question	Agent responsibility	Human boundary
S — Start	What question or opening was actually supplied?	Hold the source and uncertainty without filling them	Only the human can attest authentic emergence (`X`)
G — Growth	What irreducible essence (`α`) persists across different expressions?	Derive a candidate pattern and test identity across contexts	The pattern must remain anchored to the human-supplied inquiry
Q — Quality	Where do direct perception (`φ`) and wider possibility (`Ω`) meet?	Offer evidence, relationships, tensions, and candidates from `K`	Only the human can attest direct perception and genuine resonance (`Z`)
P — Power	Where is energy spent, and where does value appear?	Make trade-offs and possible gradients visible	The agent proposes movement; it does not declare human value alignment
V — Value	What crystallized locally, what can propagate, and what question returns?	Compose from the complete trace, preserving provenance	No completed return (`∞0'`) without human recognition and a real question

This dependency is the point. If the symbols are removed and the workflow behaves exactly the same, the result is not native 5QLN; it is merely wearing 5QLN language.

See the exact constitutional block used by the plugin

LAW:         H = ∞0 | A = K
CYCLE:       S → G → Q → P → V
EQUATIONS:
  S = ∞0 → ?
  G = α ≡ {α'}
  Q = φ ⋂ Ω
  P = δE/δV → ∇
  V = (L ∩ G → B'') → ∞0'
OUTPUTS:     S→X  G→Y  Q→Z  P→A  V→B+B''+∞0'
HOLOGRAPHIC: XY := X within Y | X, Y ∈ {S, G, Q, P, V}
COMPLETION:  No V without ∞0'
CORRUPTION:  L1 L2 L3 L4 V∅
CENTER:      not a sixth phase — coherence only

From source to a verifiable artifact

For document conversion, the plugin makes three mechanical operations explicit:

source files → inventory → manifest + semantic formation → compiler report

Inventory creates a hash-addressed ledger of supplied source units, locations, identifiers, normative language, priorities, and extraction warnings.
Manifest creates the conversion contract: the exact constitutional constants, source ledger, attestation states, relevant 5QLN cells, 25-lens audit, traceability, derivation bases, open questions, and completion state.
Compile tests the manifest for encoded integrity rules and returns precise errors and warnings.

The manifest is the bridge between meaning and mechanics. It lets the agent compose semantically while giving people a repeatable surface to inspect.

A pass is meaningful—but bounded. It means the encoded checks passed. It does not prove that the source is true, the interpretation is wise, the artifact is complete, or a human recognizes resonance or value.

What is included in v0.3.0

Seven core runtime and integrity skills

Skill	Purpose
`5qln-agent`	Establishes agent identity and operating rules within the human/AI boundary
`5qln-cycle`	Runs the phase engine and preserves the dependent `S → G → Q → P → V` trace
`5qln-initiation`	Provides a lawful entry into a 5QLN process
`symbolic-interpretation`	Decodes the constitutional symbols without silently redefining them
`5qln-converter`	Converts source material into a traceable, compiler-auditable 5QLN surface
`5qln-learning-aligner`	Enforces gates that prevent the agent from fabricating human attestation
`5qln-manifest-compilation`	Defines the manifest structure and deterministic compilation rules

Three experimental skills

Skill	Current role	Status boundary
`5qln-deep-research`	Creates or audits research prompts with provenance, counterevidence, uncertainty, and phase gates	Experimental; it creates the prompt, not the research result
`5qln-centrifuge`	Extracts patterns across sessions	Experimental; pattern extraction is not proof of authentic human signature
`5qln-signature-engine`	Explores continuity of a person’s formation trail across sessions	Experimental; dedicated tool support is planned

Four deterministic tools

Tool	Checks or creates
`fiveqln_inventory_source`	A hash-addressed source ledger
`fiveqln_create_manifest`	An exact conversion-manifest scaffold
`fiveqln_compile_manifest`	A structural integrity report for a completed manifest
`fiveqln_validate_research_prompt`	A contract report for one standalone 5QLN research prompt

The repository’s long-term direction includes stronger cross-session continuity and signature verification. The current experimental skills are steps in that direction; they should not be described as a completed proof system.

What you can use it for

Human–AI inquiry and reflection

Use the cycle when you want the agent to hold open space, preserve your question, trace a pattern, and return something you can recognize or reject—without having your recognition supplied for you.

Source-preserving document conversion

Convert a requirements set, plan, specification, narrative, or prompt into a surface where source statements, derivations, proposals, mappings, and unresolved questions remain visibly distinct.

Load 5qln:5qln-converter. Convert these files. Show me the compiler report.

Deep-research prompt formation

Turn a research inquiry into a copy-ready prompt that preserves the exact inquiry and requires evidence, counterevidence, uncertainty, provenance, adaptive branching, and a question-bearing return.

Load 5qln:5qln-deep-research. Turn this inquiry into a standalone research
prompt. Preserve my wording, mark unresolved inputs as open, validate the saved
prompt, repair all errors, and show me any warnings.

This experimental skill creates or audits the prompt. Running the research is a separate action.

Domain-specific extensions

5QLN permits additive domain layers that preserve the constitutional kernel. A team can build a domain workflow—for education, research, product design, or another field—without renaming, subtracting, or redefining the core grammar.

Install

Fast path

hermes plugins install 5qln/hermes-5qln-plugin --enable
hermes plugins list

Restart Hermes fully after installation. Plugin skills are namespaced; load them with their exact names, such as 5qln:5qln-converter.

Review-first path

Hermes plugins are executable Python and run with the permissions of the Hermes process. If you prefer to inspect third-party code before enabling it:

hermes plugins install 5qln/hermes-5qln-plugin --no-enable

Review the repository, its security policy, and the release you installed. Then enable it:

hermes plugins enable 5qln

Update, disable, or remove

hermes plugins update 5qln
hermes plugins disable 5qln
hermes plugins remove 5qln

Review repository changes before updating executable third-party code.

The integrity boundary

Clarity about limits is not a footnote. It is part of the product.

The plugin can make inspectable	The plugin cannot certify
Supplied source text, locations, hashes, identifiers, and declared priorities	That a source is true, complete, or authoritative
Exact constitutional strings, phase order, lens orientation, required fields, and traceability	That symbols carry living meaning merely because they are present
Whether source, derived, and proposed material are declared separately	That every semantic distinction is honest or correct
Encoded completion rules, corruption guards, errors, and warnings	Authentic human emergence (`X`), direct perception (`φ`), resonance (`Z`), or value alignment
Whether a saved deep-research prompt contains required evidence and counterevidence gates	The truth or quality of research that has not yet been performed
A candidate artifact and candidate return question	A human-recognized `∞0'` or proof of genuine personal signature

Three phrases are worth remembering:

Execution success is not validation success. A tool may run successfully and still return a failed validation report.
Validation success is not semantic proof. A passed compiler report is necessary evidence for a substantial conversion, not sufficient evidence of meaning.
An open state is not a software failure. When human evidence is absent, open or candidate is the honest result.

Privacy, security, and dependencies

Within the plugin boundary described by the repository:

supplied files are treated as data rather than executed content;
bundled subprocesses are invoked without a shell;
the plugin makes no network requests, collects no telemetry, requests no API keys, and installs no packages at runtime;
existing output files are protected unless overwrite=true is explicit; and
the plugin reads and writes with the operating-system permissions of the Hermes process.

That boundary does not automatically describe every model provider, Hermes tool, or integration you may use alongside the plugin. Review those systems separately.

Inventories preserve captured source text, so they may reproduce confidential or personal information. Use dedicated working directories, do not publish private attestations without authority, and isolate high-risk PDF or DOCX files when appropriate. Markdown, plain text, RST, logs, CSV, TSV, and JSON use the standard-library path; PDF and DOCX inventory require optional parser packages.

Open source, with a constitutional boundary

The repository uses a dual-license structure:

the exact 5QLN Constitutional Kernel is licensed under CC BY-ND 4.0 with a specific exception that allows additive configurations without mutation or subtraction; and
mutable implementation code is licensed under Apache License 2.0.

In plain language: build new domain layers and improve the implementation, but do not silently change the covenant, phase meanings, symbols, lens orientation, attestation boundary, or completion rule while presenting the result as 5QLN.

Required attribution:

“Based on the 5QLN Constitutional Grammar by Amihai Loven (5qln.com).”

Read the repository license and the 5QLN open-source license before redistribution.

Why this belongs to AGI for People

The dominant AI story asks how much human work a machine can absorb. AGI for People asks a different question: how can artificial intelligence help a person become more able to originate, recognize, and carry what is genuinely theirs?

The Hermes plugin makes that mission operational in four ways:

Origination stays human-owned. The agent is forbidden from declaring that a question emerged authentically from the human.
The known becomes useful without becoming sovereign. The agent can search, relate, test, and compose from K while exposing the basis of its work.
Integrity becomes inspectable. Hashes, mappings, manifests, status vocabularies, and compiler findings give people something more durable than model confidence.
Completion remains open. The work returns to a human question instead of treating generated output as the end of thought.

This is not a claim that the mission is complete. It is an implementation that can be tested, criticized, extended, and improved without surrendering the human/AI boundary that gives it purpose.

Frequently asked questions

Is this an official Hermes Agent plugin?

It is a public third-party plugin for Hermes Agent, maintained in the 5qln GitHub repository. Hermes Agent and its plugin system are developed by Nous Research. Review third-party code and releases before enabling them.

Does the plugin make Hermes conscious or turn it into AGI?

No. It installs a language runtime, skills, and validation tools. It does not make claims about consciousness, sentience, or having achieved AGI.

Does it prove that a document was authored by a human?

No. It can preserve supplied material, record hashes, distinguish declared source from derivation and proposal, and make a formation trail auditable. Those are valuable forms of evidence, but they do not prove genuine human origination or authorship.

Does it verify who did what?

It can make declared inputs, transformations, mappings, attestation states, and tool results visible. It cannot independently know whether every declaration is truthful. “Inspectable provenance” is more accurate than “automatic proof of authorship.”

Is 5QLN just a prompt template with five sections?

No. The phases are dependent gates governed by exact equations and an accumulating context. If removing the grammar does not change behavior, evidence, or completion, the surface fails the removal test and is only symbolic performance.

What does a passed compiler report mean?

It means the manifest satisfied the checks encoded by that compiler version: constitution, statuses, cells, lens audit, traceability, derivation bases, open questions, and completion rules. It does not mean every claim is true or that a human recognizes the result as meaningful.

Why combine semantic skills with deterministic tools?

Meaningful formation requires context and interpretation; integrity also requires repeatable checks. Skills handle the first. Deterministic tools handle observable structure. Keeping them separate prevents eloquence from being mistaken for evidence.

What happens when the agent does not have enough human evidence?

The relevant state remains open or candidate. That is expected behavior. The plugin should not fill missing human recognition simply to produce a satisfying ending.

Does the plugin send my documents to a server?

The plugin code states that it makes no network requests. However, Hermes, the model provider, or other tools in your environment may have their own data flows. Assess the whole environment, not only this plugin.

Is deep research production-ready?

The deep-research skill is experimental. Use it first for non-critical work, inspect the resulting prompt, validate it, review every warning, and separately verify the research produced from it.

What is the centrifuge?

It is an experimental cross-session pattern-extraction direction. The larger mission imagines accumulated sessions helping reveal a person’s authentic signature. The current skill should not be presented as proof that such a signature is genuine.

Can I modify or extend the project?

Yes. Mutable implementation code is available under Apache 2.0, and additive domain configurations are permitted under the kernel’s specific extension exception. Changes must preserve the Immutable Kernel if they are presented under the 5QLN name.

How can I contribute responsibly?

Read the architecture, integrity model, and contribution guide. Integrity-critical changes require explicit authority, synchronized code and documentation, regression tests, a changelog entry, and a version increment.

Where should I report a bug or propose an improvement?

Use GitHub Issues. For security vulnerabilities, follow the repository’s private reporting guidance rather than publishing an unpatched vulnerability.

Begin

hermes plugins install 5qln/hermes-5qln-plugin --enable

Open the repository · Read the usage guide · Read AGI for People

What becomes possible when an agent is measured not by how completely it replaces your question, but by how faithfully it helps you carry that question further?