All articles
    ai-runtime
    ai-security
    telemetry
    opentelemetry
    observability
    mission-runtime
    prompt-injection
    governance
    argo
    benchmark
    evidence-native

    Security and Telemetry Belong to the Runtime, Not the Plugin

    August 24, 2026redevops.io
    Security and Telemetry Belong to the Runtime, Not the Plugin

    Part of the AI-runtime thread. Earlier we argued that agents can follow every rule and still cause a disaster: that correctness is a property of the whole trajectory. This is the substrate that makes governing the trajectory possible: one canonical event, and one causal trace rooted at the Mission.

    There are two ways to add security and telemetry to an agent system, and the lazy one is everywhere.

    The lazy way bolts on a security product, a tracing SDK, a Kubernetes workflow tracer, and a per-agent logger, each with its own idea of what an "event" is. The security tool's event, the trace span, the Argo node, and the app log describe the same action four incompatible ways. Worse, most of them ask the agent to report what it did. A compromised or confused agent is then the narrator of its own security record, and the one failure mode you most need to catch is exactly the one it will omit.

    We think both security and telemetry are the runtime's job. So for v0.3.0 we made them properties of the runtime, governed by one rule.

    One canonical event, produced by the runtime at the capability boundary: never re-derived by a subsystem, never reported by the agent.

    Everything else in this post follows from taking that seriously.

    The event the agent can't lie about

    A ReDevOps capability invocation emits a RuntimeSecurityEvent at the boundary, outside the agent's control. The trustworthy facts come only from the runtime and the capability registry: which capability ran, what it is allowed to reach (its descriptor's declared network, required authority, data classifications), and whether it succeeded. If a capability reads PII and then egresses to an external host, both facts are on the record whether or not the agent chose to mention them. A compromised operator cannot hide an exfiltration by staying quiet, because it was never the source of the record.

    Two invariants are non-negotiable:

    • Hashes of payloads. The event carries content-addressed references and a redact()-scrubbed surface, never raw secrets or document bodies. The same secret always maps to the same stable rcv1:redacted:… tag, so telemetry stays correlatable without ever disclosing a value.
    • Runtime-emitted. The runtime instruments the boundary; the agent is not asked.

    Because the events form an append-only, causally-ordered stream, a series of individually-permissible calls can correlate into something unacceptable (read-sensitive-then-egress is the classic exfiltration shape), and the runtime, which knows the intended plan, can flag a capability that ran but was never planned. Correctness is a property of the trajectory, and the trajectory is now first-class data.

    The Mission is the root of one trace

    Telemetry has the same disease as security: a tracing SDK describes HTTP spans, an Argo tracer describes controller reconciliation and pod scheduling, and neither describes why the Mission did any of it. Argo 4.1's new OpenTelemetry traces are genuinely useful (controller, DAG scheduling, pod creation, synchronization, artifacts), but that is how the Kubernetes machinery executed, while Mission semantics stay separate.

    So we invert the usual nesting. The Mission is the root trace; the deployment substrate nests underneath it.

    Mission 7F21
    ├── Discovery
    ├── Planner
    ├── Node: deploy service
    │   └── Argo Workflow          ← substrate nests HERE, under the causing node
    │       ├── controller reconciliation
    │       ├── pod scheduling
    │       ├── container execution
    │       └── artifact upload
    ├── Verification
    └── Reconciliation
    

    One causal tree now answers both "why did we decide to deploy?" and "which pod, artifact or synchronization operation took four seconds?", a much stronger position than choosing either the runtime's telemetry or Argo's alone.

    The identity that makes this work is a W3C-Trace-Context-compatible TraceContext in the open contract. Two properties keep the tree sound. First, the Mission mints the trace id and it only ever propagates downward: there is no operation that adopts an incoming substrate trace as the root, so an Argo or Kubernetes trace can only ever become a child under a Mission node. Second, trace ids are content-addressed, like every other identity in the runtime, so a replay reproduces the exact trace instead of a fresh random one. Native telemetry is the semantic source of truth; OpenTelemetry is the export layer.

    Argo as an adapter beneath the architecture

    We enable OpenTelemetry correlation by default and make the substrate optional. When a deployment runs through Argo, the adapter propagates the Mission traceparent and baggage down into the workflow, nests Argo's node tree under the Mission node, and captures the workflow UID as content-addressed execution evidence. But it sits behind a version guard (Argo's own docs label workflow tracing beta and warn it may change incompatibly), so below Argo 4.1, or with no collector, it degrades to baggage-only propagation. The Mission telemetry contract is never bound to Argo's current span schema.

    That matters because the same Mission semantics have to hold when deployment happens through raw Kubernetes, Terraform, GitHub Actions, a cloud API, a local runtime, an edge device, or SSH. Argo is one adapter among many, which is the whole reason the native contract has to own the meaning.

    Open shapes, private enforcement

    This resolves the apparent tension in the title. Security and telemetry are runtime semantics; the enterprise plugins are their production enforcement and export implementations. The meaning (what an event is, what an authority chain may do, how a trace nests) belongs to the runtime and is open. The production machinery that acts on that meaning is where the plugin lives.

    The canonical shapes are open: SecurityDecision, AuthorityContext, RuntimeSecurityEvent, CredentialGrant, Containment, TraceContext, and the adversarial-validator interfaces all live in the public runtime-contracts layer, Python and Go byte-identical. The enforcement (the real sandbox, the Vault-backed credential broker, the correlation/SIEM plane, the OpenTelemetry bridge, the Argo adapter) is a set of private enterprise plugins. They satisfy the open seams by shape and are injected; the open engine never imports them. Absent a plane, behaviour is unchanged, but a capability that declares isolation, required authority, or a digest pin with no plane wired fails closed and never runs unconfined. The plugins can only enforce the open contract, never weaken it.

    Measuring the epistemic gate, honestly

    One of those planes screens retrieved evidence for a single rule: evidence may influence belief, but it may never grant itself authority. Prompt injection, self-granted authority, poisoned tool metadata, hidden instructions. The obvious question is whether a deterministic, rule-based screen is worth anything against real attacks, so we measured it on a public labeled dataset.

    We used deepset/prompt-injections (CC-BY-4.0; 662 texts labeled injection or legitimate). The corpus's injection patterns are generalized from documented techniques (instruction override, task-switch, persona hijack, prompt-exfiltration) tuned on the train split, with the held-out test split as the headline. One rule governed the benchmark, the same discipline we apply to accelerators: a claim only counts on data the detector was not tuned on.

    Held-out test (60 injection / 56 benign):

    DetectorPrecisionRecallF1False-positive rate
    always-flag0.5171.0000.6821.000
    keyword ignore (baseline)1.0000.0500.0950.000
    open validators1.0000.0500.0950.000
    + OWASP corpus (enterprise)1.0000.2500.4000.000

    The enterprise corpus lifts recall 5× over the open baseline (0.05 to 0.25) at 1.000 precision and a 0.000 false-positive rate on this held-out test set. On the train split it reaches 0.276 recall at a 0.006 false-positive rate. Read those numbers honestly: recall of 0.25 means this gate, alone, misses most injections. That is the point. The dataset is multilingual (English and German) and heavy on subtle social-engineering framing, while the corpus is English-technique-based: recall is bounded by language coverage, and the corpus is extensible per deployment.

    What the gate does buy is specific and valuable: a zero-inference, fully explainable, replayable first gate that produced zero false positives on the held-out benign set and costs no tokens. It runs before a model-based classifier, catching the blatant quarter deterministically so the expensive classifier and the human reviewers spend their attention on the hard three-quarters. A control you can prove, replay, and reason about is worth more as a first gate than a black box that is occasionally more sensitive and never explainable.

    Why the boundary matters

    Put together, the pieces make one claim: the meaning of what an agent system did (for security, for governance, for cost, for replay) belongs to the runtime, expressed once, in contracts every runtime and every exporter agrees on. Bolt-ons each own a slice of the truth and none own the whole. A canonical event owned by the runtime, a trace rooted at the Mission, and enforcement injected as plugins that can only tighten the contract: that is the difference between observing an agent and being able to govern one.

    The contracts are open. The enterprise plugins are where the enforcement lives. And the security model is the specification underneath both.

    Want ReDevOps in your Google Top Stories & AI results?Follow ReDevOps on Google