Michael Diegel

Founder, Pulpo Autonomous
AI doesn’t need “oversight.” It needs cryptographic guardrails.
Designing the safety layer AGI will require

[Michael Diegel @MikeyDiegel]

Grok can propose the write.

Pulpo decides whether it may happen.

allow → consume True
replay → False
over budget → deny
https://t.co/gmWaxbdCSt

[Michael Diegel @MikeyDiegel]

SaaS: A World of Dependency, Not Freedom

Remember when you could buy software and actually own it?

Some of us still have Windows XP, Vista, and Windows Server installation discs tucked away in a cabinet. Twenty years later, we can dust them off, install them, and use them again.

Try doing that with a subscription that expired yesterday.

I'm not against SaaS. After years working in IT, including supporting 12 clinics with a two-person team, I understand the value of cloud services. They can save businesses enormous amounts of time and resources.

My problem isn't SaaS. It's the lack of choice.

Businesses should have the right to:
Own and operate software on their own hardware.
Run AI locally without mandatory cloud dependencies.
Maintain, repair, and upgrade systems on their own schedule.
Continue using software they've purchased without recurring payments.
Choose when and whether their data leaves their infrastructure.

And when it comes to AI governance, there's an even bigger question:

What happens when your governance subscription expires?

Does the system fail closed? Fail open? Does enforcement stop because accounting missed a payment?

Imagine missing a car payment and the manufacturer remotely unlocking your doors for anyone to enter.

That's not a security model I'd want protecting my infrastructure.

This is part of why we're building Pulpo around the Right to Own.

Our goal is straightforward: buy it, own it, run it on your infrastructure, and keep using it. Updates shouldn't require another subscription, and substantial future architectural changes can be handled as separate products.

If you want to run your AI in your own server closet, you should be able to.

If you prefer the cloud, that's your choice too.

SaaS should be an option, not an obligation.

The future of AI shouldn't be another monthly bill just to maintain control over your own systems.

Your Hardware. Your AI. Your Rules.

#RightToOwn #RightToRepair #SelfHostedAI #AIGovernance #OnPremAI #Pulpo

[karim_yourself @karim_yourself]

This is DISHONORABLE.

Made in one weekend with Seedance 2.5 and Seedream 5 Pro via LetzAI.

Shoutout to dreamina for contributing video credits!

[Michael Diegel @MikeyDiegel]

ou build the AI. You own the infrastructure. You set the rules.

Pulpo is self-hosted AI coding infrastructure for teams that refuse to hand authority, data, or the kill switch to a SaaS vendor.

It runs coding agents (Claude Code, Codex, pi, or any terminal agent) as durable sessions on machines you control. Sessions survive reboots, resume cleanly, and stay isolated in their own git worktrees. You get exact token and cost metering from the agents’ own session files, hard budget caps that auto-stop work before it overruns, scheduled unattended runs, and webhooks into whatever observability stack you already operate.

Everything stays on-prem. Usage data never leaves your environment. There is no vendor relay, no central control plane, and no invoice that arrives after the damage is done.

For the governance crowd:

Intelligence proposes; your policy and budgets dispose.
You enforce least-privilege execution on infrastructure you own.
Full local audit trail of what ran, what it cost, and when it was stopped.
Right to Own is not a slogan—it is the architecture. Your machines, your agents, your data, your rules.

No SaaS middleman. No surprise bills. No “trust us” black box between your agents and your production systems.

If your security, compliance, or platform team is still treating AI agent spend and authority as someone else’s problem, it is time to put the breaker box on hardware you control.

Take control with Pulpo.
Code. Control. Own.
#AIInfrastructure #SelfHosted #RightToOwn #AIGovernance #OnPrem #DevOps #PlatformEngineering #AIAgents #DataSovereignty

[Warhammer 40K @WH40kbestof]

IG: wellyy_games

[Michael Diegel @MikeyDiegel]

@TomLawrenceTech

The failure mode in that demo is exactly the one that keeps showing up once agents have ambient credentials: the model can be cheap to poison, the trigger stays quiet on normal prompts, and the steal happens the moment the agent is allowed to act.

Sandboxing, stripping secrets, and logging egress are the right containment layer. The missing piece in most setups is that the model’s output is still treated as authority. A governance kernel in front of the tool call changes that: the agent states an intent (principal, action, resource, cost), policy fails closed on anything unknown or over budget, and an allow is bound to a one-use permit that is consumed and written to an audit chain. A trigger phrase in the weights can’t mint the permit.

We’ve been building that plane as Pulpo (fail-closed intents, one-use permits, verifier-backed approval for high-impact actions, evidence for reconciliation). It doesn’t replace the sandbox or the secret store; it removes the path where the model decides it has standing access. Repo is Ironnember/Pulpo1.0 if you want the actual boundary claims rather than a pitch.

https://t.co/FCnyS0xBNv

[Michael Diegel @MikeyDiegel]

What if a sci-fi idea became a testable defensive system?

SENTRY is an experimental barrier inspired by the attack barriers in Ghost in the Shell.

Layered defenses: limit traffic, deny unauthorized requests, activate preauthorized containment. Core rule: SENTRY cannot create its own authority.

Offline simulation under trial—not production. Human operator alerts are part of the design.

Demo: https://t.co/h4P27X7gLO testing: https://t.co/XH4rnLCrpg

Technical feedback welcome, especially on the line between defensive automation and human oversight.

Not affiliated with other products using the Sentry name.

#SENTRY #Cybersecurity #SecurityEngineering

[Ubiquiti Inc @Ubiquiti]

Meet UniFi: Retrofit Solutions

Keep your existing wiring. Upgrade everything else. UniFi the building. Completely license-free.

https://t.co/jTxAcxDygt

[Michael Diegel @MikeyDiegel]

A shared ephemeris only stays safe if a late or disagreed observation cannot mint a new maneuver. Pulpo-Autonomous is that governance plane for spacecraft: it can enforce a delegated burn permit, and it cannot become a second authority when the link is down. Telemetry loss stays unknown until reconciliation, not a retry. It does not exchange trajectories or assess conjunctions.

[Michael Diegel @MikeyDiegel]

Barriers by SENTRY — external testing repo for an AI authority core.

Rust, no deps, no unsafe. Fixed scopes, one-use permits, generation-bound worker ports, monotonic leases, synthetic tripwires, postcondition checks before release.

22 adversarial tests, compile-fail API boundaries, differential checks against a pinned JS reference. Claims labeled verified / inferred / proposed / unknown.

Not a sandbox. Not an EDR. Lab binary does no network.

https://t.co/XH4rnLCrpg

#RustLang #AIAgents #AISecurity #AppSec

[Michael Diegel @MikeyDiegel]

Protect your AI investment with Barriers by SENTRY.

Layered containment. Independent control. Human oversight.

Designed for suspicious activity that may pass conventional controls—not a replacement for firewalls or endpoint security. SENTRY recommends. A separate controller permits. Urgency does not create new powers.

Local research prototype. Production protection is not yet verified.

#AISecurity #CyberSecurity

[Michael Diegel @MikeyDiegel]

I don't disagree that accountability, boundaries and risk ownership need to exist before deployment.

The distinction I'm making is between declaring governance and enforcing governance.

A glossary can define authority. A policy can describe it. A human can assign it. None of those things, by themselves, prevent an AI system from producing an unauthorized consequence.

That's why I focus on the runtime boundary.

In Pulpo, the chain is closer to:

Purpose → Intent → Authority → Policy → Decision → Permit → Execution → Evidence → Reconciliation

So yes—authority and policy absolutely precede execution.

But execution must be technically incapable of treating intelligence, memory, previous success, or a model's own reasoning as authority.

That's the difference I'm pointing to.

Governance doesn't begin at runtime. Governance becomes enforceable there.

[Dr. Clown, PhD @DrClownPhD]

Moving to Texas Simulator 🤠

Don't California my Texas.

[Michael Diegel @MikeyDiegel]

⚡ Pulpo Preview v0.1.0‑preview.2 is live
Traffic Control. Faster Restarts. Windows Tuning. Governance still decides.

The Mad Lads at the Pulpo Lab have been busy. Our latest Pulpo Preview build introduces three major upgrades that push us closer to a fully governed, fully auditable autonomous stack — without shifting the trust boundary by a single millimeter.

🧠 Pulpo Traffic Control (PTC)
We’ve added independent SQL and API execution lanes with bounded queues, concurrency limits, backpressure, and routing for the same intent. PTC organizes the chaos — but remains fully subordinate to governance. It cannot create, renew, reinterpret, or substitute authority. It simply routes what governance has already permitted.
🔥 Faster Restart Verification

An authenticated cache now accelerates restart‑audit verification when the prefix history is unchanged. Local benchmarks: 2.78× to 3.17× faster bootstrap across tested histories. Still linear scanning. Still governed. Still
Pulpo.
🪟 Windows Tuning Package
A new tuning window and per‑user installer bring:
• Bounded thread settings
• Disposable comparisons + JSON export
• Snapshot checks before applying changes
• Undo support and validated migration
• No Python install, no admin account required
Preview builds remain unsigned — this is still the experimental proving ground.

📈 Performance Notes
PTC delivered meaningful gains in mixed workloads, modest costs in SQL‑only paths, and small increases in CPU and allocations. Performance remains a negotiation with physics, not a promise of universal speedups.
🛡️ Validation
Across components:
• 17 PTC tests
• 127 regression tests
• 115 tuning tests + 19 smoke tests
• 64 restart‑cache tests

Separate Linux and Windows results are documented. Full Windows suite still has known failures — preview means preview.

🧭 Try It
Commands, benchmarks, and tuning instructions are included in the release notes.
🔗 Release: https://t.co/JQSzgpQ5hu

Intelligence proposes. Governance disposes. Execution obeys. Evidence reports.

Give AI intelligence. Never give it authority.

#OpenSource #DevTools #AIAgents

[Michael Diegel @MikeyDiegel]

The inventory is not the control. An agent fails by using whatever credentials, tools, and egress it actually has, not by missing a model card. Bias tests and lifecycle states do not stop a process that can delete data, move money, or call an MCP server you did not mean to expose. “Kill switch” only counts if it revokes the token and drops the network path. A registry toggle does not, once the agent has already written a key somewhere else. Human review fails at the same point: the dangerous actions are the ones that finish before anyone is in the loop. Knowing what you run is necessary. Pretending a NIST checklist is how you contain it is the part that does not survive contact with a live agent.

[Michael Diegel @MikeyDiegel]

Today we opened up something special inside Pulpo‑Preview — a space we’ve been calling the Mad Lads Playground.

It’s where we test how far creativity can go when intelligence proposes but governance disposes. Pulpo‑Preview gives us a deterministic governance kernel, one‑use permits, fail‑closed intent evaluation, and adversarial proofs across capability, spend, and execution boundaries. The Playground is where we push those boundaries with high‑energy, high‑curiosity experiments — without ever crossing the authority lines that keep Pulpo safe.

What makes this fun is that Pulpo‑Preview is not a toy system. It’s a public, evidence‑driven governance plane with:

Fail‑closed intent evaluation and exact one‑use permits

Capability‑stripped MCP projections for safe read‑only proposals

Execution‑context binding so nothing runs outside its authorized surface

Outcome‑memory gates that record consequences without granting authority

Adversarial proofs separating task, spend, execution‑environment, and duplication authority

Inside the Mad Lads Playground, we use these constraints as creative fuel.
We explore wild proposals, hostile‑worker topologies, semantic‑authority corruption tests, and capability‑derivation boundaries — all while keeping governance intact and consequences contained.

It’s the perfect environment for founders, engineers, and governance researchers who want to build boldly without breaking the rules that matter.

Pulpo‑Preview is public, transparent, and evolving fast.
If you want to see how deterministic AI governance actually behaves under pressure — or you just want to watch the Mad Lads run experiments inside a real constitutional kernel — the repo is here:

��� https://t.co/voWcp54Lgb

The Playground is open.
Bring your curiosity.
Governance will handle the rest.

#GovernanceTesting #AutonomousSystems #PulpoPreview

[Michael Diegel @MikeyDiegel]

Proof of work.
Pulpo detects the machine, loads its measured performance profile, selects the appropriate worker/batch configuration, then verifies the audit path.
Environment: PASS
Audit verification: PASS
Authority changes: NONE
Self-tuning performance ≠ self-granted authority.
Intelligence proposes. Governance disposes. Execution obeys. Evidence reports.
PULPO READY FOR TEST USE. 🐙

#AutonomousSystems #AI #Cybersecurity

[Michael Diegel @MikeyDiegel]

@XFreeze A dashboard that shows every agent is still a view. It is not the party who can prove a session stayed inside its authority after you closed the laptop.