Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
163609 stories
·
33 followers

Week in Review: Most popular stories on GeekWire for the week of Oct. 18, 2026

1 Share

Get caught up on the latest technology and startup news from the past week. Here are the most popular stories on GeekWire for the week of Oct. 18, 2026.

Sign up to receive these updates every Sunday in your inbox by subscribing to our GeekWire Weekly email newsletter.

Most popular stories on GeekWire

Read the whole story
alvinashcraft
1 hour ago
reply
Pennsylvania, USA
Share this story
Delete

r/opensource just banned AI, non-English speakers, and more

1 Share
An illustration of the Reddit logo.

The mods at r/opensource posted new submission rules that, among other things, banned projects that use AI. The post made Saturday evening opens by saying, "If your project uses AI, is made by AI, or is intended for AI, it's not welcome on r/opensource. AI, as it exists today, is incongruent to this Open Source community."

The new rules have set off a firestorm in the comments, and even spurred the creation of a rival sub r/trueopensource. Moderator Wolvereness has waded into the comments to explain that there's nuance and room for selective enforcement, such as "software that incidentally has accessibility features that use AI," including …

Read the full story at The Verge.

Read the whole story
alvinashcraft
1 hour ago
reply
Pennsylvania, USA
Share this story
Delete

Is Kubernetes ready for AI agents?

1 Share
High-contrast abstract black cables straining under tension, representing the strain of agentic workloads on cloud infrastructure.

Kubernetes was built around a fairly simple assumption.

It’s that software does what its developers told it to do. AI Agents complicate that assumption. An agent can reason about a problem, choose a course of action, call tools, write code, interact with other systems, and keep working toward a goal. That is precisely what makes agents useful. But it is also what makes running them in production different from running a conventional application.

And increasingly, enterprises want to run them on Kubernetes. A recent survey by the Cloud Native Computing Foundation (CNCF) found that two-thirds of organizations running AI inference workloads run them on Kubernetes. This makes sense, as Kubernetes has become the standard way enterprises deploy and operate distributed applications over the past decade. It already knows how to schedule workloads, allocate resources, recover from failures, and scale applications up and down.  


KubeCon + CloudNativeCon is taking place in Salt Lake City from November 9 to 12. Register now!


Inference demand can arrive in bursts, requiring customers to rapidly scale up underlying hardware and software resources to meet surging demand. In that regard, Kubernetes is an excellent fit. Similarly, as AI workloads wind down, Kubernetes can gracefully scale down the underlying infrastructure, ensuring economical operation.

As good as the fit between AI inference and Kubernetes is, the combination still has gaps, starting with security. Recent incidents at frontier AI labs, in which AI agents escaped test environments and launched malicious cyberattacks across the internet, highlight the need for strong guardrails to keep AI workloads from misbehaving. 

Unfortunately, the probabilistic nature of AI leads to situations where it’s impossible to predict exactly what resources an AI workload will seek to use, which increases the likelihood that agents will eventually cross the line. Therefore, the ideal AI platform should make it easy to enforce clear guardrails and keep agentic workloads safely contained within well-defined sandboxes.

“The ideal AI platform should make it easy to enforce clear guardrails and keep agentic workloads safely contained within well-defined sandboxes.”

By confining agentic AI workloads to a sandbox logically separate from other Kubernetes workloads, an enterprise can better ensure that if an AI workload does run off the rails, the ensuing damage stays within that sandbox.

Instead of letting agents access whatever resources they want, agentic platforms should use an explicit permissioning framework that grants or denies access to files, tools, and network and system resources. Agents should be fully restricted from executing code unless they have been given explicit permission.

The good news is that the Kubernetes community is moving toward adopting sandboxing as an architectural element for constraining AI agents. The CNCF is working to address Kubernetes’s security and isolation gaps. However, the open-source project’s functionality is not yet fully there.

Proper AI sandboxing requires looking beyond the container and into virtual machines or the host operating system to ensure agentic workloads can’t affect other applications running in the same environment. Enterprises looking to deploy AI into production today can turn to commercial Kubernetes distributions that already include these sandboxing capabilities.

Monitoring of AI workloads is another concern that keeps CIOs up at night. While frontier AI labs may not have adequately monitored what their AI models were doing, or even whether they had internet access, enterprises generally don’t have the luxury of asking for forgiveness when their agents misbehave.

Security may be the most obvious challenge, but it is not the only one. Agents are also changing how compute is consumed. A normal service might run continuously for months, while an agent may exist for only seconds. 

“A normal service might run continuously for months, while an agent may exist for only seconds.”

A user asks a question -> an agent starts -> it performs some work, possibly creates other agents, calls several tools, and then disappears. 

Now multiply that pattern across thousands of users and the infrastructure begins to look very different from a conventional Kubernetes environment.

On top of that, starting a Kubernetes workload from scratch can take seconds. For many applications, that is perfectly acceptable. But for an interactive agent, those seconds can feel painfully slow. That creates an interesting infrastructure problem: How do you get the isolation of a fresh environment without paying the startup cost of creating one every time?

Hence, the sporadic nature of agentic workloads, and the need for agents to spin up rapidly, is testing even Kubernetes’ flexibility. Just as first-generation Kubernetes didn’t support stateful applications, the community is still searching for the best abstraction layer for running the new generation of agentic workloads. 

“Agents stay in a state of suspended animation in a warm pool, allowing them to reanimate in milliseconds rather than the seconds it would take to fully wake from deep sleep.”

One answer that is gaining attention in the community is an agent substrate for rapidly scaling Kubernetes-based agentic workloads. With agent substrate, Kubernetes pods containing AI agents aren’t fully spun down when they’re not needed, because spinning them up from a sleep state would introduce too much latency from the user’s point of view.  Instead, agents stay in a state of suspended animation in a warm pool, allowing them to reanimate in milliseconds rather than the seconds it would take to fully wake from deep sleep.

When deploying AI workloads at scale in the real world, the details matter. Not every Kubernetes distribution provides the full raft of capabilities that enterprises demand. As the open-source Kubernetes community adapts to changing requirements, forward-looking platform providers are building the guardrails, sandboxing, monitoring, and agentic substrate that will let enterprise deploy AI now.

The post Is Kubernetes ready for AI agents? appeared first on The New Stack.

Read the whole story
alvinashcraft
1 hour ago
reply
Pennsylvania, USA
Share this story
Delete

Tray-tober Day 25: Tiny ATC (air traffic control)

1 Share

If you live near a city it is basically a guarantee you hear planes flying over. As a nerd I’m always curious where they are coming from. I’ll frequently pull up flight radar on my phone and do a quick check. Now I don’t have to because I have a tiny air traffic control app in my system tray!

Tiny ATC shows a live map of planes flying over. You can even set the tray icon to scroll with info about the flights like call sign and speed! The data is currently coming from OpenSky Network because they have a great daily free quota which works well for a small app like this. The maps again are using WinUIEx.Maps.

As I’ve mentioned this app to a few people they wondered about a similar app for marine traffic, which would totally be possible! There are so many small interesting ideas for a utility app on Windows and now it is easier than ever to reachout and make it.


Happy Tray-tober!

Joe

Read the whole story
alvinashcraft
1 hour ago
reply
Pennsylvania, USA
Share this story
Delete

Lessons Learned #562: Measuring the Work Behind Statistics Updates in Azure SQL Database

1 Share

A few extra milliseconds during a stress test

While working on a support case, our customer was running stress tests against an Azure SQL Database. They noticed a small but interesting variation: occasionally, a query took a few milliseconds longer and appeared to use slightly more CPU. They wanted to understand what was happening during those executions.

The difference was small, but the question was useful. What additional work was being performed during those periods, and could we measure it?

While reviewing Query Store, I came across queries containing a familiar pattern: SELECT StatMan(...). They reminded me of an article I had written some time ago, Lesson Learned #498: Understanding the Role of STATMAN in SQL Server and Its Resource Consumption, about the internal work involved in statistics updates. Recognizing that pattern gave me a starting point: I could use the execution statistics recorded in Query Store to investigate how much time, CPU, and I/O those statements had consumed during the stress test

I would like to share what I found and the query I used to inspect that work. It provides a way to measure the duration, CPU, and reads attributed to recorded StatMan executions, and then compare their activity with the period being investigated.

Finding that statistics calculation consumed resources is one part of the investigation. Establishing how much it contributed to the customer's extra milliseconds requires correlating those records with the affected workload. The sections below explain both what we can measure and how to interpret it.

Looking beyond the last update time

sys.dm_db_stats_properties provides the last update time and sampling information, but does not preserve the duration or resource consumption of the update. The workload query plan identifies statistics loaded during compilation through OptimizerStatsUsage, but does not provide a separate runtime measurement for each statistics calculation.

Because Query Store already contained these internal statements in our test, we could inspect their historical resource consumption without configuring a new Extended Events session.

Finding StatMan in Query Store

StatMan is used internally during statistics calculation. Its query text can include the table and columns being processed and an alias such as _MS_UPDSTATS_TBL. We are inspecting recorded engine-generated statements, not invoking StatMan directly.

The following read-only query was tested successfully in our Azure SQL Database. Run it in the database being investigated and adjust the UTC dates. It returns statistics by query, plan, interval, and execution type. Query Store must already contain the relevant statements and runtime data.

Query Store inspection query

DECLARE @FromUtc datetimeoffset = '2026-10-20T00:00:00+00:00'; DECLARE @ToUtc datetimeoffset = '2026-10-26T00:00:00+00:00'; ;WITH RuntimeStats AS ( SELECT rs.plan_id, rs.runtime_stats_interval_id, rs.execution_type_desc, MIN(rs.first_execution_time) AS first_execution_end_utc, MAX(rs.last_execution_time) AS last_execution_end_utc, SUM(rs.count_executions) AS executions, SUM(rs.avg_duration * rs.count_executions) AS total_duration_us, MAX(rs.max_duration) AS max_duration_us, SUM(rs.avg_cpu_time * rs.count_executions) AS total_cpu_us, SUM(rs.avg_logical_io_reads * rs.count_executions) AS total_logical_reads, SUM(rs.avg_physical_io_reads * rs.count_executions) AS total_physical_reads FROM sys.query_store_runtime_stats AS rs JOIN sys.query_store_runtime_stats_interval AS i ON i.runtime_stats_interval_id = rs.runtime_stats_interval_id WHERE i.start_time < @ToUtc AND i.end_time > @FromUtc GROUP BY rs.plan_id, rs.runtime_stats_interval_id, rs.execution_type_desc ) SELECT q.query_id, p.plan_id, q.is_internal_query, i.start_time AS interval_start_utc, i.end_time AS interval_end_utc, r.execution_type_desc, r.first_execution_end_utc, r.last_execution_end_utc, r.executions, r.total_duration_us / NULLIF(r.executions, 0) / 1000.0 AS avg_duration_ms, r.max_duration_us / 1000.0 AS max_duration_ms, r.total_duration_us / 1000000.0 AS total_duration_seconds, r.total_cpu_us / 1000000.0 AS total_cpu_seconds, r.total_logical_reads, r.total_physical_reads, qt.query_sql_text FROM RuntimeStats AS r JOIN sys.query_store_plan AS p ON p.plan_id = r.plan_id JOIN sys.query_store_query AS q ON q.query_id = p.query_id JOIN sys.query_store_query_text AS qt ON qt.query_text_id = q.query_text_id JOIN sys.query_store_runtime_stats_interval AS i ON i.runtime_stats_interval_id = r.runtime_stats_interval_id WHERE qt.query_sql_text LIKE N'%StatMan%' AND qt.query_sql_text NOT LIKE N'%query_store%' ORDER BY total_duration_seconds DESC;

Reading the results

Start by checking query_sql_text to confirm that a returned row is an actual SELECT StatMan(...) statement. The text filter is a search aid, not a definitive classification. The second predicate excludes common diagnostic queries that reference Query Store while searching for StatMan.

  • executions shows the number of recorded executions for that plan, interval, and execution type.
  • avg_duration_ms is the execution-count-weighted average duration. max_duration_ms identifies the slowest recorded execution within the group.
  • total_duration_seconds and total_cpu_seconds estimate accumulated execution duration and CPU from the recorded averages multiplied by execution counts.
  • total_logical_reads and total_physical_reads estimate accumulated page reads from the recorded averages. Query Store reports these reads as counts of 8 KB pages.
  • is_internal_query identifies whether Query Store marks the query as internally generated. Inspect execution_type_desc to distinguish regular, aborted, and exception executions.

Query Store reports runtime duration and CPU in microseconds. The query converts them to milliseconds or seconds as indicated by the output names. Its grouping also accounts for multiple runtime-statistics rows that can exist for the active interval.

Interpreting the time window

The date filter selects intervals that overlap the requested window. Those intervals are included in full, including executions outside the precise requested boundaries. Use interval boundaries aligned with your investigation when possible. first_execution_end_utc and last_execution_end_utc identify execution completion times, not start times.

Query Store aggregates executions. When executions is greater than one, a row does not describe one individual update. Summed durations are not an end-to-end wall-clock measurement, especially when operations overlap. CPU can also exceed elapsed time when execution is parallel.

From recorded consumption to workload impact

The results quantify the recorded work attributed to StatMan. A high total can justify investigating its contribution to CPU or I/O during the same period, but does not by itself prove that it caused application latency or blocking. Correlate those observations with workload performance and resource metrics.

The StatMan statement need not include every phase of the surrounding statistics update. Its text alone does not establish whether the update was automatic or explicitly requested. 

If the query returns no rows, it does not prove that statistics were not updated. The relevant statements may not have been captured or retained, or their runtime data may not be available in the selected window.

Extended Events as an alternative

We also observed StatMan through sp_statement_completed in a database-scoped Extended Events session during testing. Extended Events can provide individual statement observations when a suitable capture is available. 

Lessons learned

When StatMan is present in Query Store, we can examine historical duration, CPU, and reads for the statistics-calculation statements already recorded. This provides a practical starting point for understanding their resource consumption while preserving the distinction between internal statement cost, the full statistics update, and impact on the workload.

References

Read the whole story
alvinashcraft
1 hour ago
reply
Pennsylvania, USA
Share this story
Delete

Mac Power Users 872: The Mighty Mac mini

1 Share

Sparky swapped his Mac Studio for an M6 Mac mini, and he breaks down everything a Mac mini can do as an always-on home server: backups, automations, app hosting, Plex, Docker, and more!

This episode of Mac Power Users is sponsored by:

  • Squarespace: Save 10% off your first purchase of a website or domain using code MPU.
  • Workbrew: Deliver the software your team needs securely and at scale.
  • 1Password: Never forget a password again.

Links and Show Notes:

Sign up for the MPU email newsletter and join the MPU forums. You can watch the podcast over on YouTube.

Credits

The Mac Power Users
Stephen Robles
David Sparks

The Editor
Jim Metzendorf

The Fixer
Kerry Provanzano

More Power Users: Ad-free episodes with regular bonus segments
Submit Feedback
Some iPhone Duo orders getting moved up to earlier dates
Crackling/distorted sound from MacBook Pro
Apple's October 28 'Pro and Tell' Launch: What's Coming
Stephen's iPhone Duo First Look
iPhone Duo Day 2: IRL
Parachute Backup
Orion — HDMI Monitor for iPad
Guermok Video Capture Card
A launchd Tutorial
Transcriber
Instinct
Plex Pass
MakeMKV
HandBrake
LM Studio
Mac mini M6, 32GB, 1TB
Apple and Meta team up to run Meta’s Muse Spark Open model on Macs
Docker Desktop
HomeBox
Paperless-ngx
Audiobookshelf
changedetection.io
Mealie
Uptime Kuma
Stirling-PDF
Karakeep
Calibre-Web
Aqara Camera Hub G5 Pro PoE
Airversa QliQ AC1 HomeKit Button Controller
Raspberry Pi 5




Download audio: https://www.podtrac.com/pts/redirect.mp3/mgln.ai/e/613/clrtpod.com/m/pscrb.fm/rss/p/traffic.libsyn.com/relaympu/mpu872.mp3
Read the whole story
alvinashcraft
1 hour ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories