Forem: Martin Nicolas Sanchez Morales

What If We’ve Been Doing Software Governance Wrong This Whole Time?

Martin Nicolas Sanchez Morales — Thu, 23 Apr 2026 18:04:24 +0000

`# What If We’ve Been Doing Software Governance Wrong This Whole Time?

I know. Big claim.

But hear me out.

We’re really good at tracking systems.

Like, really good.

logs
metrics
traces
event streams

We can replay what happened down to the millisecond.

But then something breaks — not just a bug, but something messy —
and suddenly the question changes:

not what happened
but why did we allow this to happen?

And that’s where things get weird.

The thing we don’t model

There’s one thing almost no system treats as a real, first-class object:

👉 the human decision behind a change

We assume it exists somewhere:

“it was approved”
“we talked about it”
“it’s in a ticket”

But inside the system?

It’s gone.

So what do we actually have?

We have systems that can tell you:

✔ what changed
✔ when it changed
✔ how it changed

But not:

❌ who decided
❌ under what reasoning
❌ whether that decision even existed

That’s not a bug

That’s a missing layer.

And it gets worse with AI

Now we’re building systems that:

generate code
trigger actions
chain decisions

And we’re still logging like it’s 2010.

We’re capturing outputs…

but not the decision boundary that allowed them.

The uncomfortable realization

We’ve been building systems that can explain everything…

except responsibility.

What I’ve been working on

I’ve been exploring this as a structural problem, not a tooling one.

The idea is simple:

What if decisions were part of the system?

Not comments.
Not tickets.
Not “somewhere else”.

But bound to the execution itself.

Minimal model

That leads to something very small, almost boring:

append-only logs
evidence that includes presence and absence (E+ / E−)
explicit decision events (HUMAN_DECISION)

That’s it.

No framework.
No magic.

Just a missing primitive.

Why this matters

If a system can’t reconstruct:

who allowed a change and why

Then it’s not fully auditable.

And if it’s not auditable…

you don’t actually control it.

I wrote this up

Paper:

“The Missing Decision Layer: Structural Failure in Information Systems and the Case for a Minimal Governance Kernel”

👉 https://doi.org/10.5281/zenodo.19709093

Curious

How are you handling this today?

approvals in code?
logs + tickets?
just trust? 😅

Because I’m starting to think:

👉 we’ve been solving observability
👉 but ignoring authority

And that gap is going to matter more than we think.
`

We built a governance layer for AI-assisted development (with runtime validation and real system)

Martin Nicolas Sanchez Morales — Fri, 27 Mar 2026 22:49:59 +0000

I’ve been working on a project called Janus — a governance layer for AI-assisted development systems.

The core idea is simple:

Instead of evaluating performance, we evaluate governance through evidence and protocol conformance.

We just published the second paper, which moves from the theoretical model to measurable governance:

Evidence-based model (E+/E−)
Omission detection
Human authority boundaries
Deterministic reconstruction
Benchmark (ECR, GVL, PVDR)

Paper 1 (model):

https://doi.org/10.5281/zenodo.18974356

Paper 2 (validation):

https://doi.org/10.5281/zenodo.19239183

There’s also a live system running on top of it:

https://lluviadeideas-juegosdidacticos.github.io/trivias/

And the framework used to run it:

https://framework.janusgovernance.org/

I’d really appreciate feedback — especially from people working on observability, event sourcing, or AI tooling.

Building Janus: A Minimal Governance Kernel for Human–AI Development

Martin Nicolas Sanchez Morales — Thu, 12 Mar 2026 16:45:29 +0000

I just published the foundational paper for a project called Janus.

Janus is a minimal governance kernel for human–AI development systems. The goal is to introduce a lightweight governance layer that helps maintain traceability, deterministic reconstruction, and evidence-based decision processes when building software with AI assistance.

The project explores how small governance primitives can help teams understand what happened during development, why decisions were made, and how a system state can be reconstructed.

The foundational paper and repository were developed in about a week using the same governance protocol the project proposes.

Paper (DOI)
https://doi.org/10.5281/zenodo.18974356

Repository
https://github.com/Janus-Governance/janus-governance-core