|
Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
|
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 Sept. 20, 2026.
Sign up to receive these updates every Sunday in your inbox by subscribing to our GeekWire Weekly email newsletter.
Amazon says it has cut off Meta’s new Muse personal AI agent from shopping on Amazon.com, citing data security and other concerns. It’s part of a larger industry fight over who controls the shopping experience and customer relationship in agentic commerce. Read More … Read More
Microsoft is moving communications out of its marketing group and under Vice Chair and President Brad Smith, as CEO Satya Nadella calls for a fundamentally new approach that makes employees a bigger part of how the company tells its story. Read More … Read More
The cuts total about 600 globally, including about 300 in Washington state, and 268 worldwide in Xbox Game Studios. The restructuring folds some existing studios under Activision, Bethesda and King, and leaves Ninja Theory, the studio behind the Hellblade series, facing a potential closure. Read More … Read More
Former Seattle City Council President Sara Nelson has launched CivicTide, a website that tracks City Council legislation, publishes policy briefs and opinion pieces, and gives readers tools to contact councilmembers. The site runs on a custom AI-powered system built by Seattle tech communications executive Viet Nguyen. Read More … Read More
Microsoft’s revamped Copilot app adds AI coding, always-on agents and full versions of Word, Excel and PowerPoint as the company competes with OpenAI and Anthropic and shifts more of its AI pricing to usage-based billing. Read More … Read More
Impacted positions span across technology, product, and corporate roles — including data scientists, software engineers, finance managers, and senior leadership. Read More … Read More
Amazon announced new AI tools for its independent sellers, led by a plugin that lets them run their Amazon businesses from Anthropic’s Claude or Amazon’s own Quick assistant. Read More … Read More
Bungie, the Bellevue-Wash.-based video game studio behind Destiny and Marathon, began its week with an apology from its new studio head, as it tries to win back its audience after several recent missteps. Read More … Read More
Shankar Sundaram, a former Boeing engineer and enterprise sales leader, said the ultimate goal of East West Club is to create a “third place” in the city that’s centered around genuine connection rather than corporate networking or status. Read More … Read More
Mayor Katie Wilson’s proposed budget closes a $175 million deficit through spending cuts and leaves the JumpStart payroll tax untouched, offering big tech employers a period of tax stability. Read More … Read More
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Microsoft’s September 25 announcement introduces Home, Code and Autopilot alongside a clearer commercial distinction between everyday Copilot use and usage-based agentic work.
There is plenty to get excited about. But what caught my attention is not only what Copilot can do next. It is what organizations will need to do differently.
My reading is that Microsoft is building an AI operating model—and an AI economy—inside Microsoft 365.
This is bigger than adopting another tool. It connects delegation, solution creation, autonomous work, governance and spending. And it raises a practical challenge: helping people create meaningful business value with the right AI capability, at the right cost, under the right governance model.
Let’s take a closer look.
Home brings together Chat and Cowork, with Word, Excel and PowerPoint experiences integrated through Office in Copilot. Microsoft describes a future where people state what they want to accomplish and Copilot routes the work to Chat, Cowork or Code, rather than requiring them to select the mode themselves.
That is a significant direction: less focus on operating the interface, more focus on describing the outcome.
Cowork makes this shift particularly clear. Microsoft positions it around delegated, end-to-end work, including complex deliverables such as RFP responses and financial close packages.
This is not simply bigger chat.
When I delegate work, the important questions become what I want completed, which context matters, what boundaries apply and how I will judge the result. Better prompting helps, but a good prompt is not the same as a well-defined assignment.
That distinction should become part of how we teach people to work with AI.
Cowork has already changed how I am able to work. Using Cowork and Copilot Chat on my mobile phone, I can draft, generate content and keep refining it when opening a laptop is not an option. Like preparing this blog post, planning the next work webinar, creating customer workshop materials, and the list goes on.
That might be on public transportation, sitting in a café or at home in the living room with my family. Bringing a laptop to the table with “I’ll just do some work while we’re having family night” does not really work. And yes, I should probably put the phone away as well. Touché. 
The change is not just about the device. I can move work forward through conversation: describe what I need, review what comes back and steer the next iteration.
What excites me about Code and Autopilot is the possibility of extending that pattern—creating applications by chatting with Copilot, refining what I want an agent to do and reviewing its outcomes. That is the working pattern I want to build toward as these capabilities become available.
And perhaps the most useful outcome should be knowing when the work is handled—and putting the phone away.
Microsoft describes Code as a way to create apps, dashboards, trackers, automations and workflows through natural language, extending solution-building beyond professional developers.
The important story is not that developers can build software. It is that business users, subject-matter experts and knowledge workers can increasingly turn their understanding of a problem into a working solution.
I see Code as extending that direction into the everyday Copilot experience. Compared with learning a visual builder or expression language, describing the desired outcome can lower the starting barrier further.
But easy to create must not become easy to abandon.
A useful team application still needs an owner, tested behavior, appropriate data permissions and a maintenance decision. A convincing first demonstration is not automatically a dependable business solution.
This is why Copilot Managed Runtime matters. Microsoft describes it as IT-governed hosting within the organization’s Microsoft 365 environment, supporting applications created through Cowork, Code and Copilot Studio; it is currently in preview.
Microsoft’s public documentation on Copilot Managed Runtime default governance settings describes controls for connectivity, sharing and runtime behavior alongside existing Power Platform governance.
For me, this is an enterprise-readiness discussion, not merely a hosting detail. Generating an application and operating it responsibly are different responsibilities.
My recommendation is to involve administrators, security teams and business owners early. Give experimentation a defined scope and a clear route from useful prototype to supported solution.
Autopilot, previously known as Microsoft Scout, is Microsoft’s proactive, cloud-hosted agent for persistent work, including following up on threads, running recurring tasks and resuming projects beyond an individual interaction.
The important shift is that work can continue after the person stops interacting with it.
I find the digital-teammate framing useful, provided we do not confuse delegated execution with transferred accountability.
For persistent agentic work, I would want a business owner, a bounded objective, escalation rules, a review schedule and a clear way to stop execution.
This also connects directly to FinOps. When work continues beyond a conversation, organizations need to understand what they are funding and why.
Just because an agent keeps working does not mean the work is still needed or worth the cost.
An agent’s purpose should be reviewed alongside its quality, permissions and cost. Continuing to run is not, by itself, evidence that the work remains valuable.
In the Managing AI spend section of its announcement, Microsoft distinguishes between User Subscription License (USL) and Usage-Based Billing (UBB).
For everyday AI, the USL provides a fixed subscription cost covering Chat, Copilot experiences across Microsoft 365 applications, model selection and Auto model routing; Auto weighs accuracy, speed and cost when selecting a model.
Microsoft places Cowork, Code, Autopilot, long-running agentic capabilities and frontier models such as Astra and Fable under UBB. I would not frame this simply as “the interesting things cost extra.”
Someone pays for computation. If the customer is not charged separately for an operation, its cost still exists within the provider’s economics.
My view is that indefinitely expanding agentic work cannot sustainably be treated as computation without an economic consequence. Organizations should not base their strategy on that assumption. This is an economic argument, not a claim about Microsoft’s margins or unpublished pricing.
Equally, usage-based billing does not automatically mean poor value.
A demanding task can justify higher consumption if it produces a valuable, accepted result. A cheap task repeated unnecessarily can still waste money.
The useful business conversation connects the outcome, the required quality, the total cost of producing and reviewing it, and the value actually realized.
We should optimize for valuable work—not simply the lowest consumption or the most powerful model.
The title of Microsoft’s companion announcement—New FinOps for AI capabilities: Control spend, measure value, and optimize for impact—captures the connection between financial control and business value.
I see this as a business capability, not a dashboard finance checks after IT has enabled everything.
The main Copilot announcement describes spending-policy management through APIs, credit requests routed into approval workflows and model-family controls for different user groups, including constraints on Auto’s choices.
It also describes cost-management expansion to Code and Copilot Managed Runtime, visibility into Cowork task outcomes, and users’ ability to see credit usage, remaining balances and usage history.
These are useful foundations. They are not, by themselves, proof of ROI.
A completed task is not necessarily useful work. Time saved does not automatically become financial savings. Someone still needs to establish a baseline, assess the result and decide what the organization gained.
For a pilot, I would examine accepted outputs, turnaround time, review effort, rework and consumption together. For an application, I would include maintenance and support. For autonomous work, I would also check whether the process still needs to run.
FinOps should help organizations spend confidently on valuable work—not merely spend less.
That becomes increasingly important when AI is creating applications, executing longer assignments and operating beyond individual interactions.
If an adoption program mainly teaches people to start using AI and write better prompts, I would now broaden it.
Prompting remains useful. It is simply not sufficient.
The next layer of AI literacy should include:
A quick answer may not require the most advanced model. A reusable business dashboard may justify evaluating Code. A recurring process with clear boundaries may justify evaluating Autopilot when it becomes available.
These are judgment exercises, not automatic product-selection rules.
Even when Copilot handles more routing, people still need to decide whether work should be delegated and whether the result is acceptable.
My practical recommendation is to select a few meaningful outcomes, give each an owner and baseline, agree on spending and review boundaries, and scale what demonstrates value. Connect IT, finance, business owners and adoption champions rather than treating each as a separate workstream.
And do not turn cost awareness into anxiety. Give people understandable limits, room to learn and a straightforward way to request more capacity.
Microsoft’s published rollout expectations, as of writing this article on September 27, 2026, are:
Code is also planned to enter preview for Microsoft 365 Premium and Pro subscribers later in 2026. These are consumer subscriptions, not Microsoft 365 enterprise licenses, as reflected in Microsoft’s guidance on AI credits and limits for Microsoft 365 subscriptions.
I am excited about this direction. But I would not use this moment simply to add more features to a Copilot training deck. I would use it to reconsider what successful AI adoption means.
Home, Code and Autopilot are important. FinOps may prove even more important because it connects that ambition to a sustainable way of operating.
The defining challenge of the next phase is not merely getting people to use AI. It is helping them delegate responsibly, create dependable solutions and recognize which work is worth doing.
The future of work is not a maximum AI consumption nor a heavily constrained one. It is meaningful business value, created with the right AI capability, at the right cost, under the right governance model.
That is the conversation I want us to have next.
Build software on Windows using the Linux environments and tools you already rely on. In this video, see how to connect the GitHub Copilot app to Windows Subsystem for Linux (WSL) and run coding agents directly inside Ubuntu. Watch how Copilot handles parallel feature requests using worktrees, previews changes in a built-in browser, and verifies code diffs, all without leaving the app. Download the GitHub Copilot app at https://gh.io/app to get started.
— RESOURCES—
Agent automation controls in GitHub Issues: https://github.blog/changelog/2026-07-23-agent-automation-controls-in-github-issues-in-public-preview/
Creating GitHub Agentic Workflows: https://docs.github.com/en/copilot/how-tos/github-agentic-workflows/creating-github-agentic-workflows
#GitHubCopilot #Linux #WSL
— CHAPTERS —
00:00 Linux development on Windows
00:25 Connect WSL to the GitHub Copilot app
02:22 Add features with coding agents
03:35 Preview, test, and review changes
Stay up-to-date on all things GitHub by connecting with us:
YouTube: https://gh.io/subgithub
Blog: https://github.blog
X: https://twitter.com/github
LinkedIn: https://linkedin.com/company/github
Insider newsletter: https://resources.github.com/newsletter/
Instagram: https://www.instagram.com/github
TikTok: https://www.tiktok.com/@github
About GitHub
It’s where over 180 million developers create, share, and ship the best code possible. It’s a place for anyone, from anywhere, to build anything—it’s where the world builds software. https://github.com
Molly Graham is back for round two, and this one is even more powerful. Molly has spent more than 20 years helping organizations and the humans inside them navigate growth and change. She’s held leadership roles at Google, Facebook, Quip, and the Chan Zuckerberg Initiative and is the host of TED’s WorkLife podcast (which she took over from Adam Grant). She also runs Glue Club, a leadership community for senior operators, and writes a popular newsletter called Lessons.
In our in-depth conversation, we discuss:
1. Why Molly’s famous “give away your Legos” career advice no longer holds true in an AI world
2. The grief, loneliness, and burnout sweeping through the tech industry right now
3. Why delegating to AI is fundamentally different from delegating to a human
4. The fear narrative around AI job displacement, and why it’s overblown
5. Which Legos you should never give to AI
6. What the best managers are doing right now
—
Brought to you by:
WorkOS—Make your app enterprise-ready, with SSO, SCIM, RBAC, and more
DX—Engineering intelligence for the AI era
—
Episode transcript: https://www.lennysnewsletter.com/p/the-grief-loneliness-and-burnout
Archive of all Lenny's Podcast transcripts: https://www.dropbox.com/scl/fo/yxi4s2w998p1gvtpu4193/AMdNPR8AOw0lMklwtnC0TrQ?rlkey=j06x0nipoti519e0xgm23zsn9&st=ahz0fj11&dl=0
Highlights: https://lennyspodcast.com/mostreplayedmoments
—
Where to find Molly Graham
• LinkedIn: https://www.linkedin.com/in/mograham
• Substack: https://mollyg.substack.com
• Website: https://glueclub.com
—
Where to find Lenny:
• Newsletter: https://www.lennysnewsletter.com
• X: https://twitter.com/lennysan
• LinkedIn: https://www.linkedin.com/in/lennyrachitsky/
—
In this episode, we cover:
(00:00) Molly Graham returns
(03:34) What is “Give away your Legos”?
(05:44) The origin story: Google, Facebook, and rapid scale
(11:27) What still holds true in an AI world
(18:13) Engineering’s identity shift: from rowing to steering
(22:09) Loneliness and the collapse of team structure
(24:06) The centaur and the reverse centaur
(25:36) The fear narrative: AI-branded layoffs and overblown doom
(29:20) Survey data: burnout is up to 55%, but half of people are thriving
(35:07) Cleaning up AI slop
(40:01) What’s actually different: delegating to AI vs. giving Legos to a human
(42:02) Why every worker is now a manager, whether they want to be or not
(49:07) Why giving things away creates space for new opportunities
(55:27) Advice for people in the age of AI
(59:38) What Legos you should never give away
(01:03:12) The human sandwich: vision at the top, AI in the middle, humans at the end
(01:05:00) Holding on to the things you love: grief, funerals, and what comes next
(01:09:39) Slow takeoff: why you’re not too late
(01:13:32) The most important skill to build right now
(01:18:58) A message for managers and leaders
(01:24:17) Key takeaways
(01:31:42) Final thoughts
—
References: https://www.lennysnewsletter.com/p/the-grief-loneliness-and-burnout
—
Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.
—
Lenny may be an investor in the companies discussed.
Run a full Microsoft Agent Framework (MAF) agent entirely on-device to eliminate round trips to the cloud, reduce latency, avoid egress costs, and keep sensitive data private. With Foundry Local you can run optimized local model variants (ONNX/WinML) and wire them directly into MAF.
In this guide you’ll get a working quickstart (Windows .NET 7 + WinML and a cross-platform Python example), exact commands to install and download a model, copy‑and‑paste code, hardware/driver tips, observability and troubleshooting checks, CI/CD advice, and production‑ready recommendations.
What you’ll accomplish
Quick overview (high-level steps)
Prerequisites
Quickstart (10–15 commands)
This is a condensed path from zero to a running agent (Windows example for .NET then Python). If you prefer a single OS, follow that section below in full.
Windows (.NET 7 + WinML quick path)
Cross-platform Python quick path
Important note: package and CLI names evolve. If a command fails, consult the Foundry Local docs and the official sample repos (foundry-samples and agent-framework) which contain tested examples and exact package/namespace names.
Part A — Install Foundry Local and download a model (details)
Where to get the right installer/packages
If your platform’s docs show a different CLI name, use that. The initial model download can be large; download location and cache are configurable in the runtime docs.
Part B — Copy‑paste ready C# example (Windows .NET 7 + WinML)
Important: package names and API surfaces can change between SDK releases. The commands below use package names commonly seen in the Microsoft samples. If NuGet packages change, run the dotnet add package commands without versions to get the latest packages, and refer to the foundry-samples repo for exact Program.cs if you encounter API differences.
using System;
using System.Threading.Tasks;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry;
class Program
{
static async Task Main(string[] args)
{
// Read model alias from environment or use a default
var modelAlias = Environment.GetEnvironmentVariable(“FOUNDRY_LOCAL_MODEL”) ?? “phi-4-mini”;
Log in
Console.WriteLine($"Using Foundry local model: {modelAlias}");
// Create a FoundryLocalClient (provider glue). Exact constructor may vary by SDK version.
var foundryClient = new FoundryLocalClient(model: modelAlias);
// Create agent wrapper using a ChatClientAgent helper (example API)
var agentOptions = new ChatClientAgentOptions
{
SystemPrompt = "You are a helpful assistant that summarizes text concisely."
};
var agent = ChatClientAgent.FromChatClient(foundryClient, agentOptions);
var input = "Summarize the plan for the project in one sentence.";
Console.WriteLine($"Sending prompt: {input}");
var result = await agent.RunAsync(input);
Console.WriteLine("Agent response:");
Console.WriteLine(result);
}
}
Notes
Part C — Copy‑paste ready Python example (cross-platform)
If PyPI names differ or packages aren’t present, clone the sample repo and install from source.
from agent_framework import Agent
from agent_framework.foundry import FoundryLocalClient
async def main():
model_alias = os.environ.get(“FOUNDRY_LOCAL_MODEL”, “phi-4-mini”)
print(f”Using Foundry local model: {model_alias}”)
# Create Foundry client (constructor may vary)
client = FoundryLocalClient(model=model_alias)
# Create a simple agent wrapper — adjust arguments to match the library you installed
agent = Agent(chat_client=client, instructions="You are a brief assistant that summarizes text.")
response = await agent.run("Explain Docker in one sentence.")
print("Agent response:", response)if name == “main“:
asyncio.run(main())
Notes
Part D — Configure Foundry Local without env var (programmatic control)
Instead of environment variables, pass the model alias when you create the client:
This is useful for runtime selection, multi-agent scenarios, or when you want config inside your app.
Hardware, drivers and model sizing (practical guidance)
What to look for in the Foundry catalog
Observability and logging
Troubleshooting checklist (concrete remedies)
Forensics & logs: where to look
CI/CD and production considerations
Security and licensing checklist
Performance tuning tips
Appendix: Useful command snippets (summary)
Set env var
Dotnet project (example)
Python virtualenv
Foundry CLI (example patterns — CLI name may vary)
Where to get canonical examples
Foundry Local + MAF gives you an approachable path to local agents that respect privacy and latency constraints. The main friction is model selection and the first-time download/optimization. Start with the official sample repos (foundry-samples and agent-framework) for exact API versions, try a small model (phi-4-mini) for initial experiments, and iterate to larger/quantized models as your hardware allows
Note: The initial draft of this post was written by BlogWriter and then edited by Jesse Liberty
Illustrations by Copilot. Caution: LLMs make mistakes; this post is offered as is.