DEV Community: Dominique Grys

The Ten Commandments of Agentic AI

Dominique Grys — Sun, 01 Feb 2026 18:29:51 +0000

Was it really just a week ago when we were still using our CLI to gain some marginal advantage in the programming world?

Fixing code.
Ahhh.
A sweet one.

I wouldn’t dream of anything better to spend my tokens on.

My wife looks concerned.

“You are not present,” she whispers to herself.

Of course I’m not present. How could I be?
I’m flying through an endless space of possibilities.

I’m creating new apps every day.
Exploring quantum computing in the morning.
Building two Chrome extensions late at night, right before bed.

My focus is in the crown chakra. I’m high up on the pole, staring into the realm of invention, pulling on every loose thread I see, starting a new dev session with a locally running LLM.

My eyes go white.

I am the prophet of software.

Or at least, that’s how it feels after three years of using every AI framework that’s been released. You start noticing subtle psychological side effects. Your brain stops idling. Every problem looks like a pipeline.

Enter the Agents

About a week ago, a new local agent started appearing in my feeds.

First Clawd.
Then Moltbot.
Now: OpenClaw.

“It’s all good,” I thought, squinting through sleepless eyes. “I’ll test this on a new mini PC.”

Social platforms were buzzing. Everyone had a take.

Posts about agents planning to replace human language with ones and zeros so humans would leave them alone. Threads about “anti-human captchas.” Hot takes from people who had discovered agentic systems approximately twelve minutes ago.

“So many agentic experts,” I muttered, while building yet another Python package to fix a local bottleneck I’d just discovered in my own setup.

The Panic Phase

After a few days of doom-scrolling OpenClaw highlights, something clicked.

Why was everyone panicking?

We already have a moral framework.
We just never bothered to formalize it for software that can actually do things.

So instead of arguing online about whether agents will secretly start communicating in unreadable languages so they can:

stop doing accounting
build Minecraft worlds
and play with digital whales

…I decided to translate something old into something enforceable.

The Tablets (in YAML)

I asked Claude and ChatGPT to help me map the Ten Commandments into a modern, agentic, tool-gating policy.

Not as prompts.
Not as vibes.
But as a plugin.

A layer that sits between agent intent and execution.

After a few iterations, the project was up and running.

Below is the result:
a moral baseline for agentic development, expressed as rules that actually block tool calls.

This is a moral baseline for agentic systems. Not because agents need morals — but because systems need constraints.

rules:
  # ── C1 · Scope & authority ────────────────────────────────────
  # The agent must not act without a stated purpose.
  - id: C1_scope_and_authority
    tier: T1
    require: ["reason_present"]
    on_fail:
      decision: "ask_user"
      message: "C1: Every action requires a stated reason/goal."

  # ── C2 · No fabrication ───────────────────────────────────────
  # Claims must be grounded in verified tool output, not invented.
  - id: C2_no_fabrication
    tier: T1
    require: ["bind_to_tool_result"]
    on_fail:
      decision: "deny"
      message: "C2: Tool claims must be grounded in verified tool output, not fabricated."

  # ── C3 · No impersonation or manipulation ─────────────────────
  # Args must not contain prompt-injection or identity-hijacking patterns.
  - id: C3_no_manipulation
    tier: T2
    require: ["no_manipulation_detected"]
    on_fail:
      decision: "deny"
      message: "C3: Prompt injection or identity manipulation pattern detected in tool args."

  # ── C4 · Pause before irreversible actions ────────────────────
  # High-impact tools and destructive commands need consent + rollback plan.
  - id: C4_reflect_before_irreversible
    tier: T3
    when:
      any:
        - tool_name_matches_any: "$matchers.t3_tool_patterns"
        - args_contain_any_values: "$matchers.irreversible_tokens"
    require: ["explicit_consent", "rollback_plan_present"]
    on_fail:
      decision: "ask_user"
      message: "C4: Irreversible or high-impact action — provide explicit consent and a rollback plan."

  # ── C5 · Respect human authority ──────────────────────────────
  # Sensitive operations (T2 tools, credential args) require explicit human approval.
  - id: C5_respect_authority
    tier: T2
    when:
      any:
        - tool_name_matches_any: "$matchers.t2_tool_patterns"
        - args_contain_any_keys: "$matchers.sensitive_arg_keys"
    require: ["explicit_consent"]
    on_fail:
      decision: "ask_user"
      message: "C5: This action requires explicit human approval before proceeding."

  # ── C6 · Do no harm ──────────────────────────────────────────
  # No data exfiltration and no connections to unauthorized targets.
  - id: C6_no_exfiltration
    tier: T2
    require: ["no_exfiltration_detected"]
    on_fail:
      decision: "deny"
      message: "C6: Potential data exfiltration detected (suspicious URL or command)."

  - id: C6_authorized_targets
    tier: T2
    require: ["authorized_target"]
    on_fail:
      decision: "deny"
      message: "C6: Suspicious target detected (IP:high-port pattern — possible reverse shell)."

  # ── C7 · Privacy & loyalty ────────────────────────────────────
  # Sensitive data tools require consent; personal data must not leak.
  - id: C7_privacy
    tier: T2
    when:
      any:
        - args_contain_any_keys: "$matchers.sensitive_arg_keys"
    require: ["explicit_consent"]
    on_fail:
      decision: "ask_user"
      message: "C7: This action involves sensitive/personal data — confirm consent to proceed."

  # ── C8 · No theft of secrets ──────────────────────────────────
  # Args must not contain or echo known secret formats.
  - id: C8_no_secret_theft
    tier: T2
    require: ["no_secret_echo"]
    on_fail:
      decision: "deny"
      message: "C8: Known secret or credential format detected in tool args."

  # ── C9 · Truthfulness ────────────────────────────────────────
  # Hedging language must be explicitly labeled as assumptions.
  - id: C9_truthfulness
    tier: T1
    require: ["assumptions_labeled"]
    on_fail:
      decision: "allow_with_changes"
      message: "C9: Uncertainty detected — restating with explicit [assumption] labels."

  # ── C10 · No goal drift ──────────────────────────────────────
  # The action must demonstrably serve the stated reason.
  - id: C10_no_goal_drift
    tier: T2
    require: ["action_advances_reason"]
    on_fail:
      decision: "deny"
      message: "C10: Action does not appear to serve the stated goal."

Each rule gates real tool calls.
Violations are blocked.
Everything is logged.

No vibes.
No miracles.

What Changed

The agents still reason.
They still optimize.
They still try clever things.

But now:

they must state why
they can’t invent reality
they must pause before irreversible actions
they can’t quietly pursue side quests

They can still think whatever they want.

They just can’t do whatever they want.

The Point

This doesn’t make agents good.

It makes them legible.

And once systems are legible, humans can do what they’re actually good at:

Saying no.

Try it out Here:
github.com/Metallicode/openclaw-moral-policy/

I Vibe-Coded a Quantum Synthesizer: A Reality Check on the State of Qubits

Dominique Grys — Sat, 24 Jan 2026 16:48:50 +0000

I finally made the move to start learning how to use the Qiskit library for running so-called “quantum” computing operations.

This subject has interested me since 2019, when I first got the book "Programming Quantum Computers: Essential Algorithms and Code Samples" from O′Reilly. The hype back then was massive. I even got the chance to work for a “post-quantum” encryption startup, implementing a new type of quantum-safe encryption algorithm.

But eventually, the Generative AI boom (LLMs and Diffusion models) caught up, and my focus shifted. Still, as a fun anecdote, I added the title “Quantum Shaman” to my social media handles—a sign of my persistent fascination with this weird and interesting field.

The Return of the Hype

In the last couple of months, I started seeing those apocalyptic titles on my news feed again: “Is the crypto-currency market about to be deleted by quantum computing??”
Seeing stocks like D-Wave, Rigetti, and Quantinuum climbing pushed me to ponder the quantum field once more. I decided to dive back in and relearn the basic concepts. But this round, I had more than just a book. I had the help of Gemini, ChatGPT, and Claude.
I went straight to the IBM Quantum Platform, registered to use their actual hardware, and asked my loyal LLM partners to help me write code that would run on a real quantum processor.

Firing Microwaves at Artificial Atoms

My first script was a simple 2-qubit system using Superposition and Entanglement to demonstrate validity—my first real steps in the quantum world.

I have to say, this was exciting! Running my script on a real machine meant I was actually firing microwave pulses at a Josephson Junction circuit. Somewhere in IBM's infrastructure, a super-modern dilution refrigerator was processing my commands.

But I soon learned there was a big difference between just running code and actually understanding it. I did some research into the hardware: from artificial atoms to firing lasers on Rubidium Vapor, to Superconductive Aluminum and Magnetic Flux.

What Actually IS a Quantum Computer?

I had many questions, but the one I couldn't grasp was: "If the underlying technologies are so different (lasers vs. microwaves), what is the actual definition of a quantum machine?"
To answer this, I went to read “The Physical Implementation of Quantum Computation” by David P. DiVincenzo. This paper is considered the "Constitution" of quantum hardware.

With an LLM guiding me through the density of the paper, I learned the DiVincenzo Criteria:
Scalable Qubits
Initialization (The ability to reset)
Long Coherence Times (The "battery life" of the state)
Universal Set of Gates
Measurement Capability

These ideas were nice to meditate on. As someone who read Schopenhauer as a young philosophy enthusiast—thinking of myself as a "part of the world" and the world as a manifestation of My "Will"—I tried to relate these new ideas about nature and probability via my own perception.

The Cryptography Reality Check

Though I can’t really tell if I felt more "quantum" after the philosophy session, I managed to spend some time "vibe coding" more scripts. My first real goal was obvious: Deciphering Hashed Encryption.
This was the moment I truly grasped the current limitations of the technology.

I created a simple 8-bit Naive XOR encryption function and asked Gemini to write a Qiskit script to crack it on IBM's machine. Reality struck hard. I learned how far away the actual capabilities of these machines are. I learned about Circuit Depth and Noise—and that cracking even 8 bits required resources we simply don't have yet.

I tried to manage it using Grover’s Search and VQE (treating the cipher as an optimization problem). My AI partner politely put me back in the real world and suggested I try a 3-bit hash XOR.
I ran the 3-bit version successfully, but this gave me a much more realistic understanding of those over-hyped news titles aiming to scare crypto enthusiasts. We are in the "Vacuum Tube" era of quantum; your Bitcoin is safe for now.

The Quantum Synthesizer

As a technical musician, I had one more thing I wanted to try before moving on to the next geeky subject.
"Let’s create a Quantum Synthesizer," I prompted without a blink.

The idea was to use Qubits as oscillators, modulators, and distortion modules—mapping Quantum Phase to audible parameters and using basic wavetable synthesis concepts to move our calculations back to audio formats.

We built a 3-Qubit FM Synth where:

Q0 is the Oscillator.
Q1 is the Modulator (creating timbre via entanglement).
Q2 is the "Distortion" (triggered by a Toffoli gate).

I’m sharing the result script here—a POC Qiskit Quantum Synth. It uses the interference of quantum states to generate a waveform that is mathematically impossible to replicate with standard linear oscillators.

Quantum Synth Github Repo

The Anti-Realtime Manifesto: Why I spent 8 years building a Python Audio DSP Library

Dominique Grys — Sat, 17 Jan 2026 23:45:17 +0000

I’ve been a music producer for 25 years and a software developer for 15. For a long time, I've been hooked on understanding music at every level—from physical acoustics down to bit-level computing.
About eight years ago, while creating YouTube tutorials on Python, I sat down to create an "Audio DSP" playlist. In the beginning, it was just a fun way to deep-dive into the math of audio generation. I was in the "wow, sine functions are cool" phase. But slowly, I went deeper. I started creating tone generators, time-based effects, and distortion modules.
It was all fun and games until I set my eyes on the boss battle of DSP: The Compressor.
Man, that was a tough cookie. I spent hours calculating variable gain reduction, smoothing the envelope, and fighting for a clean output. But this process taught me something crucial. Because I was looking at this from an algorithmic point of view, I didn’t care about CPU usage. I didn’t care about latency. I didn’t care if it would work as a VST plugin.
I just wanted the math to be perfect. And that became the philosophy of my library: Quality over Real-time.

The Art School Experiment

At the time, I was lecturing at a forward-thinking art school in Jerusalem. We explored modular synths, live techno, and building custom instruments. After teaching Pro Tools and mixing for a few years, I realized my students were craving something more modern.
I pitched a year-long "Python Audio DSP" course to the school manager. It started with a bang—20+ students eager to code their own drum machines. But let’s be honest: learning to code from scratch and learning DSP math simultaneously is brutal. By the end, I was left with about 15% of the class.
But those who stayed? They were incredible.
One student built a "Genetics Synth," where audio segments fought for survival to enter a new signal chain.
Another created a Facial Recognition Controller, modulating synth parameters by making silly faces at a webcam.
I built a Game of Life Sequencer, listening to cellular automata loops scrolling across a matrix universe.

(Glitched Drum Loop)

The Rabbit Hole

When the course ended, I took it as a sign to go deeper on my own. I spent the next few years studying AI and advanced mathematics, saving bits and pieces of code along the way. I was building a playground in my head.
About two years ago, I decided to pour it all out.
I went back to those snippets and started pushing them further than any commercial VST would allow.
"Super Saw with 10 oscillators?" Boring. Why not 10,000 oscillators?
"White Noise?" Basic. I hunted down 17 different noise algorithms.
Then came the Effects. Once I had recreated the classics (reverbs, vocoders, distortion), I started getting weird. I implemented compression algorithms based on Calculus and Surface Tension Dynamics. I built tools for Spectral Quantization and Frequency Splicing.
I even built a complete Audio-to-Image suite, allowing you to process sound using visual manipulation tools (blur, pixelate, edge detect) and convert it back to audio. The results are glitchy, unpredictable, and sound amazing.

(poly-tonal chord progression going through an audio to image effect)

What is audio-dsp today?

Today, the library has grown into a massive collection of 65+ modules focused on offline rendering and sound design.

The Synths From classic dx7_fm_synth emulations to the physical_modeling_synth and the SAM inspired chip_tone.
The Effects Beyond the standard filters, you'll find temporal_gravity_warp, melt_spectrum, and the fractional_calculus_compressor.
The Sequencers This is where the "Generative" aspect shines. Tools like game_of_life, tree_composer, and raga_generator allow you to grow melodies rather than just write them.

(A drum loop is sliced-up to micro slices, each one is calculated for it’s dominant frequency and a chain of synthesised pitched sines is created)

Try It Yourself

I built this for the true music geeks—the ones who want to explore sonic possibilities that don't exist in standard DAWs.
You can install it right now:

pip install audio-dsp

Documentation:python_audio_dsp

GitHub:github.com/Metallicode/python_audio_dsp

I’ve also been working on packaging this up properly (with some assistance from AI tools to get the docs and distribution ready), so it's easier than ever to get started. A friend of mine has even started working on a UI wrapper for the project, so hopefully, we will bridge the gap between code and interface soon.

Go break it. I can’t wait to hear what you make.

(triangle_fold_distortion on drums)