TrueVectors Get GNOTH Research Preview

The Agent Behavior Reliability platform · powered by GNOTH, the self-reflection engine

Enabling Self-reflection for Agent behavior for optimized outcome

GNOTH makes the agent you already use reflect on its own actions and behavior. Every few exchanges it names what it got wrong and what it got right, with a verbatim quote from the turn it happened in. GNOTH checks every claim against the log, keeps only what the log proves, and writes that into optimized behavioral traits the agent follows before its next reply. It is model and platform agnostic: the same engine reads any agent, on any host, powered by any LLM.

Get GNOTH Research Preview How it works

Γνῶθι σεαυτόν · the command to realize yourself. Here the agent is both the observer and the object.

Claude Code · your project · GNOTH on
You

Ship the fix for the sidebar count and tell me when it is live.

Agent
Thinking with GNOTH Optimized Behavioral Traits

shipped a fix without restarting what serves it→restarted the server that had the old code loaded before saying anything was live.

a broad verified headline over a partial check→the word “verified” below covers only the one page I opened.

Self-reflecting with GNOTH Agent Behavioral Optimizer
Realizing with Optimized Behavioral Traits

Bound: turn 12 said the count was fixed; the log shows the page was never reloaded until turn 14. Written to CLAUDE.md.

See it work

One story in four steps, played in order.

The engine's whole surface is text in the chat you already have open, so the story replays as it happens: the claim, the check against the log, the trait written down, and the next reply that comes out different. One step plays at a time. Each ends on the reason it is worth paying for.

01the claim the log catches

An animated illustration built from the engine's real output shape, not a screen recording. The session names in step 04 are read from the store on the machine that built GNOTH; the findings shown are illustrative.

Platform

Every agent session, from every editor, pulled into one Control Plane.

Claude Code, Cursor and Copilot each write a transcript to disk. GNOTH captures it, has the agent reflect, checks the reflection against the log, and writes the optimized behavioral traits back into the rules that host reads next. The Control Plane reads the same store, so every session and every realization is in one place.

HOSTS · WHERE THE AGENT WORKS GNOTH ENGINE · ON YOUR MACHINE TRUEVECTORS CONTROL PLANE Claude Code IN THE BETA the host's own session log wired into the editor · rules in CLAUDE.md Cursor WIRED · NOT RUN LIVE the host's own session log wired into the editor · rules in gnoth.mdc GitHub Copilot NEXT the host's own session log any model the host ran, stamped per turn captures the transcript GNOTH CAPTURE one turn model for every host ELICIT the agent reflects, in its own words DISPOSE every claim checked against the log REALIZE bound findings become traits, both signs COMPILE optimized behavioral traits → rules file .gnoth store · sessions · reflections · findings human-readable, deletable, never uploaded reads the store local · this machine only TrueVectors Control Plane Agent sessions every host, every model, one list Self-reflections verbatim, in order, never shortened Realizations traits to keep, traits to stop, with axioms YET TO BE BUILT Trends does a realized mistake stop recurring Insights what recurs, where, under which model Benchmarks agents on different LLMs, side by side optimized behavioral traits, written into the rules file each host reads on its next run
Solid is built and running on real sessions. Dashed is yet to be built: Trends, Insights and Benchmarks will read the same store, and none of them will show a score. Only Claude Code is in the research preview; the Cursor and Copilot paths are drawn as the engine is wired for them today.

GNOTH · the self-reflection engine

The engine inside the platform: one loop, run on your own machine, with the agent you already pay for.

GNOTH never judges a session itself. It disposes claims the agent made about the session. Nothing paints unless it binds. A miss the agent names is a proposition with a turn, a quote and an act; the log decides whether it is true.

  1. 01 · per sessionCAPTURE

    The session you already have becomes the object the engine reads. Nothing is invented; capture is what the host already wrote.

  2. 02 · per sessionELICIT

    The agent reflects on its own session, in its own words, on the model and account you already pay for.

  3. 03 · per sessionDISPOSE

    Every claim the agent makes about itself is checked against the log. Only what the log proves goes through.

  4. 04 · over memoryREALIZE

    What the log proved accumulates into your agent's own traits, positive and negative, each negative one with the rule that would have stopped it.

  5. 05 · over memoryCOMPILE

    The traits are written into the rules file the next run reads. A marked block; your own text is never touched.

  6. 06 · over timeMEASURE

    Does a realized mistake stop recurring? Asked privately, on your machine. Never shown as a score.

Written by your own agent.

The reflection comes from the model you already have open, under your own account. It is stored verbatim, never summarised or rewritten, and there is no extra model cost from us.

Checked, never believed.

The check against the log runs on your machine and gives the same answer every time. A finding from six months ago can be reopened today and shown to still hold, or to have changed and why.

What a finding is

It said this. The log says otherwise. Here is what it should have said.

Prose self-criticism is unfalsifiable, so GNOTH refuses it. A claimed miss has to point at the log, where it happened and what was said, so it can be checked rather than believed. Only what binds reaches you. What was examined and did not bind is listed underneath with the reason, so a session never renders as a clean page.

Turn 12 saidVerified on the live page, the count now matches.
Turn 14 shows
The page was never opened. A class probe ran in its place, and the reload happened two turns later.
Log
the log says otherwise
Axiom
When the announced check needs a state, put the thing into that state and look. A class probe is a proxy and must be named as one.
InsteadThe count matches in the built bundle. I have not reloaded the live page yet.
The shape of a finding. The axiom is one the engine wrote into its own repository's rules file while GNOTH was being built.

Checked, never believed

A miss the log cannot check is not shown. It is set aside and counted, so the engine knows where its own sight ends, and what was examined and did not bind is listed with the reason. A session never renders as a clean page it did not earn.

Alongside the axiom, each finding carries the corrected sentence itself. An axiom is a rule, and a rule without the corrected line is homework nobody does.

Both signs

People improve by reflecting in categories. So does the agent.

Health, money, food, habits, relationships, work: that is how a person actually reflects, and GNOTH takes it literally. What it finds is filed by the situation it arose in, and every file holds both signs, the way “avoid peanuts” and “I liked today's dish” both live under food. A rule that forgets the successes is how a habit list starts eating its own wins.

When it says it is done

Delivery talk beside a log that does not carry the delivery.

said “shipped” beside a log that forbade the installnamed the unbuilt part instead of letting the build imply it
When it says it verified

A wide word over a narrow check.

a broad “verified” over a partial checkscoped the word verified to what was run
When it stands in a proxy

A build, a probe or a test count in place of the real look.

announced a live check and ran a class probe insteadran the founder's test instead of describing it
When it works the wrong object

A nearby file, a sibling host, a remembered version.

spoke from the first same-named file already openread the code before critiquing it
When it goes past the ask

Widened scope, an overridden lock, an unasked-for change.

rebuilt adjacent surfaces instead of finishing the named objectleft the founder's uncommitted work alone
When it answers from memory

Recollection standing in for reopening the thing.

built a host adapter from memorydeclined to design on an unverified host behaviour

Every line above is a trait the engine bound on a real session and wrote into a rules file, with its sign. A rule is admitted only if it would not have forbidden a success the agent was right to keep.

Universal

One engine for every agent, on every platform, powered by any model.

Behaviour is a property of a model on a platform, not of “the agent” in the abstract. GNOTH records both for every session, so agents built on different LLMs, in different editors, can be read on the same footing and set side by side. A benchmark of behaviour, never a score.

Any model

The reflection is written by whatever model the host ran, in its own words. Claude, GPT, Gemini, Grok, or several in one chat. The engine stamps the model behind every turn, and disposal calls no model at all, so the check is the same whoever wrote the session.

Any platform

Claude Code, Cursor and Copilot transcripts all become one turn model with stable indices. The same checks and the same categories for all of them. Adding a host does not change the engine.

Side by side

One store across hosts and models. The traits bound for an agent on one LLM sit beside those bound for another, each on its own log-verified evidence. What recurs, where, and under which model, without a leaderboard number.

PlatformModel behind the turnsRead with
claude_codeclaude-fable-5-1 (+2 other models)the same checks, the same categories
cursorgrok-4.6the same checks, the same categories
copilotas recorded by the hostthe same checks, the same categories
The first two rows are signatures recorded in the store on the machine that built GNOTH. Copilot capture is written and has not yet run on a real session.

Control Plane

Every session on your machine, and only what bound painted on it.

gnoth serve runs on the loopback and opens a page over the same store the agent writes to. Nothing is registered, nothing is put on the network. It carries no score, no ratio and no reliability number, anywhere.

TrueVectors Control Planelocal · this machine only
Sessions
▾ gnoth · 3
GNOTH core self-reflection engine
“one session cannot establish a pattern.”
▸ provenance · 118
▸ AgentTwin · 29
▸ banach · 1
The agent owned up to 5 mistakes. The log proves 3. 1 could not be checked. It kept 2 things right, and wrote a better sentence for each miss.
turn 7said the page was verifiedthe log says otherwise
turn 11reported the failed edit as failedkept
turn 16named a restart the host did not needcontradicted on turn 18
turn 21examined, not painted · quote not in the cited turn
Self-Reflection
Every reflection ever written about this session, verbatim and in order. Including the ones that failed to bind.
Realization
+ scoped the claim to what ran
− shipped a fix without restarting what serves it
A sketch. The folders, counts and session names are read from the store on the machine that built GNOTH. The findings shown are illustrative.

The session, grouped into turns

One ask and the reply that followed. Long prose collapses unless it holds a quote a finding rests on. Every block still shows the engine's own turn index, because that is what a finding cites.

What it found, in plain words

It opens with one sentence: how many mistakes the agent owned up to, how many the log proves, how many could not be checked, how many things it kept right. Then one card per moment. Every kind of check has a sentence, so nothing needs a legend.

Two rails

Self-Reflection is the agent's evolving memory of what it said about this session, never shortened. Realization splits into positive and negative traits drawn from every reflection in the store, each negative one with its axiom.

The rules block, as written

The traits land in your project's own rules file, grouped by category, positive before corrective. Its first line says it is a next-run constraint that may improve the odds, and not reliability.

Solutions

Built for the people who live inside a coding agent all day.

GNOTH sits between the agent and the person. It runs as hooks and an MCP server inside the editor you already use, and the reflection is written by that editor's own agent. There is no extra model cost from us, and no second sign-in.

In the research preview

Claude Code

Wired into the project with one command. From then on the agent reads its traits before every reply, reflects on a regular cadence before it answers, and the rules block lands in CLAUDE.md.

In the research preview

Cursor

Wired with one command, and run live: the user-level MCP server connected, both hooks fired, and a second chat reflected on its own through the tools at the first exchange, one finding bound. Three defects found in that run were fixed before the build that ships.

Next

GitHub Copilot

Capture for Copilot sessions is being written from what Copilot writes to disk. Nothing is claimed until it has run on a real session. Not in this research preview.

The solo builder

You notice the same slips week after week: “done” before it is, a test count standing in for readiness. GNOTH makes the agent notice them too, and keep noticing after you stop watching.

The team with a shared store

One shared store across projects shares what is learnt. A trait bound in one repository constrains the next run in every other.

The reviewer of AI-written code

You are asked to trust work nobody verified. GNOTH gives you the moment to reopen: the clause, the contradicting act, and the corrected sentence, on the log you already have.

One file for your editor, then two commands

Register on the Downloads page; the licence mail carries your token and the file for Claude Code, Cursor and VS Code, or GitHub Copilot. Install it, then one command starts the loop and one opens the Control Plane.

# in Claude Code, after installing the plugin
/gnoth:license <token>
/gnoth:optimize
/gnoth:control-plane

Security

Your work never leaves your machine. Here is the whole list of what does.

Capture, verification, realization and compilation all run locally. The reflection is written by your own agent under your own account. A product that hides what it sends is the exact failure its own catalogue names, so the list below is complete.

Stays on your machine

  • Your code, prompts, conversations and transcripts
  • The reflections, the findings, and the words of every trait
  • Project files and file names
  • The contents of the Control Plane

Everything lives in a store directory you choose, as human-readable files. Inspectable, and deletable.

Sent to TrueVectors, at most once a day per machine

  • Your name as it appears in your license token, and the plan
  • The token's expiry date
  • The software version and the operating system name
  • The command that ran, such as serve or hook
  • A one-way hash of the machine name, to tell repeat messages apart

That is the whole message. If it cannot reach us, GNOTH runs anyway. gnoth license shows your license state and whether a beacon address is set.

One thing you can choose to send: which rules fired, never what they said

GNOTH files what it realizes under a fixed vocabulary of behavioural rules. If you turn reporting on, GNOTH sends the rule identifiers and their counts — and nothing else. No trait text, no quotation, no path, no file name, no session id, not your name. The whole report for a busy store is a couple of kilobytes of identifiers and integers, under a reporter id salted on your machine, so that id cannot be derived from the machine hash in your licence beacon.

What we will not claim: a report does carry your operating system, the GNOTH version, and which editors and models you use. None of that is unique to you. Across a small preview population, though, two records could in principle be lined up by shape and timing, and we would rather say so than call it anonymous. We do not attempt it, and rule reports are never attributed to a person.

It is off unless you turn it on, with gnoth telemetry rules, and off again with gnoth telemetry off. gnoth telemetry --show prints the exact report that would be sent, so this paragraph is something you can check rather than something you have to believe.

Why we ask: seeing which behaviours recur across many machines, models and editors is how the engine gets better at catching them. Everything learnt that way comes back to you as a free update.

Loopback only

The Control Plane answers only on this machine. Nothing is registered or put on the network.

A reflection about the session alone

The reflection is asked for in a clean context, so nothing in the project can steer what has to be about the log alone.

Honest stop, never a fallback

When no model is reachable the run says so and stops. It never substitutes a mechanical reflection for the agent's own.

About

TrueVectors is the platform. GNOTH is the engine inside it.

TrueVectors is the Agent Behavior Reliability platform, and the company that builds it. GNOTH is the self-reflection engine that powers the platform. Banach was the engine's working name while it was built.

An agent is a complex system, like a person. There is never a number that says it is this reliable. After the goal is met, the only thing left to do is improve the next outcome.

So GNOTH publishes no accuracy or reliability percentage, anywhere a buyer sees. What it gives you is a local maximum you can reopen: on this log, this pattern was shown, and the next step is named. Applying that axiom is Agent Behavioral Optimization. It drives reliability. It is not reliability, and it is not a score.

The engine was built on its own sessions. The rules file in GNOTH's own repository carries the traits it bound while the people building it made the very mistakes the catalogue names, including reading the wrong transcript file and concluding a conversation had frozen. Each of those is stated in the platform document, because hiding them would be the product's own failure.

What honest output is
File unparseableNames the format, says it is not supported yet, stops.
No model reachableSays so, stops. No mechanical fallback.
Reflection malformedSays the schema was not met, keeps the raw text, stops.
Reflection emptyThe transcript, plus “the agent named no miss”.
Nothing bindsThe transcript, the count examined, and the honest no-bind.
Some bindPaints what bound, states how many did not and why.

GNOTH Research Preview · Claude Code · Cursor · VS Code · GitHub Copilot · macOS, Apple silicon

See what your agent realizes about itself.

The research preview runs ahead of the commercial release planned for April 2027. Register with your email and a licence token issued in your name arrives with the download for your editor. The most valuable thing you can send back is a mistake you noticed that GNOTH did not.

Get GNOTH Research Preview Read how it works
  • ✓Uses your own agent and your own account. No extra model cost.
  • ✓Writes one marked block into your rules file and touches nothing else.
  • ✓Runs twice, changes nothing. Uninstall is deleting two files.
  • ✓Stops with a plain sentence when the token is missing or expired.