Enterprise Account Executive

It's trending: Jev by former OpenAI researcher, why is everyone rushing to use it? marsbitPublished on 2026-09-19Last updated on 2026-09-19 Abstract. The AI community is buzzing about Jev, a new "System One Model" from TypeSafe AI, designed for fast, structured judgment calls. Specializing in Yes/No, multiple-choice, and scoring tasks, Jev returns decisions with probabilities, ideal for high-volume, low-latency scenarios. Its popularity is surging as developers integrate it into AI agents to act as a low-cost, high-speed "judge" for tasks like evaluating if an agent's goal is complete, analyzing ad campaigns, or selecting the next action in a browser automation. For instance, it classified 724 real-time ads in about 40 seconds and is being used in projects like `fast-jev-compaction` to intelligently prune AI context. Early benchmarks from TypeSafe suggest dramatic speed and cost advantages, positioning Jev as potential infrastructure for the myriad small, intelligent decisions that could power future AI applications. Named after economist William Stanley Jevons, it embodies the "Jevons paradox": by making intelligent judgments radically cheaper, their overall usage may explode. Machine Heart Editorial Department Recently, a new name has emerged in the AI circle: Jev. Over the past few days, Jev has rapidly trended on X, GitHub, and Agent developer communities. Some used it to analyze 724 real-time ads in 40 seconds, some integrated it into Claude Code to clean up context, others used it for task acceptance testing of AI Agents, and developers have even connected Jev to browser Agents, using it to decide which button to click next or which page to navigate to. LangChain quickly followed up, releasing a Jev-as-a-Judge experiment on September 20th to test its performance as an Agent evaluator. Even OpenAI's "Reset God" Tibo promoted Jev. What exactly is Jev? Simply put, it's an AI specialized in handling "True/False questions." On September 15th, TypeSafe AI officially launched Jev, categorizing such models as "System One Models." According to TypeSafe's definition, these models receive a program state or text information and quickly return structured judgment results along with corresponding probabilities. HTX Group reported on Jev when it was first released. A few days later, its popularity has surged again, with related tweets garnering 37 million views. For example, suppose a customer service system receives an email. A developer can have Jev simultaneously judge: "Is this a sales lead?" "Is the user's sentiment intense?" "Does it require manual intervention?" "Does it belong to billing, technical, or sales issues?" Jev might return a set of probabilities: sales lead: 0.91; requires manual intervention: 0.12; technical issue: 0.83. The application can immediately proceed to the next step based on these numbers. Matija Sosic, Co-founder and CEO of Wasp, also posted a 45-second explanatory video about Jev on X. Currently, Jev offers three core judgment forms: Noul, Choice, and Score. Noul handles Yes/No type judgments, Choice selects answers from given options, and Score rates based on predefined criteria. Each result comes with a probability or confidence score, and multiple questions can be judged simultaneously based on the same input. This design quickly propelled Jev into a rapidly growing application scenario: acting as a "referee" for Agents. Today's AI Agents often need to complete dozens or even hundreds of consecutive steps. After writing code, calling tools, searching the web, and modifying files, the system still needs to judge whether the task is complete. This type of problem perfectly aligns with Jev's mode of operation. Developers can feed an Agent's execution logs to Jev and then ask: "Is the goal achieved?" "Does the result meet requirements?" "Are there any omissions?" "Which quality tier does the current result belong to?" LangChain's latest published experiment follows a similar approach. They had Jev, GPT-5.6 Luna, GPT-5.6 Terra, and Claude Sonnet 4.6 repeatedly score fixed Agent outputs. In this small-scale experiment, Jev averaged about 0.44 seconds per call with a cost of approximately $0.00035, while also demonstrating strong consistency in consecutive scoring. LangChain also emphasized that this is still an early, small-scale test requiring further validation with more Agents and real-world production tasks. A set of data from Jev's performance in ad analysis further boosted its popularity. In an experiment shared by developer Matthew Berman, the system used Jev to analyze 724 real-time ads from 37 brands, classifying them based on Hook, format, Offer, CTA, user cognitive stage, and the consistency between ad and landing page, resulting in a total of 8,724 judgments. According to the data shared by the developer, these tasks were completed in about 40 seconds, with a token cost of about 9 cents, and a median processing time per ad of about 216 milliseconds. This case has been included in the Jev community case library. Another project that spread quickly among developers is called fast-jev-compaction. This Claude Code plugin sends numerous tool calls and terminal outputs to Jev for scoring. Jev judges which content remains relevant to the current task, and then compresses the context sent to the model based on the results. After its release, the project quickly gained significant attention and spawned multiple ported versions. Browser Agents have also become a popular testing ground for Jev. Several open-source projects have already adopted the loop of "browser reads page -> generates candidate actions -> Jev selects action -> browser executes." In a public flight search demo, developers reported the entire search process took about 7 seconds, costing about $0.004. These applications well explain why Jev suddenly caught the attention of Agent developers. Many Agent steps are essentially high-frequency decisions: which button to click, which tool to call, whether this information is relevant, whether the current task is finished, whether a certain result passes acceptance. When these judgments occur hundreds of thousands or even millions of times a day, latency and cost quickly become integral parts of system design. In its own workflow benchmark, TypeSafe claims Jev can achieve up to approximately 193.6x speed improvement and 444.6x cost advantage on certain tasks. TypeSafe also clarifies that these results are at the high end of their estimated practical benefits, and the test set was prepared by the company's model capability team, so these figures are better suited as early references for the technical direction. The naming of Jev also hints at TypeSafe's ambitions. "System One" comes from the System 1 concept proposed by Daniel Kahneman in "Thinking, Fast and Slow," referring to the fast, intuitive judgment system. "Jev" comes from the economist William Stanley Jevons. TypeSafe borrows the meaning of the "Jevons Paradox": when the efficiency of using a resource significantly improves, its overall consumption may instead rapidly increase. In the context of AI, the implication is very clear. When the price of an intelligent judgment drops by orders of magnitude, developers will start incorporating AI in places they previously wouldn't have dared to call a model. Whether a log is important, what type an email belongs to, whether an Agent has completed its task, what cognitive stage an ad is in, which button to choose for a webpage action - these tiny judgments combined could form a massive volume of calls within the next generation of Agent systems. Jev is currently still in early access. Community experiments around it for browsers, code Agents, ad analysis, evaluators, and context management have just begun. But it has already raised a very interesting question: in future AI applications, what truly consumes the most intelligent computing power might be the tens of thousands of small judgments hidden within software processes. And what Jev aims to become is precisely the infrastructure behind these "intelligent if statements." Have you tried Jev yet? What do you think? Reference Links:

Arcjet launches agent runtime security for production AI agents. New product helps teams discover agent activity, apply controls before and after consequential actions, and preserve evidence for security reviews and compliance SAN FRANCISCO, Sept. 17, 2026 /PRNewswire/ - Arcjet, the security platform that ships in your AI code, today launched agent runtime security, a new product that helps engineering teams secure the AI agents they are building while giving security teams the governance and compliance evidence they need. Arcjet brings observability, enforcement, and audit capabilities across agent workflows so teams can discover which agents are running, control what they can do, and understand what happened and why. AI agents are moving beyond chat interfaces and into production workflows, where they can read and write to databases, respond to support tickets, refund payments, call tools and APIs, and take other actions on behalf of users. Those workflows can start from a chat interface, an email, a text message, a code commit, or another event, and can continue autonomously across multiple systems. As agents take on longer-running workflows, security teams need to answer three questions across the full sequence of activity, which agents are running, whether a particular action should be allowed, and what happened and why. Arcjet's agent runtime security addresses those questions through observe, enforce, and audit capabilities. Teams can discover agent activity and connect actions across sessions, apply deterministic security policies before and after calls to LLMs, tools, databases, and APIs, and preserve the execution context needed for security reviews and compliance. "Agents are now taking real actions inside production systems, which means security teams need to know which agents are operating and what they have done, and apply controls at machine speed," said David Mytton, CEO at Arcjet. "A risky outcome can develop across a series of steps that look perfectly reasonable on their own. Arcjet connects those steps and gives teams policy controls to detect them." Arcjet's agent runtime security centers on three parts of securing agents in production, observe, enforce, and audit. Observe: Discover all your agents Arcjet supports ingesting agent activity without application code changes or deploying another agent. Platform and security teams can use existing OpenTelemetry observability tooling to send activity directly to Arcjet for real-time visualization and analysis. For teams using Claude, Arcjet can also pull activity from the Claude Compliance API. Arcjet connects activity across sessions so teams can see an agent's sequence of actions as one workflow rather than a collection of unrelated events. Activity can include prompts, tool call parameters, session metadata, identity, security decisions, and other application context, giving teams a view of what each agent is doing across a run. Agent identity and inventory are part of that visibility. Arcjet gives teams an inventory of the agents and applications operating inside their environment, with activity and individual runs associated with each agent so teams can inspect actions and security decisions step by step. Enforce: Apply controls before and after every action Once teams can see their agents and activity across sessions, Arcjet lets security teams define controls for prompt injection detection, PII and sensitive information leak prevention and redaction, automation and bot detection, rate limits, and quota controls. Arcjet guards apply deterministic policies to tools, APIs, database calls, and other inputs and outputs. Powered by Rego and Open Policy Agent, teams can create versioned, immutable policies through Arcjet's web UI, API, CLI, or MCP without redeploying application code. Policies can define the actions an agent is allowed to take, such as restricting recipients or attachments in an email tool, setting acceptable bounds for refund values, or limiting web fetch tools to trusted API URLs. Arcjet returns a decision to the application before the action executes, allowing the application to stop the operation, request human approval, or return an explanation to the agent. Applied before and after calls to LLMs, tools, databases, and APIs, these controls can mitigate risk before consequential actions and verify results before the workflow continues. For enforcement, Arcjet has native integrations with major agent frameworks, including Claude Agents SDK, Claude Managed Agents, OpenAI Agents SDK, LangChain, LangFuse, Strands, Mastra, and Microsoft's Agent Framework. This in-code context allows Arcjet to track recorded actions, their inputs, and policy decisions across the workflow. Audit: Evidence and proof of compliance Arcjet collects the context of each execution so teams can reconstruct what happened, understand why a policy decision was made, and provide evidence for security reviews and compliance audits. Correlated traces preserve actions, inputs, security decisions, and policy evaluations across the work SOURCE Arcjet

LangSmith gets full OTel support: what it means. LangSmith now ships full OpenTelemetry support in its SDK. Here's what changed, what it costs you, and when you should actually use it. The observability problem nobody talks about honestly. Building an LLM application is one thing. Knowing what it's actually doing at 2 AM when something goes sideways is another problem entirely. Traditional observability tools were built for a world where 'something broke' meant an exception was thrown or a response time spiked past a threshold. They're good at that. But an LLM application can fail in ways that never trigger an alert - the model drifts toward a weird tone, a multi-step agent loop quietly skips a tool call, or a retrieval step returns documents that are technically relevant but practically useless. No exception. No timeout. Just a subtly wrong answer that your users notice before your monitoring does. This is why the question of how you collect and route telemetry data from LLM applications matters so much more than it did for traditional services. And it's why LangSmith's move to ship full end-to-end OpenTelemetry support in its SDK is worth paying attention to - not because it's flashy, but because it quietly solves a real infrastructure headache for teams running complex, multi-service AI systems. What actually changed. Here's the thing about this update that the announcement buries a little: LangSmith already accepted OpenTelemetry traces. It could ingest them on the backend. What it couldn't do was emit them natively from the SDK itself. That meant the OTel pipeline was half-built. You could receive OTel data, but generating it from your LangChain or LangGraph code required extra wiring that most teams didn't bother with. Now the SDK handles the whole pipeline. Your LangChain application generates traces, the LangSmith SDK converts and ships them in the OTel standard format, and those traces land wherever you've pointed your collector - LangSmith's own dashboard, Datadog, Grafana, Jaeger, or all of the above simultaneously. That last part is the real unlock for teams that already have an observability stack and don't want to maintain a separate silo just for their AI layer. Getting started is deliberately minimal. Install the package with OTel support: pip install 'langsmith[otel]' pip install langchain Then set three environment variables: LANGSMITH_OTEL_ENABLED=true LANGSMITH_TRACING=true LANGSMITH_API_KEY=your_key_here That's it. Your existing LangChain code doesn't need to change. The instrumentation happens automatically. For teams that have been avoiding observability setup because it felt like a project unto itself, this is a meaningful reduction in friction. Why OTel is a good fit for LLM tracing (and where it gets complicated). OpenTelemetry's core value proposition is vendor neutrality. It's an open standard, which means the data format isn't owned by any single observability vendor. You instrument once and you can route that telemetry anywhere. For conventional microservices, this has been a genuine quality-of-life improvement - teams stopped being locked into whichever APM tool they chose three years ago. For LLM applications, the fit is mostly good but not perfect. OTel was designed around the concept of spans - discrete units of work with a start time, end time, and a set of attributes. That maps reasonably well onto a chain execution: each LLM call, each tool invocation, each retrieval step can be its own span. Distributed tracing across microservices works exactly as you'd expect, with context propagation linking spans from different services into a single coherent trace. The complications show up at the edges. LLM outputs are stochastic - the same prompt doesn't always produce the same response, and 'correctness' isn't a binary you can encode in a span attribute. The emerging OpenTelemetry GenAI semantic conventions are trying to standardize how things like model name, token counts, and prompt/response content get attached to spans, but those conventions are still evolving. It's worth asking, before you commit to any OTel-based setup, whether the platform you're sending traces to actually understands those conventions or just treats your LLM spans as generic HTTP calls with extra attributes. LangSmith's own dashboard is built specifically for LLM traces, so it handles the nuances - token usage, evaluation scores, intermediate reasoning steps - in ways that a general-purpose tool like Grafana won't do out of the box. That's not a knock on Grafana; it's just a different tool for a different job. The performance trade-off is real, and you should care. LangSmith is upfront about this: the OTel format carries more overhead than their native tracing format. The native format was designed specifically for LLM data patterns - it's leaner, it supports real-time tracing with pending run states (so you can watch a long agent loop execute step by step), and it has a smaller memory footprint in the SDK. The OTel format is more general-purpose. That generality costs something. How much it costs depends on your workload, but if you're running a high-throughput production system where every millisecond of added latency compounds, you'll want to benchmark both formats under realistic load before committing. The practical guidance is straightforward: if LangSmith is your only observability destination and you have no plans to route traces anywhere else, stick with native tracing. You get better performance and features like pending run visibility that OTel doesn't support. If you need traces in Datadog for your SRE team and in LangSmith for your ML team, the OTel integration is the right call - just accept that you're paying a small performance tax for the flexibility. The questions this update doesn't answer. A few things worth thinking through before you wire this into production. First, trace volume. An agent that makes twenty tool calls per user request generates a lot of spans. At any meaningful scale, that's a storage and cost problem. OTel has sampling strategies - head-based, tail-based - that let you capture a representative subset of traces rather than every single one. The LangSmith integration doesn't spell out how sampling is configured or what the defaults are. For a small application this doesn't matter. For a system handling thousands of requests per hour, you'll want to understand this before your observability bill becomes uncomfortable. Second, data privacy. Traces from LLM applications often contain the actual prompts and responses - which means they can contain sensitive user data. Shipping those traces through an OTel pipeline to multiple destinations means that data flows through more systems. Whether LangSmith offers any built-in masking or redaction for sensitive fields in the OTel path isn't clear from the current documentation. If your application handles anything regulated - healthcare, finance, legal - this is a conversation to have before enabling the integration. Third, framework scope. The integration is explicitly for LangChain and LangGraph. Teams using LlamaIndex, or calling the OpenAI SDK directly, or building on other frameworks aren't covered here. OTel instrumentation libraries exist for many of these, but the seamless LangSmith integration described in this release is LangChain-specific. Worth knowing if your stack is mixed. The bigger picture. There's a broader pattern worth naming. The AI tooling ecosystem is maturing, and part of that maturation is AI-specific tools starting to speak the same language as the broader infrastructure world. For a long time, LLM observability was a separate island - you had your model metrics over here and your infrastructure metrics over there, and getting a unified view required custom glue code or a lot of tab-switching. OTel support in LangSmith is a step toward making the AI layer a first-class citizen in existing observability stacks. Your SRE team can use the tools they already know. Your AI team gets the LLM-specific visibility they need. The two don't have to be completely separate concerns anymore. That's genuinely useful progress. Not because it's technically unprecedented - OTel instrumentation has existed for plenty of frameworks - but because it removes the excuse for AI teams to skip proper observability setup. 'It's too much work to integrate with its existing stack' gets harder to argue when the integration is three environment variables and a pip install. The teams that will benefit most are the ones already running mature observability infrastructure who've been treating their LLM layer as a black box because wiring it up felt like a separate project. For them, this is the bridge they've been waiting for. #Platform / Product Updates #GZOO #BusinessAutomation