JevOps: Early Signs Decision Models Are Transforming DevOps

DevOps may be one of the largest untapped use cases for decision models. We are already seeing early signs of what that could look like, with developers putting Jev into telemetry, incident response, SRE agents, CI, Kubernetes, and infrastructure tooling.

The term “JevOps” has started floating around the ecosystem, mostly as a meme at this point. But the opportunity behind it is massive because DevOps is packed with exactly the kind of small semantic decisions Jev is built to make.

Is this log worth investigating? Does this incident look serious enough to wake someone up? Is the proposed remediation broader than the evidence supports? Did the repair actually solve the problem? Which tests are relevant to this change?

These are questions that many DevOps tools are already designed to answer, but until now have had to resort to deterministic rules, specialized classifiers, humans, and increasingly LLMs.

Decision models offer another option: fast semantic decisions that can run directly inside operational systems. That means more of these decisions can be made semantically, continuously, and at a much higher volume than was practical before. Instead of asking a model to reason through an entire incident, you can make thousands of smaller decisions as the incident unfolds.

Jev has been out for less than two weeks, and projects are already appearing across nearly every part of DevOps. Most are small or experimental, but there are already enough to see a pattern.

Here is what people are building and what it tells us about where DevOps may be headed.

More Semantic Telemetry

Cribl was one of the first infrastructure companies to experiment publicly with Jev. Two days after launch, its AI Research team published an investigation into what decision models might mean for telemetry.

The team explored several places where fast semantic decisions could fit into telemetry pipelines, including parser selection, PII detection, alert triage, schema inference, and evaluating agent responses. In the agent evaluation test, Jev maintained more than 92% agreement with Cribl’s committee of LLM judges at roughly 1% of the cost.

Millions of events are constantly being classified, enriched, routed, prioritized, retained, or discarded. Many of those decisions are handled well by existing rules and classifiers, but others require semantic judgment that has historically been too expensive to put directly into the pipeline.

Jev Moves Into OpenTelemetry

Logs have attracted several experiments already. Jev Logs puts Jev in front of expensive log analysis, assessing diagnostic value, priority, and whether deeper investigation is warranted. Every record still goes to the normal archive, while Jev determines whether it should also travel down the expensive analysis path.

Its published benchmark over sanitized HDFS and BGL logs successfully routed 99.3% of anomalous HDFS records and 100% of anomalous BGL records toward analysis, while filtering less than 1% of total records in both datasets.

Jev Logs also ships as an npm package and can wrap an existing OpenTelemetry log exporter, adding Jev assessments without changing the primary archive.

Jevernetes applies the idea to live Kubernetes logs. It highlights events that may deserve investigation, shows surrounding context, and can generate evidence for a coding agent. Jev is optional, with offline keyword rules available as a fallback.

Another project, jevbrief, reduces operational context before Jev sees it. One example takes 1,447 OpenTelemetry log records, groups them into 23 clusters, narrows those to five candidates, and asks Jev which evidence best explains a checkout incident.

The experiments now cover the other major OpenTelemetry signals as well. jevmetrics examines metric metadata for operational relevance, redundancy, and whether a metric belongs in primary storage. It starts in annotation mode so operators can inspect the assessments before allowing them to affect retention.

jevtraces does something similar for spans, assessing whether operations are likely to be useful for diagnosis, business-critical, and worth retaining. A separate experiment combines those annotations with OpenTelemetry tail sampling while maintaining a full archive branch.

These experiments put decision models directly into the pipelines for all three major telemetry signals: logs, metrics, and traces.

Evals Become Operational Signals

Datadog’s Agent Observability team recently showed Jev powering offline experiments and online evaluations of production agent spans as they arrive.

Instead of asking a generative model for an open-ended judgment, the example asks focused questions about whether claims are supported, what failure occurred, and how severe the impact is. The results can be recorded alongside normal telemetry.

Agent traces already contain latency, token usage, errors, and tool calls. Jev can add semantic properties such as whether requirements appear satisfied, whether a policy violation occurred, or whether human review is warranted.

LLM-as-a-judge has often happened after execution. Low-latency decision models make some of those evaluations practical inside the live operational path.

SRE Agents In Second Loop

SREGym added Jev to an SRE agent working through Kubernetes incidents. The agent still investigated the system, ran commands, formed hypotheses, and performed repairs. Jev ran alongside it, ranking proposed diagnostic tests and checking whether enough evidence existed before the agent submitted a diagnosis or declared mitigation complete.

Across ten incidents with five attempts each, the baseline agent passed 20 of 50 attempts. The Jev-assisted version passed 24 of 50, moving from 40% to 48%.

The architecture may be more important than the early benchmark. The idea is that a reasoning model can stay focused on the open-ended investigation while a decision model continuously evaluates smaller questions around its work.

This creates the possibility of a second operational loop running alongside the SRE agent, continuously watching and evaluating the investigation without taking it over. As decision models get faster and cheaper, that loop could make many more decisions than would ever be practical with another reasoning agent.

Semantic Gates on Actions

Permissions can tell an agent whether it is allowed to take an action, but they cannot easily determine whether that action makes sense given the current situation. Jev can help here by evaluating proposed actions before they execute, usually in a high-risk production environment.

The dsh-jev project explores this inside DeepSeek Harness. Its Kubernetes demo has an agent troubleshooting a broken network path while Jev evaluates proposed tools and actions against the current incident.

In one demonstration, the agent proposes a broad network-policy change that would restore connectivity while also exposing PostgreSQL. The action may solve the immediate problem, but Jev identifies the broader risk before it executes.

Traditional authorization still determines what the agent can do, while Jev can continuously evaluate whether an allowed action makes sense in context.

That opens up a much richer set of runtime gates. Is this remediation proportional to the incident? Does this tool call match the current diagnosis? Is there enough evidence to justify a destructive action? Instead of trying to encode every situation into policy ahead of time, DevOps systems can evaluate the proposed action against the situation as it happens.

Incident Response Decomposition

Incident response contains a large reasoning problem surrounded by smaller judgments. Is this a real incident? How severe is it? What evidence should we collect? Is containment warranted? Should someone be paged? Is the service actually recovered?

Several projects are decomposing incident response this way. jev-oncall assesses alerts while ordinary code determines whether the result leads to paging, review, or suppression.

A Jev incident router uses exact ownership data when available and Jev when routing requires interpretation. Low-confidence answers go to a review queue instead of being automatically followed.

A larger security-operations experiment applies Jev across triage, investigation, mitigation, escalation, recovery, and closeout. Each stage asks focused questions rather than handing the entire incident to one model, and the repository stops short of executing the proposed actions itself.

These projects treat incident response less like one giant AI problem and more like a bunch of smaller, less consequential semantic decisions.

CI and Semantic Selection

jev-ci-pathfinder brings the same idea into CI. It looks at a code change and decides which allowlisted CI jobs appear relevant.

The job inventory remains deterministic, always-on jobs remain always on, and dependency closure stays in code. Jev handles the harder question of whether a particular change is relevant to a particular job.

The same question appears across tests, security scans, deployment environments, canaries, rollout checks, and rollback decisions. Many existing rules are approximations for judgments we previously could not ask directly.

Semantic Decisions During Deployment

Deployment and progressive delivery are another natural fit for decision models. A canary rollout already collects evidence about errors, latency, traffic, and system health, but eventually something has to decide whether to hold, promote, or roll back.

A Jev deployment state-machine experiment puts Jev directly at those decision points. The state machine remains deterministic, while Jev evaluates the current canary evidence when the deployment reaches a model-eligible branch. In a captured run, Jev first chose to hold at 5% traffic, then promoted the deployment through subsequent stages as more evidence arrived.

A Jev and Temporal experiment applies the same idea to rollback. Jev looks at operational state and can choose to investigate a recent deployment or roll it back, while Temporal handles execution, retries, durable state, and human approval. In the demo, Jev identifies a recent deployment and chooses rollback as the next action. When the rollback operation initially times out, Temporal retries it without asking Jev to make the decision again.

This opens up a richer version of progressive delivery. Instead of promoting or rolling back from a handful of fixed thresholds, a deployment controller can evaluate the broader state of the rollout at each transition. Is the canary healthy enough to promote? Is the degradation meaningful enough to hold? Does the evidence point strongly enough to this deployment to justify a rollback? The mechanics of deployment stay deterministic while the decisions between stages can become semantic.

Early Signs of JevOps

JevOps is still extremely early, but the opportunity is already visible. DevOps sits between enormous amounts of machine state and a much smaller number of consequential actions, creating countless points where systems have to decide what deserves attention and what should happen next.

Decision models make it practical to put semantic judgment into more of those decisions. DevOps could move from a relatively small number of large reasoning steps to thousands or millions of small decisions happening continuously as systems operate. Every alert, deployment, tool call, incident, trace, and remediation is another opportunity for software to ask a narrow question before deciding what to do next.

DevOps could be one of the first places where inference becomes a normal part of software infrastructure, distributed throughout the operational stack rather than isolated behind an agent or model endpoint.