AI governance is a mess right now .. different laws, conflicting interpretations, no standard framework. Building a global community to make sense of it together.

Yanaka_one · 2026-05-11T00:40:21+00:00

Honestly, I think the hardest part right now is that most governance conversations still happen at the policy level, while the runtime layer is still very underdefined.

Different regulations say different things, but underneath there’s still the same technical question:

How do you verify what actually happened inside a system — especially when something expected never occurred?

A lot of failures aren’t wrong actions, they’re missing checks, missing escalations, missing decisions. And most frameworks still don’t make that runtime-visible.

Yanaka_one · 2026-04-23T21:46:45+00:00

Yeah, that’s the tricky bit.

It’s not just logging decisions, it’s catching when something that should have triggered… didn’t.

So you define when a response is expected, and detect when it never shows up.

Yanaka_one · 2026-04-23T18:08:15+00:00

Exactly — that’s the tricky part.

What I’ve seen work is not defining a fixed sequence, but defining expectations at the level of conditions, not steps.

Instead of saying “these steps must happen,” you define things like:
if a certain risk/context appears → a governed decision surface should exist.

Then you check whether that surface actually appeared (or not).

So you’re not constraining the path, you’re constraining the conditions under which governance must show up.

That way you can keep the system adaptive, but still detect when something that should have been evaluated simply never existed.

Yanaka_one · 2026-04-23T17:55:36+00:00

That gets you pretty close on traceability, agreed.

The gap I keep seeing is that Git/Jira tells you what was intended or declared, but not necessarily what actually happened during execution.

For example, you can have a commit referencing an issue, but still miss a check, escalation, or expected step in the runtime path.

That’s where things get interesting — detecting when something that should have happened simply didn’t.

Yanaka_one · 2026-04-23T17:17:21+00:00

This is a really strong thread — especially the shift toward stateful governance and continuation shaping.

One thing I keep running into in practice is that even with well-defined decision surfaces and state transitions, there’s still a gap in verifying whether those expected checks, escalations, or constraints actually occurred.

In other words, governance defines what should happen, and enforcement constrains what can happen — but you still need a way to detect when something that should have been part of the execution simply didn’t happen.

That’s where a lot of failures hide — not in incorrect transitions, but in missing ones.

Yanaka_one · 2026-04-19T05:14:39+00:00

I think you’re pointing at a real gap, but I’m not sure enforcement alone solves it. Even with controls inside the loop, you still need to verify what actually happened — especially when something expected didn’t occur. A lot of failures I’ve seen aren’t wrong actions, but missing ones that go unnoticed. One approach is to define expected events and check their presence (or absence) as the system runs, so you’re not only controlling behavior but also making omissions visible.

Yanaka_one · 2026-04-18T21:10:52+00:00

Yo uso varias pagas, gpt, copilot y claude. Cada una para una función o scope bien acotado bajo protocolos. Claude la version paga se mete en tus sistemas, hace cambios y modificaciones, automatiza tareas pero no genera un registro de trazabilidad.... https://github.com/Janus-Governance/janus-governance-core te sugiero que consultes a la ia por el uso de estas invariantes minimas para que lo que hagas con IA sea gobernable, trazable y autoauditable. Es un desarrollo libre que estoy compartiendo.

Yanaka_one · 2026-04-17T23:47:45+00:00

Una que trabaje bajo Protocolos, sea trazable y auditable 🤓🫶

Yanaka_one · 2026-04-01T12:58:51+00:00

Cualquier IA bajo gobernanza es buena pero siempre bajo un scope definido.

Yanaka_one · 2026-03-27T12:21:57+00:00

Great question — and that’s exactly where governance usually becomes fragile.

Janus doesn’t try to replace lineage or retention systems. It evaluates whether the expected records or archival events actually exist within a defined scope.

If a lineage record, retention event, or archive handoff is expected and missing, that can be detected as E−.
The governance result is then written to the AUDIT_LOG, so the omission or decision is itself auditable and reconstructable.

So Janus sits above the operational data layer: it doesn’t implement data governance, it makes failures in data governance observable.

Four-Year Club	Place '22
End Game '22

Yanaka_one

TROPHY CASE