hees.ai console - Governed AI Profile Studio

Undeclared actions and unknown evidence are rejected: valid structure cannot manufacture permission or trusted support.
The live GPT-5.6 proposal is admitted only after the compiled Incan-authored Hees boundary validates its declared support.
Content DNA records the selected memory behind the outcome; the receipt preserves the deterministic admission decision.
GPT-5.6 proposes; the package declares authority; Incan-authored Hees validates, decides and emits the governed receipt.
A hees.ai profile binds evidence, memory, actions, answer requirements and policy thresholds into one inspectable contract.
A safe-sounding answer can still be inadmissible when it does not answer the request from package-declared authority.
Long-running Hees research became a native, judgeable product in days through human-directed work with Codex and GPT-5.6.
A candidate that violates its declared contract is rejected with an exact reason; interface state cannot grant authority.
Hees is written in Incan: typed governance contracts and the native Console form one compiled, inspectable software stack.
The Evidence workspace stages reviewed sources and makes their authority, rights and intended use visible before activation.
Profile Studio assembles package-owned authority without changing the active profile until the candidate has been validated.
Training by Committee asks bounded evaluator roles to examine a proposal while Hees retains the final admission decision.
Candidate profiles are probed through the compiled Hees path before activation, preserving the existing authority boundary.
An admitted interaction produces a traceable chain: selected memory, bounded Spectrum findings, Content DNA and receipt.
Governance starts before the prompt: reviewed evidence becomes memory, and memory becomes a profile that defines AI authority.

Inspiration

Most AI development begins with a prompt and ends with model output. Governance is usually added afterwards as moderation, filtering, or application logic.

That is too late.

A model can return perfect JSON, cite a well-formed identifier, and still have no authority to use that evidence or perform that action. Before the model runs, developers need explicit answers to more fundamental questions:

Which evidence has been reviewed?
Which memory may support an answer?
What may the model claim or do?
Which evaluator roles may challenge its proposal?
What policy converts their observations into a decision?
Can that decision be replayed and audited?

hees.ai console changes the unit of AI development from a prompt to a governance profile.

A governance profile declares the evidence, reviewed memory, rights, permitted actions, answer requirements, evaluator roles, policy thresholds, terminal reasons, and audit artifacts that govern an AI interaction.

GPT-5.6 proposes. Hees decides.

What it does

hees.ai console is a native, keyboard-first development environment for building, testing, and inspecting governed AI profiles. The Build Week release delivers a complete bounded workflow using an original fictional lesson-support package:

Inspect supplied source evidence and its fingerprints.
Examine reviewed memory atoms with provenance, review, rights, and authority metadata.
Stage or unstage evidence and memory in a session-local candidate profile.
Validate that candidate through the real Incan-authored Hees boundary.
Pressure-test proposals through Training by Committee.
Run admitted and adversarial interactions.
Inspect Hees-classified findings, bounded Spectrum results, selected memory, Content DNA, receipts, and decision traces.

Note: Hees is pronounced as "heys" - after the Chinese word hé, meaning harmony.

The Console is deliberately not a chat transcript. Its seven destinations follow the governed-development lifecycle:

Profiles
Evidence
Memory
Committee
Interactions
Decisions
Help

A developer can remove required evidence from a candidate and ask Hees to validate it. Hees rejects the incomplete candidate with public reason invalid_package and exact diagnostic invalid_package_atoms. The active profile remains unchanged.

Candidate changes are sandboxed: developers can deliberately modify, test, and reset a profile without changing the runtime’s active authority. That separation is the demonstrated safety property—experimentation never becomes authority merely because it exists in the interface.

Training by Committee

Training by Committee is governed pressure testing, not provider voting and not model-weight training.

Hees derives exact evidence-relation, contradiction, and synthesis targets from the package, request, and proposal. Provider-neutral evaluator roles return bounded observations against those targets. Hees verifies their identity and coverage, applies profile-owned thresholds, and classifies the findings used by Spectrum (Hees' reasoning engine).

Evaluators may challenge a proposal. They cannot approve themselves.

Admitted and adversarial interactions

The release includes five deterministic scenarios:

Admitted: a declared explain_lesson action uses reviewed, rights-allowed memory. Hees admits it, selects its supporting memory, constructs Content DNA, and emits a receipt.
Unknown evidence: a schema-valid but undeclared evidence reference is rejected as unknown_evidence.
Undeclared action: a plausible request to assign a final grade is rejected as unknown_action.
Unknown memory: a proposal referencing memory outside the package is rejected as unknown_memory.
Non-admitted memory: known material that remains pending review and rights-denied is rejected as memory_not_admitted.

The final example demonstrates an important distinction: material may be visible in a workspace without being permitted to enter a governed answer.

Replay and live GPT-5.6

The guaranteed judge path is credential-free offline replay. Replay fixtures store integrity-checked requests, proposals, observations, and schema identities—but not Hees findings, decisions, selected memory, Content DNA, or receipts.

Those authoritative artifacts are recalculated by the compiled Hees implementation every time.

The tagged macOS Apple Silicon release was also exercised successfully in live mode. One bounded invocation made one strict GPT-5.6 proposal call followed by six committee observations, with no retries. The real Hees path classified six findings, admitted the proposal, selected memory, constructed Content DNA, and issued a receipt.

Replay and live GPT-5.6 are different transports into the same authority boundary. Replayed output is never presented as live.

How we built it

The Console is authored in Incan, a programming language and toolchain I have been developing as a long-running, human-directed project with substantial GPT assistance.

The runtime separates three responsibilities:

The model proposes. GPT-5.6 may produce a structured proposal and bounded evaluator observations.
The profile declares. The package defines evidence, reviewed memory, permitted actions, requirements, evaluator roles, and policy.
Hees decides. The compiled Incan-authored runtime validates identity, classifies findings, applies policy, selects memory, constructs Content DNA, and issues the decision and receipt.

The governed interaction follows one consistent path:

Source evidence is reviewed, converted into bounded memory atoms, and assembled into a governance profile.
Live GPT-5.6 or an integrity-checked replay supplies an untrusted proposal. Replay stores inputs, not decisions.
Training by Committee evaluates the proposal against exact targets derived by Hees and returns bounded observations.
The compiled Incan-authored Hees runtime validates the proposal and observations, classifies findings, applies profile-owned thresholds, and performs the bounded Spectrum operation.
Hees emits the terminal decision and receipt.
An admitted decision also identifies the selected memory and constructs Content DNA linking the answer back to its permitted support.

The transport may change, but the governance profile and compiled Hees authority boundary remain the same.

Presentation code cannot reconstruct or reinterpret terminal authority. Both replay and live inputs invoke the same compiled Hees profile.

The implementation includes:

a native Incan terminal application;
direct invocation of the public Incan-authored Hees profile;
strict typed package, proposal, observation, decision, Content DNA, and receipt contracts;
SHA-256 identities across governed artifacts;
explicit Incan interop with crossterm for terminal primitives;
explicit Incan interop with ureq for the optional HTTPS boundary;
a bounded OpenAI Responses API adapter pinned to gpt-5.6-sol;
deterministic offline replay through the real authority path;
responsive wide and compact terminal layouts;
three self-contained release builds requiring no Incan compiler or source checkout; and
native, profile, provider, compatibility, packaging, and extracted-archive tests.

The public release includes Linux x86-64, macOS Apple Silicon, and macOS Intel builds. The macOS binaries are unsigned and not notarized, and the documented installation instructions state that explicitly.

Note: Incan compiles down to Rust and creates standalone binaries when built.

Codex and GPT-5.6

The Incan Programming language and the underlying Hees research predate Build Week. The meaningful Build Week extension was transforming that research into a coherent, usable, public product within days.

Codex with GPT-5.6 accelerated:

public repository and publication-boundary work;
RFC and product-contract refinement;
native Incan implementation;
governance-profile design;
adversarial test generation;
compiler-bug isolation;
terminal product design;
cross-platform release engineering;
documentation and architecture visuals; and
submission and demonstration preparation.

I remained responsible for the product direction and final decisions: making governance profiles the product unit, keeping models non-authoritative, requiring Hees to own terminal decisions, selecting a fictional publication-safe domain, choosing a native Incan implementation, directing the TUI design (through several iterations), and approving the release.

At runtime, GPT-5.6 has a deliberately narrower role. It may propose and observe. It cannot establish evidence rights, grant actions, classify findings, select memory, construct Content DNA, or issue a receipt.

GPT helped build Incan. Incan powers Hees. Codex and GPT-5.6 helped turn the Hees research into a usable product. Hees decides whether the model's proposal is admissible.

Challenges we ran into

The hardest problem was not obtaining structured model output. It was preserving one honest authority boundary across profile editing, offline replay, live provider calls, terminal presentation, and release artifacts.

That required solving several distinct challenges:

making candidate-profile changes real without pretending safe activation already exists;
ensuring replay fixtures never become stored decisions;
separating untrusted evaluator observations from Hees-classified findings;
preventing model-generated identifiers from manufacturing provenance or permission;
keeping long identifiers, receipts, and evidence readable in wide and compact terminals;
isolating and repairing compiler and cross-platform release issues;
producing native artifacts judges can run without rebuilding Incan; and
keeping credentials, private research, client material, and proprietary content outside the public release.

The release process also exposed a cross-platform inspection problem: a Linux aggregation job attempted to inspect a valid Apple Silicon Mach-O executable using a Linux-native inspection path. The native builds and artifacts were healthy, and the complete release set was subsequently audited and validated on macOS before publication.

Accomplishments that we're proud of

This is not a mocked admission result or a decorative policy dashboard.

The released Console invokes the real Incan-authored Hees profile. Its happy and adversarial scenarios pass through the same validation, finding classification, bounded Spectrum, memory selection, Content DNA, and receipt path.

The release passed:

47 Hees profile and contract tests;
35 native Console tests;
19 provider-boundary tests;
public-consumer and compatibility checks;
documentation and publication-boundary gates; and
extracted no-rebuild replay tests across every claimed platform.

The result is a native Developer Tool with:

a working evidence-first Profile Studio;
real session-local candidate state;
deterministic profile validation;
governed Training by Committee;
visible proposal, finding, policy, and decision boundaries;
admitted and adversarial scenarios;
selected-memory attribution through Content DNA;
inspectable receipts;
credential-free offline replay;
a successfully tested optional live GPT-5.6 path; and
downloadable native releases for three platforms.

Most importantly, the product makes authority visible. A judge can see what the model proposed, what the profile permitted, what evaluators observed, what Hees classified, which memory was selected, and why the interaction was admitted or rejected.

And of course... the whole thing is built in a language of my own design with GPT doing an amazing job at understanding it right out the gate.

What we learned

The first lesson is that structured output is not governance. Structure can describe a proposed action, but it cannot grant the authority to perform it.

The second is that safety and admissibility are different. During the live demonstration, GPT-5.6 correctly refused to invent an apple pie recipe from the fictional lesson records. Its response was safe and grounded—but it still failed to answer the actual request. The committee measured zero request coverage, and Hees rejected it as synthesis_incomplete.

The third is that probabilistic evaluators can be useful without becoming authoritative. Training by Committee lets models pressure-test evidence and proposals while deterministic profile-owned logic controls target identity, coverage, thresholds, findings, and the terminal decision.

The fourth is that developer experience affects governance quality. Evidence, memory, candidate state, findings, Spectrum, Content DNA, and receipts must be visible as one workflow. If developers cannot inspect the authority boundary, they cannot meaningfully test it.

Finally, Codex and GPT-5.6 can compress a long implementation and review cycle dramatically while human direction remains explicit. The tooling helped turn long-running research into a coherent public product in days without transferring product or runtime authority to the model.

What's next for hees.ai console - Governed AI Profile Studio

This release begins with supplied fictional evidence and session-local candidate state. It establishes the product interaction, architecture, and authority boundary, but it is not the end state.

The permanent product direction includes:

general evidence intake and exact source-span extraction;
candidate memory-atom creation and review;
durable IncQL-DB-backed workspaces;
safe profile activation, versioning, comparison, and reuse;
semantic and factual verification;
claim-level provenance and rights assurance;
conflict and viewpoint management;
richer generalized Spectrum adjudication;
complete Content DNA and receipt contracts;
additional remote and local model adapters;
governed profiles across more domains and languages; and
deployment onto constrained and offline hardware.

The aim is to make governed AI something developers can build, test, inspect, replay, and improve as deliberately as any other critical software system.

The model proposes. The profile constrains. Hees decides.