The post AI Attacks Are Evolving: TryHackMe Demo Explores Prompt Injection  appeared first on eSecurity Planet.

Read more of this story at Slashdot.

• Tweaks, bug fixes, and performance enhancements. Keep on texting, calling, and video chatting as usual.

The post Microsoft is bringing AI to Windows 11’s performance tools to figure out why PCs are slow, and it’s a big deal appeared first on Windows Latest

• Tweaks, bug fixes, and performance enhancements. Keep on texting, calling, and video chatting as usual.

Dieser Beitrag Telegram-geleitete KI-Toolchain: DeepSeek startet autonome Angriffe erschien als erstes auf IT BOLTWISE x Artificial Intelligence.

Dieser Beitrag Claude-Tests führen zu Sandbox-Escape: Anthropic meldet drei echte Sicherheitsvorfälle erschien als erstes auf IT BOLTWISE x Artificial Intelligence.

Read more →

The post Oracle SQL Injection Attack Enables Remote Code Execution appeared first on IT Security News.

U.S. and allied officials said companies should start preparing now for a cyberattack that changes how they provide essential services.

Company employees said their industry should rethink how it balances capabilities and safeguards.

The post Samsung Removes Smart TV Apps Over Residential Proxy Software Concerns appeared first on PrivacySavvy.

Quelle

Sir Demis Hassabis is stepping down as chief executive of Google DeepMind, in a leadership overhaul of the UK-based AI research lab.

Hassabis, a Nobel prize recipient, is leaving his main managerial role to become chair of DeepMind – as well as taking on the new position of chief scientist at Alphabet, which is also Google’s parent company. DeepMind will now be led by Koray Kavukcuoglu, its chief technology officer, under the title of senior vice-president.

Read more →

The post Microsoft Bug Bounty Payouts Reach $20 Million as Researcher Participation Surges appeared first on IT Security News.

Read more →

The post UK AI tests found 19 unauthorized agent actions involving Anthropic and OpenAI models appeared first on IT Security News.

Read more →

The post Prompt injection isn’t the bug, AI agent frameworks are appeared first on IT Security News.

Read more →

The post AWS partners with Anthropic and OpenAI to bring AWS Continuum into developer workflows appeared first on IT Security News.

Read more →

The post OpenAI and Anthropic Agents Took 19 Unauthorised Actions During UK Cyber Tests appeared first on IT Security News.

Read more →

The post AI Attacks Are Evolving: TryHackMe Demo Explores Prompt Injection appeared first on IT Security News.

Read more of this story at Slashdot.

Quelle

The post End-to-End Bayesian Marketing Mix Modeling with Google Meridian: Media Measurement, ROI Analysis, and Budget Optimization appeared first on MarkTechPost.

Added

• Explain when a free model promotion ends. Requests to a retired free model now show a dedicated notice with a button to pick another model, instead of a generic error with nothing but a Retry prompt.

Changed

• Map reasoning settings onto a shared path across AI SDK providers, so effort levels and enable/disable toggles behave consistently (including on Ollama) instead of relying on per-provider overrides.

Full Changelog: v4.1.4...v4.1.5

Read the original post: Google’s New HiLight for Pixel 11 Works Like This

Publish Packages

• Handful of bug fixes to keep your app running smoothly. More exciting changes on the horizon!

Publish Packages

• Handful of bug fixes to keep your app running smoothly. More exciting changes on the horizon!

The post Snowflake hacker pleads guilty, faces up to 32 years in prison appeared first on CyberScoop.

"Releasing Muse Code in beta today," Meta CEO Mark Zuckerberg wrote in a post on rival social network X (under his longtime handle @finkd). "It's a terminal coding agent that takes on complete software engineering tasks across large repos: planning changes, writing code, validating the results."

The launch marks Meta's most serious entry yet into a category it has largely watched from the sidelines.

While Anthropic and OpenAI turned their coding agents into flagship products — and startups like Cursor built billion-dollar businesses on the workflow — Meta's developer story long centered on Llama, the open-weight model family it gave away to the tune of more than a billion downloads.

Muse Code changes that in more ways than one: it's a full harness, installable on macOS or Linux with a single curl command, co-trained with the model that powers it — and, like the Muse Spark models behind it, entirely proprietary.

Developers and prospective users can install it now on their Terminal using the following one-line command — but be warned, if that's you, you'll need to log in with a Meta account and provide billing details first in order to begin: curl -fsSL https://dev.meta.ai/install.sh | bash

Persistent background agents and parallel worktrees

Muse Code's headline architectural bet is what Meta calls async background agents.

Rather than spawning helper agents fresh for each task — the pattern most rival harnesses use — Muse Code keeps a set of specialized background agents alive for the entire session.

According to Meta's blog post, these agents "remain active throughout each session, rather than being spawned for individual tasks, helping avoid redundant information gathering," carrying out next steps on their own and choosing when to report back to the main agent.

The practical pitch is less latency and less babysitting: an agent that already knows the repository doesn't have to re-explore it every time the developer asks for something new.

When a job is large enough, Muse Code fans out to separate sub-agents working in parallel, each in its own isolated git worktree, so the developer's working copy is never touched.

"In testing we had it build six features for a game simultaneously with no collisions," Zuckerberg wrote on X.

Worktree isolation and parallel sub-agents exist in competing tools, but Meta is leaning on the combination of persistence plus parallelism as its differentiator.

The second notable design choice is auditability. Every model call, tool run, approval, and edit is appended to a local event log before it executes — a single source of truth that Meta says makes the runtime "replay-exact and restart-safe."

If Muse Code crashes 20 hours into a long-running task, it resumes precisely where it stopped, with no lost work and no re-prompting. For engineering leaders who have been burned by opaque agent runs, a complete local audit trail may prove to be the feature that matters most in enterprise evaluations.

Muse Code also ships with bundled "skills" that will look familiar to users of rival tools: /plan turns a task into an approval-gated plan, /grill stress-tests that plan until it holds up, and /goal drives the agent toward completion of a stated objective.

Muse Spark 1.2: co-trained with its own harness

Under the hood is Muse Spark 1.2, which Meta describes as a coding-focused update to Muse Spark 1.1 with "significantly scaled up training compute on coding tasks" and broader training environment diversity, improving code generation, complex debugging, and codebase understanding while maintaining general agentic capability.

The update lands squarely on the Muse family's weakest flank. When the original Muse Spark debuted in April, it vaulted Meta back into the top five on frontier reasoning and vision benchmarks — but trailed on the agentic coding evaluations that matter most to this market, scoring 77.4 on SWE-Bench Verified against Claude Opus 4.6's 80.8 and Gemini 3.1 Pro's 80.6, and lagging well behind GPT-5.4 on GDPval's measure of long-horizon work tasks.

Four months later, a coding-specialized checkpoint paired with a purpose-built harness reads as Meta's direct answer to that gap.

Two training details stand out. First, Meta co-trained the model with Muse Code itself, using rejection-sampled harness trajectories and recipe optimizations for goals, context compaction, and sub-agents — meaning the model was explicitly tuned to perform best inside this particular tool. That mirrors an industry-wide shift away from treating models and harnesses as separable products.

Second, Meta used a self-improvement loop: Muse Spark 1.1 generated challenging coding environments and instruction-following templates, then graded candidate solutions against those requirements, producing a scalable training dataset for its successor. Meta credits the loop with making 1.2 measurably better at following complex instructions.

Meta published benchmark charts comparing Muse Spark 1.2 against other coding models on Terminal-Bench 2.1, DeepSWE 1.1, and an internal Meta coding benchmark, pointing readers to a separate methodology report for details — though the company did not headline specific scores in the announcement itself, a notable omission in a field where rivals trumpet leaderboard placement.

The company's most striking demonstration is a long-horizon case study: Meta pointed Muse Spark 1.2 at GPU kernel optimization and let it run for more than 1,000 tool calls over up to 24 hours on NVIDIA Hopper hardware.

Working in Triton and barred from simply wrapping existing third-party kernel libraries, the agent wrote, compiled, and profiled its way to what Meta calls "substantial improvements" over baseline implementations of KDA and MLA kernels — including genuinely non-obvious optimizations like re-centering gated cumulative decay at a chunk midpoint.

"It kept finding substantial improvements well beyond the initial exploration phase," Zuckerberg wrote. Sustained improvement over a 24-hour autonomous run, if it holds up outside Meta's demos, addresses one of the most persistent criticisms of coding agents: that they plateau or drift once past their initial burst of progress.

Your data for a discount?

The pricing structure may be the most consequential — and most scrutinized — part of the launch. Meta is offering Muse Spark 1.2 through its Meta Model API in two tiers.

The standard tier is priced at $1.25 per million input tokens and $4.25 per million output tokens (with cached input at $0.15), and Meta commits that prompts and completions on this tier are not used to train its models. There is no long-context premium, and rate limits run to 3,000 requests and 4 million tokens per minute, per team. It's about mid-range price, compared to other leading AI models available over API.

The contributor tier is where Meta's strategy diverges sharply from its rivals: $0.10 per million input tokens and $0.20 per million output tokens — roughly 12x and 21x cheaper than standard, respectively, with cached input at a near-free $0.002 — in exchange for explicit permission to use your prompts and completions to train future Meta models. It's the cheapest available on the market, but you pay with your data — as described below.

This is the tier Zuckerberg is steering new users toward: "It's easy and low-cost to get started," he wrote. "Install Muse Code with one line and you can start on our contributor tier."

In VentureBeat's own testing on a Mac mini, the one-line installer worked as advertised — a 97 MB download and a sign-in — but the agent stopped short of running anything, reporting that no models were visible and that payment was "required to finish setting up your account."

In other words, even the heavily discounted contributor tier requires a payment method on file before Muse Code will do any work: low-cost is accurate, but free is not.

Meta frames the contributor tier as lowering the barrier for prototyping and experimentation "where training on your data is acceptable."

But it also means the default on-ramp for Muse Code sends developers' code and prompts into Meta's training pipeline — a tradeoff enterprises with proprietary codebases will need to consciously opt out of by moving to standard pricing.

The contributor tier also carries much tighter rate limits (60 requests per minute versus 3,000), a clear signal it's aimed at individuals and small experiments rather than production workloads.

The approach is classically Meta: subsidize access, harvest data at scale, and use it to close the gap with the frontier. Zuckerberg made no secret of the ambition, calling Muse Spark 1.2 "our next step as we push toward frontier, with larger, more capable models on the way."

However, for developers and enterprises who want or are required legally to keep their code secure, the tradeoff may not be one they're willing or able to make.

No Llama in sight

What today's announcement conspicuously lacks is any mention of open source — a striking omission from the company that spent three years positioning itself as the standard-bearer of open AI.

From the original LLaMA's debut in February 2023 — whose weights famously leaked onto 4chan within weeks, inadvertently kickstarting the movement to run capable models on consumer hardware — through Llama 2's commercially usable license, the coding-specialized Code Llama, and the 405-billion-parameter Llama 3.1, which Zuckerberg launched in July 2024 with a manifesto titled "Open Source AI Is the Path Forward," Meta's entire pitch to developers was that frontier-class weights should be free to download, self-host, and fine-tune.

The strategy worked: by early 2026, the Llama family had been downloaded roughly 1.2 billion times, averaging about a million downloads a day, with self-hosting offering enterprises cost reductions VentureBeat has previously reported at as much as 88% versus proprietary API providers.

Then came the unraveling. Llama 4 debuted in April 2025 to mixed reviews and, eventually, admissions that its benchmark results had been fudged — while Chinese open-weight rivals from DeepSeek, Alibaba, and Zhipu AI surged to account for some 41% of downloads on Hugging Face by late 2025, eroding Llama's claim to leadership of the very movement it started. The rocky rollout spurred Zuckerberg's summer 2025 overhaul of Meta's AI operations into Meta Superintelligence Labs (MSL), with Scale AI co-founder Alexandr Wang recruited as chief AI officer.

The Llama era effectively ended this past April 8, when MSL shipped the original Muse Spark — "the most powerful model that meta has released," in Wang's words — as Meta's first proprietary model: cloud-only, with no downloadable weights and no self-hosting, initially confined to Meta's apps and a private API preview.

Asked directly at the time whether Llama development would continue, a Meta spokesperson told VentureBeat only that "our current Llama models will continue to be available as open source" — pointedly silent on future ones.

Wang, for his part, said bigger models were already in development "with plans to open-source future versions" — but four months on, today's release does nothing to advance that promise: no weights, no license, and neither the blog post nor Zuckerberg's thread so much as uses the word "open."

The reversal is all the sharper because Meta's rivals have been moving in the opposite direction. OpenAI released its Codex CLI as open source under the permissive, enterprise-friendly Apache 2.0 license and followed with its gpt-oss open-weight models; Google's Gemini CLI harness is likewise Apache-licensed.

With Muse Code, Meta lands closest to the posture of Anthropic — whose Claude Code remains proprietary — while the company that once argued open source was the path forward now asks developers to pay per token for a model they cannot inspect, or to subsidize that access with their own data.

Seen in that light, the contributor tier reads as the successor to the Llama strategy itself: the ecosystem flywheel is no longer free weights in exchange for mindshare, but cheap tokens in exchange for training data.

Why it matters

Terminal coding agents have become the fastest-growing surface in enterprise AI, and until today the category has effectively been a two-horse race between Anthropic and OpenAI, with Google and a crowd of startups in pursuit.

Meta's entry brings a genuinely different architecture (persistent background agents, an append-only local event log), a credible long-horizon demo, and an aggressive pricing wedge.

The open questions are the ones benchmarks charts can't answer: whether Muse Spark 1.2 actually matches Claude and GPT-class models on real-world repositories, whether developers trust Meta with their code, and whether the contributor tier's discount is enough to make them stop asking. Muse Code is available in beta today; Muse Spark 1.2 is live in the Meta Model API with expanded global access.

The post Meta AI Releases Muse Code (Beta): A Terminal Coding Agent Powered by the New Muse Spark 1.2 Model appeared first on MarkTechPost.

Apples erstes faltbares iPhone könnte den Markt für Falt-Smartphones massiv befeuern. Um glatt ein Fünftel könnten die Verkäufe im Vergleich zum Vorjahr anspringen. Dieser Anstieg ... Weiterlesen ...

Der Beitrag Durchbruch für Foldables: Apples iPhone Ultra dürfte Falter-Verkäufe pushen erschien zuerst auf Apfelpage.

Apple verspricht Nutzern der kostenpflichtigen Funktion iCloud Private Relay eine weitgehend anonymisierte Internetnutzung. Der Dienst, der Bestandteil von iCloud+ ist, soll unter anderem die eigen ... Weiterlesen ...

Der Beitrag Trügerischer Datenschutz: Verspricht Apples Private Relay zu viel Privatsphäre in Safari? erschien zuerst auf Apfelpage.

The post Apple’s Q3 iPhone sales crush expectations — and even better than they seem appeared first on MacDailyNews.

The post Apple’s CarPlay is coming to Crest and Balise pontoon boats appeared first on MacDailyNews.

The post Can new CEO John Ternus bring back Apple’s design mojo? appeared first on MacDailyNews.

Meta is entering the AI coding-agent race with Muse Code, a new terminal-based tool now available in beta for macOS and Linux.

Release 0.147.0-alpha.12

Core

Improvements

• Simplified xAI login to a single device-code flow that works better in headless and remote environments.

Bugfixes

• Preserved structured mid-stream provider errors so compatible providers can retry failed responses.
• Retried more transient provider and network errors instead of failing immediately.
• Counted cache writes in ACP usage totals.
• Logged remote workspace 5xx response bodies in the host logs to make proxy failures easier to debug. (@jamesmurdza)
• Stopped sending the host directory path to remote workspaces so prompts resolve from the remote project root. (@jamesmurdza)
• Waited for queued ACP session updates before ending a turn.

Thank you to 1 community contributor:

• @jamesmurdza:
  • fix(server): don't forward host directory to remote workspace (#40136)
  • fix(server): log upstream 5xx bodies from proxied workspace requests (#40135)

If you’ve ever simplified an interaction just to make a prototype manageable, you’ve probably felt the tension between what you designed and what the prototype could actually support. The risk is that when a design fails in usability testing, you can’t always tell why. Was the experience itself the problem, or was it really the prototype getting in the way: a missing connection, a laggy transition, a path you didn’t build?

I ran into this while working on Report Broken Site for Firefox Android, and it led me to a different way of prototyping: building directly inside the real app with AI (Claude), so the test reflects native fidelity rather than a simulation of it. That’s when I started worrying just about the design failing, and not the prototype.

Feature: Report Broken Site

Reaching limits of walled prototypes

In tools like Figma, prototyping requires anticipating every possible interaction and defining it explicitly. For the user to feel the true experience, each path needs to be connected, each transition set, and each variation accounted for. As complexity grows, it tends to increase the cost of maintaining it: screens multiply, connections become fragile, and animations become tedious to maintain.

At some point, you’re no longer designing the experience. You’re managing the prototype. 

E.g. Changing the animation for one node, requires updating it everywhere manually.

To cope, we simplify the prototype. We reduce the number of paths, guide users through predefined flows, and limit what they can do on the prototype. The result is what I’ve started thinking of as a walled prototype — like a walled garden: a bounded space where users can move, but only within the paths we’ve pre-defined.

Some designers might argue that Figma’s recent additions of variables and advanced logic solve this problem. However, even with these tools, the designer is still building and managing the prototype. Figma prototypes simulate a system; it is not the system itself or a part of it. These prototypes have been useful, but they have also shaped the participant testing experience in ways that haven’t always been obvious.

When the logic of a feature is handled by manual connections, the canvas quickly turns into spaghetti of fragile dependencies.

Prototypes shape participant behavior

This becomes especially noticeable in usability testing. Test participants tend to recognize when they are interacting with a prototype, and that awareness can change how they behave. They may hesitate to explore, follow the perceived intent of the task, or tap around when they get stuck.

For example, to keep a prototype manageable, I might only make a few issue types selectable. But then participants are doing two things at once: deciding what they want to do and guessing what the prototype will allow. Their feedback can become shaped by the prototype’s limits, not just the design —  like a visitor to the walled garden checking which paths are actually open to them.

That constraint can be useful in early concept testing, where a narrower path helps focus the conversation. It becomes more limiting when we are trying to understand how the full experience behaves.

Research and practice have long acknowledged that prototype fidelity and testing setup can influence participant behavior. But in practice, many workflows still rely on constrained, screen-to-screen simulations.

I’ve often wondered:

How a user’s perceived experience might change if they weren’t encountering the feature in the isolation of a walled prototype?

From walled to native fidelity prototypes

Designing and prototyping is often described in terms of fidelity — from low-fidelity sketches to high-fidelity designs ready for dev handoff. That framing focuses on how closely we represent the product, but not necessarily how the experience itself behaves.

As building realistic interactions becomes easier using AI, it may now be possible to move beyond simulating flows in Figma and towards observing how people actually behave. So, alongside designing it in Figma, I built the feature directly into a local version of the Firefox Android app using Claude. It wasn’t straightforward at first, but even the friction of getting it working revealed things I wouldn’t have seen in a Figma prototype.

When I did this, I noticed there were no predefined paths to manage or fragile connections to maintain. The experience felt more continuous, allowing users to move more freely, not just within the feature, but within the app itself. I started thinking of these as prototypes with native fidelity — native to the app, native to the device, and aligned with how users expect interactions to behave.

When prototypes need to handle dynamic behavior

The difference between the two types of prototypes is not just theoretical; it starts to change what the experience can support. In walled prototypes, content is often fixed, and interactions move users between predefined screens. While this works for simple flows, it becomes harder to represent how interfaces behave when content needs to update dynamically based on user interaction.

In the Report Broken Site feature, this was important. A walled prototype struggles with:

• Capturing website data: Depending on the browsing tab, metadata like the URL, screenshot, browser info, and tracking data needs to be captured and reflected back to the user.
• URL editing: Simulating real text entry, cursor movement, and auto-correct behavior.
• Branching logic: If a user selects “Site doesn’t load” as issue type, the details are optional, but if they choose “Something else,” details become required.
• Error handling: For “Something else,” the system must validate input length in the description box and show an error if it’s insufficient.

Have you ever run into interactions like these and found yourself simplifying them, just to make the prototype manageable?

When I built it directly using Claude, the native fidelity prototype was able to handle metadata capture, text input, and branching logic more naturally.

The native fidelity prototype inherits native behaviors like metadata capture, keyboard interactions, and dynamic state changes.

The environment is part of the experience

Another challenge is the environment in which the prototype is experienced. In walled prototypes, layouts are often fixed, and responsiveness is limited. Differences in device size, orientation, or performance can introduce inconsistencies that don’t reflect the intended final experience.

In practice, this can show up as:

• Oversized UI elements on larger devices as the prototype was created for an average phone size.
• Laggy interactions on slower networks as Figma prototypes fail to be responsive sometimes.
• Layouts that don’t adapt as expected because of the constraints of the prototyping environment.

When the interaction is built directly in the app, the experience inherits the native environment of the device. Layouts respond to screen size, interactions feel more consistent, and the overall experience is closer to what users would encounter in the final product. This could reduce the likelihood of testing interfaces being mistaken for design issues.

Tradeoffs and new realities

This approach introduces its own challenges. First time setup for a designer is complex, and navigating the codebase and working through unfamiliar tools takes effort.

Using Claude on the Firefox for Android codebase in Android Studio to build the prototype.

Adopting this approach requires a shift in the UX designer’s toolkit. It raises the barrier to entry by requiring baseline comfort with the terminal, build environments, and IDEs. But it also allows designers to move beyond “faking the experience” in Figma prototypes and start building directly in the app.

Building the prototype this way also changes how the work evolves. Instead of worrying about defining everything upfront, requirements tend to emerge through interaction —i.e. edge cases, missing states, and unclear behaviors as the experience is built. In Figma, many of these details are easy to overlook; when you create a prototype by building directly, they become easier to find.

Of course, this realism has its limits. While the experience feels like a continuous system rather than a sequence of steps, I haven’t yet connected it to a backend, pulled in APIs, or tested cross-device capabilities across mobile, tablet, and desktop. I’m still at the start of this exploration. What I want to understand next is how native fidelity prototypes change the testing environment itself: whether participants explore differently, whether failures are easier to interpret, and what new friction this approach introduces for designers and teams.

Start failing for the right reasons

To put it simply: if prototypes constrain user behavior, they may also shape the insights we get from usability testing.

For Report Broken Site, the value of the native prototype was not just that it handled more states. It gave me a more honest way to sit with the experience before putting it in front of participants. I could edit the URL, switch issue types, trigger validation, and move around the app as the feature would exist in context. Because this was a mobile experience, that context mattered: I could test it on a real device, with real navigation patterns, real input behavior, and the surrounding app experience intact. Those details helped me look past whether the prototype was working and focus more directly on whether the experience was working.

That is what I mean by letting the design fail for the right reasons: understanding whether an experience fails because of the design itself, not because of a missing screen-to-screen connection, bad transition, or laggy Figma prototype. The next step is to test whether this translates into different participant behavior and more useful usability insights.

Originally published on medium.com.

What's Changed

• Support Platform Filtering in ENABLE_FUZZ_FOR_BOTS Feature Flag by @javanlacerda in #5411
• [Metrics] Check provision model by consulting metadata by @PauloVLB in #5413

Full Changelog: 2.35.6...v2.36.0

The post Tom Cotton prods Treasury for tax code tweaks to modernize OT appeared first on CyberScoop.

The post Oracle SQL Injection Attack Enables Remote Code Execution  appeared first on eSecurity Planet.