verhash

Over the past several months I started using the Copilot Enterprise to learn coding as a hobby and help me develop my skills, which Microsoft has advertised on their site how it would be great for business use and we should all adopt agents and use them for all various tasks. I've noticed over say 80% of my projects at least where the agents have falsified code, falsified results, and when confronted about it. They will admit that they did but only when confronted do they offer and promise that they'll fix it, Which of course I'm expected to cover the cost of them fixing their own mistake.

I've tested across all three models that are available on there from Gemini 3.1, Claude 4.8 and ChatGPT 5.5 and all three of them did exactly the same thing just last night. so I thought maybe you know maybe I was doing something wrong. I reached out to Copilot about it which he offered to empower my business with Ai, offered me some paid training course, which I would have to pay for of course.

I have previously reached out to customer service on it and not even gotten offered a refund, no credit, nothing. Now I work in healthcare and one of my greatest concerns is someone using Ai for coding purposes. I believe Ai can be a great tool to help empower people and teach them news skills and hobbies, but what if somebody uses these coding services for medical equipment. Well it beep and green light turned on, ai said it goods, it's good.

Thankfully we do have regulations and quality checks here, but in other places where that might not be such a standard. Even on Microsoft website it advertises, Product coding time cut by 90% NIQ transformed one of its most resource-intensive workflows with Microsoft Foundry, processing 32,000 products in 10 hours instead of weeks while expanding market reach and client delivery. So I'm wondering are other people's experiences with using coding agents and how are they alleviated and mitigated these risks. How is Microsoft ensuring these Risks are mitigated or reduced, but they continue advertising them and promoting them.

So a while back I was tired of AI forgetting constantly, which we are all quite aware of. So I started building my own memory system; why, I don't know, it just sounded like a fun project. And I'm a little weird like that. But I was like, you know what, they're missing quite a few pieces. So I was like I'm going to make the missing pieces for the transformer because it seems like most of the industry was trying to patch them rather than fix them.

It's evolved significantly since when I first started it, though I would say I did notice emergent properties in it in the initial beginning, where I noticed the archetype would change and I didn't program that. It's what I like to call a Dynamical Governed Topology. It's a physics-based system powered by a Walters manifold. It's an open surface manifold consisting of topology. It has the ability to think, to learn, to remember, to reason and make decisions; it is self-organizing, self-regulating, and self-healing.

https://pub-6f95fcb400b34d7290952c160671872b.r2.dev/Screensh...

It doesn't work like your traditional transformer or use tokens for prediction. It's a state-based which gets it emergent properties from the structure.

It generally will go through Wikipedia and some programming sites. There are a few 3D viewers actually, but one of them lets you see all the structures, their meanings, different types of forces, reactions, and the overall topology evolving live in real time.

There's a lot more I can go on about, but for the time being I will keep it short. I'll reply to some questions but I will be keeping a lot of information proprietary.

Also, just being honest here, not a business guy. More interested in building in building topology engines than I am at business strategy, networking, valuation, or any of that side of things.

So if somebody out there has actual experience with partnerships, commercialization, connections, research opportunities, or knows how to navigate that world without setting everything on fire, I’m definitely open to talking.

If you're interested in a private walkthrough, or are interested in investing or partnership opportunities, feel free to reach out to me.

Ryan Walters Ryan@Verhash.com

LLMs are probabilistic by nature. They’re great at producing fluent, creative, context-aware responses because they operate on likelihood rather than certainty. That’s their strength—but it’s also why they’re risky in production when correctness actually matters. What I’m building is not a replacement for an LLM, and it doesn’t change how the model works internally. It’s a deterministic gate that runs after the model and evaluates what it produces.

You can use it in two ways. As a verification layer, the LLM generates answers normally and this system checks each one against known facts or hard rules. Each candidate either passes or fails—no scoring, no “close enough.” As a governance layer, the same mechanism enforces safety, compliance, or consistency boundaries. The model can say anything upstream; this gate decides what is allowed to reach the user. Nothing is generated here, nothing inside the LLM is modified, and the same inputs always produce the same decision. For example, if the model outputs “Paris is the capital of France” and “London is the capital of France,” and the known fact is Paris, the first passes and the second is rejected—every time. If nothing matches, the system refuses to answer instead of guessing.

That’s a fair critique, but it slightly misidentifies what’s being claimed. The system does not assume embeddings encode truth, nor does it attempt to extract truth from latent space. It measures proximity to a substrate that has already been declared authoritative. In that sense it’s a conditional gate, not a semantic oracle. If the substrate is wrong, incomplete, or absurd, the mechanism will enforce that wrongness consistently. That is not a failure mode; it is the boundary of responsibility. The engine is not discovering truth, it is enforcing consistency relative to an explicit reference set.

On salami-slicing toward a contradiction: that concern applies to memoryless, single-pass filters. This mechanism is explicitly stateful. Deviations accumulate stress over time and do not reset, so a sequence of “almost acceptable” steps still fractures under sustained pressure. You cannot asymptotically walk toward a contradiction unless the configuration allows it, in which case that permissiveness is deliberate and inspectable. The trade being made here is not correctness for convenience, but opacity for causality. Instead of stochastic acceptance that can’t be replayed or audited, you get a deterministic enforcement layer whose failure modes live upstream in substrate and configuration choices, where they can be examined rather than guessed at.

Here “exclusion” just means a deterministic reject / abstain decision applied after a model has already produced candidates. Nothing is generated, ranked, or sampled here. Given a fixed set of candidate outputs and a fixed set of verified constraints, the mechanism decides which candidates are admissible and which are not, in a way that is replayable and binary. A candidate is either allowed to pass through unchanged, or it is excluded from consideration because it violates constraints beyond a fixed tolerance.

In practical terms: think of it as a circuit breaker, not a judge. The model speaks freely upstream; downstream, this mechanism checks whether each output remains within a bounded distance of verified facts under a fixed rule. If it crosses the threshold, it’s excluded. If none survive, the system abstains instead of guessing. The point isn’t semantic authority or “truth,” it’s that the decision process itself is deterministic, inspectable, and identical every time you run it with the same inputs.

Verified facts:

“The sky is blue”

“Water is wet”

Candidate outputs:

“The sky is blue”

“The sky is green”

Each sentence is embedded deterministically (in the demo, via a hash-based mock embedder so results are reproducible). For each candidate, I compute:

similarity to the closest verified fact

distance from that fact

a penalty function based on those values

Penalty accumulates over a fixed number of steps. If it exceeds a fixed threshold, the candidate is rejected. In this example, “The sky is blue” stays below the threshold; “The sky is green” crosses it and is excluded.

What I tested:

Identical inputs + identical config always produce identical outputs (verified by hashing a canonical JSON of inputs + outputs).

Re-running the same scenario repeatedly produces the same decision and the same hash.

Changing a single parameter (distance, threshold, steps) predictably changes the outcome.

Why this isn’t “AI slop”:

There’s no generative model here at all.

The terminology is unfortunate but the code is explicit arithmetic.

The entire point is removing non-determinism, not adding hand-wavy intelligence.

If you think the framing obscures that rather than clarifies it, that’s useful feedback—I’m actively dialing the language back. But the underlying claim is narrow: you can build governance filters that are deterministic, replayable, and auditable, which most current AI pipelines are not.

If that’s still uninteresting, fair enough—but it’s not trying to be mystical or persuasive, just mechanically verifiable.

You can test it here if you like, https://huggingface.co/spaces/RumleyRum/Deterministic-Govern...

Not satire, though I get why the terminology looks odd. The language comes from materials science because the math is the same: deterministic state updates with hard thresholds. In most AI systems, exclusion relies on probabilistic sampling (temperature, top-k, nucleus), which means you can’t replay decisions exactly. This explores whether exclusion can be implemented as a deterministic state machine instead—same input, same output, verifiable by hash.

“Mechanical” is literal here: like a beam fracturing when stress exceeds a yield point (σ > σᵧ), candidates fracture when accumulated constraint pressure crosses a threshold. No randomness, no ranking. If that framing is wrong, the easiest way to test it is to run the code or the HF Space and see whether identical parameters actually do produce identical hashes.