You can now play Fortnite natively on Windows on Arm64-based chips, such as the Snapdragon X Plus and X Elite or the upcoming X Elite 2.

Back in August, Epic announced that the “EOS” (Epic Online Services) SDK would be updated to include ARM64 support on Windows clients, meaning the kernel-level anti-cheat software they use, called Easy Anti-Cheat, would now work on ARM64 clients.

However, at the time, it was not included in Fortnite, which meant the game would still not launch correctly on the platform. Meanwhile, other games like VRChat would go on to implement the new SDK and allow their respective titles to work on Windows 11 ARM.

Fast forward to November 1st with the latest Fortnite update to version 38.00. As first spotted by Windows Latest, an undocumented change in this release updated the EOS SDK version with the new Easy Anti-Cheat client that runs on ARM devices.

This change means that Fortnite will now run on Windows 11 ARM devices, which include any of the Snapdragon X Series chips in laptops.

I played Fortnite on my Arm PC with 60FPS

I decided to give this a try to see how it ran, and I was pretty surprised.

At default “performance” settings with v-sync enabled, I saw a locked 60FPS with minimal hitching, however I did experience some random lag here and there from texture streaming in the first couple of matches I played.

While Qualcomm has stated many times that the Snapdragon X platform is not geared towards gaming, it’s nice to see developers enable them to run on this hardware, if not for the simple fact that this makes these devices much more versatile.

So while you can enjoy day(s) long battery life for productivity, you can enjoy some light gaming on the same device.

With a large player like Epic moving its anti-cheat system to ARM, I’m hoping others follow (like Riot Games and its Vanguard system).

Windows on Arm’s Prism emulator now supports more 64-bit apps

Fortnite support on Arm64 is not the only big news this week.

Microsoft also confirmed that Prism, which is Windows on Arm’s emulator, now supports new CPU features. This means more 64-bit x86 apps can now use emulation, and run at a better performance. After the update, you will notice that all (x64) apps that use emulation will automatically rely on new CPU features when required.

Windows Latest previously spotted that the October 2025 Update (KB5066835) upgrades Prism emulation on ARM PCs to support AVX/AVX2. For those unaware, AVX is a set of math instructions that lets apps process lots of data at once, which many games and creative apps expect on Intel or AMD chips.

Because most ARM chips don’t have AVX in hardware, those apps could fail to launch or miss features. With AVX emulated, far more titles are now open and run on Snapdragon X laptops, though performance can vary because it’s still emulation.

If it’s not turned on your PC, you can right-click any app’s .exe, open Properties > Compatibility > Windows Arm compatibility, and select “Show newer emulated CPU features.”

If you see Hide newer emulated CPU features (x64 apps only), it’s already on.

Are you excited that Fortnite and other games are now playable on Windows ARM devices? Let me know!

The post Windows on Arm looks ready for gaming, as Fortnite finally runs appeared first on Windows Latest

Four years after its launch, Windows 11 is exploring a major update to the Context Menu, at least for some apps. It has every ingredient to finally fix what users have been complaining about. Microsoft calls this new UI update for the right-click menu in WinUI 3-based apps, and the feature is called “Split Context Menu.”

Microsoft won’t clarify whether this idea will be applied to the shell or remain limited to WinUI apps for now. If it’s applied to the shell, it’ll be available everywhere in Windows 11. If not, you will only see the new menu in some apps.

Microsoft confirmed the upgrade in the WinUI Community call spotted by Windows Latest.

When you right-click on a file or folder in any app or Windows, the menu that shows up is called the context menu. Its purpose is to provide quick access to relevant actions based on what you’re interacting with. But lately, this menu has gotten a little too useful with too many options.

Microsoft admits that the current right-click menu makes the context menu appear cluttered with a long list of actions, something that has been bothering users for a long time. Also, you might have noticed that when you right-click a file, you’ll likely see irrelevant or excessive “contextual” actions that could’ve been avoided in the first place.

Here, while right-clicking on an image, even though there is an option to open in the Photos app, you can see the Photos app mentioned two more times in the context menu. Besides that, there are other options down below, which could frankly be integrated into the “Open with” menu.

This is a system-wide problem, which means menus in WinUI-based apps like the Microsoft Photos app are also taller.

Well, Microsoft’s solution is to add context-aware nested menus, based on the type of file, which ideally would reduce the length of the context menu, while allowing developers to add useful secondary actions. This change will first arrive in WinUI-based apps, but Microsoft won’t clarify if it will eventually arrive for all menus in Windows 11.

This means all Photos app-related options will now be grouped under “Open with Photos” and the secondary menu will show all related options when you hover.

What is the Split Context Menu?

The Split Context Menu in WinUI apps aims to make the right-click experience more intuitive, organized, and context-aware through a new API called SplitMenuFlyoutItem, which allows a single menu entry to contain both a primary action and secondary options, shown in a separate, smaller flyout beside the main item.

For users, instead of seeing multiple repetitive entries in the right-click menu, like Open with Photos, Edit with Photos, and Set as desktop background, they’ll see just one “Open with Photos” option, with related secondary apps such as Paint or Snipping Tool, all tucked into the secondary menu (split menu).

You can hover over “Open with Photos” to see all related options in the secondary menu.

Based on the images shared in the WinUI Community Call, we can safely say that this new UI design solves two long-standing problems. The first is that it prevents menus from stacking similar items into a single vertical list.

The second is that it makes options more adaptive and shows only the options that are relevant to the selected file.

Developers can also define which action appears as the default and group less-used or advanced tools under a small arrow next to it.

How the new secondary (Split Context) menu works

The new Split Context Menu is powered by a WinUI 3 control called SplitMenuFlyoutItem, which is a part of the latest Windows App SDK. This new control changes how context menus are rendered inside WinUI-based apps by letting a single item behave both as a primary action and a secondary menu container.

When a developer defines a SplitMenuFlyoutItem, it acts as a hybrid of a button and a submenu:

• Right-click on an image, and the context menu appears. It has a “Photos” option, which is the primary action.
• Then, Microsoft is adding a nested menu, which lets you access all Photos-related commands or apps (Paint, Snipping Tool). This second menu can be accessed by hovering over the Photos option in the primary context menu. Right now, all these apps and options are repeated several times in the primary menu.

From the demo, it is clear that the new control supports context-aware grouping. That means Windows apps can now dynamically determine which secondary actions to show based on the file type.

When a .txt file is right-clicked, Open with Notepad appears as the default, with other editors hidden in the secondary menu, which can be accessed by hovering “Open with Notepad.” This reduces repetition, as you just have “Open with Notepad” in the primary right-click menu, and everything else shows up only when you hover over the Notepad option.

The whole feature may not need extra compute resources, because the contextual actions are added on by developers, who can assign defaults, where Windows automatically promotes the most frequently used app for the selected file type. Developers can also adapt menus per file type, so the same app can appear differently when right-clicking a text file vs an image.

New context menu could reduce clutter by 38% in some cases

Microsoft’s new Split Context Menu drastically trims the clutter that plagued the right-click menu, with a cleaner, shorter, and potentially smarter layout. As shared by Microsoft developers, the new design reduced overall menu length by up to 38%, but it depends on the file type.

In some cases, the menu shrinks by 35% when groups all related options like Open with Photos, Set as desktop background, and Edit with Photos appear under a single split menu. See the screenshot below.

Since these examples are of WinUI 3-based apps only, they don’t have Cut, Copy, Rename, Share, and Delete buttons.

Text-based files, right-click menu, see only a 30% reduction in menu height, but that in itself is a welcome change. The “Open in Notepad” option will be on top, with any other supported applications under the submenu.

Sharing the file will also be in a single button, with “Share to phone” being the default action, likely powered by Phone Link.

Right-clicking folders gets the most reduction in height, which makes sense because the current layout repeats similar actions like Pin to Quick Access, Pin to Start, and Pin to Task Bar, which all can be consolidated into one default Pin to…option. Unsurprisingly, there are also three separate “Open” options.

But can we expect this new menu to be available everywhere in Windows, such as File Explorer?

While Microsoft examples clearly use “File Explorer,” the “Split view” feature in the question is specifically for WinUI-based apps or menus. This means it will roll out to Windows apps for now, such as Microsoft Photos. However, that could change in the future, as Microsoft might adopt a similar design approach for every corner in Windows 11.

The Split Context Menu is still under an early developer stage and isn’t available in any app. So, any chance for testing for regular users is out of the question.

Microsoft detailed its underlying API in the official WinUI GitHub repository, so developers can already begin experimenting with it by referencing the control through the latest Windows App SDK preview builds.

Right now, there is no word on when the Split Context Menu will arrive for the shell (everything in Windows 11) for everyone.

Microsoft is also working on the long-promised acrylic blur, which is slated to come to every corner of apps in Windows 11. Both these are steps in the right direction for the company, which is finally shifting to benefit regular users rather than its habit of going full B2B.

The post Microsoft admits Windows 11’s right-click menu is cluttered, confirms fix for WinUI apps appeared first on Windows Latest

Former Apple Swift Student Challenge winners Brayden Gogis, Adrit Rao, and Sofia Sandoval share their journeys from app ideas to App Store.

Much like the introduction of the personal computer, the Internet, and the iPhone into the public sphere, recent developments in the AI space, from Generative AI to Agentic AI, have fundamentally changed the way people live and work. Since ChatGPT’s release in late 2022, it’s reached a threshold of 700 million users per week, approximately 10% of the global adult population. And according to a 2025 report by Capgemini, Agentic AI adoption is expected to grow by 48% by the end of the year. It’s quite clear that this latest iteration of AI technology has transformed virtually every industry and profession, and data engineering is no exception.

As Naveen Sharma, SVP and Global Practice Head at Cognizant, observes, “what makes data engineering uniquely pivotal is that it forms the foundation of modern AI systems, it’s where these models originate and what enables their intelligence.” Thus, it’s unsurprising that the latest advances in AI would have a sizable impact on the discipline, perhaps even an existential one. With the increased adoption of AI coding tools leading to the reduction of many entry-level IT positions, should data engineers be wary about a similar outcome for their own profession? Khushbu Shah, Associate Director at ProjectPro, poses this very question, noting that “we’ve entered a new phase of data engineering, one where AI tools don’t just support a data engineer’s work; they start doing it for you […] Where does that leave the data engineer? Will AI replace data engineers?”

Despite the growing tide of Gen AI and Agentic AI, data engineers won’t be replaced anytime soon. While the latest AI tools can help automate and complete rote tasks, data engineers are still very much needed to maintain and implement the infrastructure that houses data required for model training, build data pipelines that ensure accurate and accessible data, and monitor and enable model deployment. And as Shah points out, “prompt-driven tools are great at writing code but they can’t reason about business logic, trade-offs in system design, or the subtle cost of a slow query in a production dashboard.” So while their customary daily tasks might shift with the increasing adoption of the latest AI tools, data engineers still have an important role to play in this technological revolution.

The Role of Data Engineers in the New AI Era

In order to adapt to this new era of AI, the most important thing data engineers can do involves a fairly self-evident mindshift. Simply put, data engineers need to understand AI and how data is used in AI systems. According to Mike Loukides, VP of Content Strategy at O’Reilly Media, “data engineering isn’t going away, but you won’t be able to do data engineering for AI if you don’t understand the AI part of the equation. And I think that’s where people will get stuck. They’ll think, ‘Same old same old,’ and it isn’t. A data pipeline is still a data pipeline, but you have to know what that pipeline is feeding.”

So how exactly is data used? Since all models require huge amounts of data for initial training, the first stage involves collecting raw data from various sources, be it databases, public datasets, or APIs. And since raw data is often unorganized or incomplete, preprocessing the data is necessary to prepare it for training, which involves cleaning, transforming, and organizing the data to make it suitable for the AI model. The next stage concerns training the model, where the preprocessed data is fed into the AI model to learn patterns, relationships, or features. After that there’s post-training, where the model is fine-tuned with data important to the organization that’s building the model, a stage that also requires a significant amount of data. Related to this stage is the concept of RAG (Retrieval-Augmented Generation), a technique that provides real-time, contextually relevant information to a model in order to improve the accuracy of responses.

Other important ways that data engineers can adapt to this new environment and help support current AI initiatives is by improving and maintaining high data quality, designing robust pipelines and operational systems, and ensuring that privacy and security measures are met.

During a testimony with a US House of Representatives Committee on the topic of AI innovation, Gecko Robotics co-founder Troy Demmers affirmed a golden axiom of the industry, “AI applications are only as good as the data they are trained on. Trustworthy AI requires trustworthy data inputs.” It’s the reason why roughly 85% of all AI projects fail and why many AI professionals flag it as a major source of concern: without high-quality data, even the most sophisticated models and AI agents can go awry. Since most Gen AI models depend upon large datasets to function, data engineers are needed to process and structure this data so that it’s clean, labeled, and relevant, ensuring reliable AI outputs.

Just as importantly, data engineers need to design and build newer, more robust pipelines and infrastructure that can scale with Gen AI requirements. As Adi Polak, Director of AI & Data Streaming at Confluent, notes, “the next generation of AI systems requires real-time context and responsive pipelines that support autonomous decisions across distributed systems”, well beyond traditional data pipelines that can only support batch-trained models or power reports. Instead, data engineers are now tasked with creating nimbler pipelines that can process and support real-time streaming data for inference, historical data for model fine-tuning, versioning, and lineage tracking. They also must have a firm grasp of streaming patterns and concepts, from event driven architecture to retrieval and feedback loops, in order to build high-throughput pipelines that can support AI agents.

While Gen AI’s utility is indisputable at this point, the technology is saddled with notable drawbacks. Hallucinations are most likely to occur when a model doesn’t have the proper data it needs to answer a given question. Like many systems that rely on vast streams of information, the latest AI systems are not immune to private data exposure, biased outputs, and intellectual property misuse. Thus, it’s up to data engineers to ensure that the data used by these systems are properly governed, secured, and comply with relevant data and AI regulations. As data engineer Axel Schwanke astutely notes, these measures may include “limiting the use of large models to specific data sets, users and applications, documenting hallucinations and their triggers, and ensuring that GenAI applications disclose their data sources and provenance when they generate responses”, as well as sanitizing and validating all Gen AI inputs and outputs. An example of a model that addresses the latter measures is O’Reilly Answers, one of the first models that provides citations for content it quotes.

The Road Ahead

Data engineers should remain gainfully employed as the next generation of AI continues on its upward trajectory, but that doesn’t mean there aren’t significant challenges around the corner. As autonomous agents continue to evolve, questions regarding the best infrastructure and tools to support them have arisen. As Ben Lorica ponders, “what does this mean for our data infrastructure? We are designing intelligent, autonomous systems on top of databases built for predictable, human-driven interactions. What happens when software that writes software also provisions and manages its own data? This is an architectural mismatch waiting to happen, and one that demands a new generation of tools.” One such potential tool has already arisen in the form of AgentDB, a database designed specifically to work effectively with AI agents.

In a similar vein, a recent research paper, “Supporting Our AI Overlords”, opines that data systems must be redesigned to be agent-first. Building upon this argument, Ananth Packkildurai observes that “it’s tempting to believe that the Model Context Protocol (MCP) and tool integration layers solve the agent-data mismatch problem […] However, these improvements don’t address the fundamental architectural mismatch. […] The core issue remains: MCP still primarily exposes existing APIs—precise, single-purpose endpoints designed for human or application use—to agents that operate fundamentally differently.” Whatever the outcome of this debate may be, data engineers will likely help shape the future underlying infrastructure used to support autonomous agents.

Another challenge for data engineers will be successfully navigating the ever amorphous landscape of data privacy and AI regulations, particularly in the US. With the One Beautiful Bill Act leaving AI regulation under the aegis of individual state laws, data engineers need to keep abreast of any local legislations that might impact their company’s data use for AI initiatives, such as the recently signed SB 53 in California, and adjust their data governance strategies accordingly. Furthermore, what data is used and how it’s sourced should always be at top of mind, with Anthropic’s recent settlement of a copyright infringement lawsuit serving as a stark reminder of that imperative.

Lastly, the quicksilver momentum of the latest AI has led to an explosion of new tools and platforms. While data engineers are responsible for keeping up with these innovations, that can be easier said than done, due to steep learning curves and the time required to truly upskill in something versus AI’s perpetual wheel of change. It’s a precarious balancing act, one that data engineers must get a bead on quickly in order to stay relevant.

Despite these challenges however, the future outlook of the profession isn’t doom and gloom. While the field will undergo massive changes in the near future due to AI innovation, it will still be recognizably data engineering, as even technology like Gen AI requires clean, governed data and the underlying infrastructure to support it. Rather than being replaced, data engineers are more likely to emerge as key players in the grand design of an AI-forward future.

In our previous post, we explored how Phi-4 represents a new frontier in AI efficiency that delivers performance comparable to models 5x its size while being small enough to run on your laptop. Today, we're taking the next step: getting Phi-4 up and running locally on your machine using Microsoft Foundry Local.

Whether you're a developer building AI-powered applications, an educator exploring AI capabilities, or simply curious about running state-of-the-art models without relying on cloud APIs, this guide will walk you through the entire process. Microsoft Foundry Local brings the power of Azure AI Foundry to your local device without requiring an Azure subscription, making local AI development more accessible than ever.

So why do you want to run Phi-4 Locally?

Before we dive into the setup, let's quickly recap why running models locally matters:

Privacy and Control: Your data never leaves your machine. This is crucial for sensitive applications in healthcare, finance, or education where data privacy is paramount.

Cost Efficiency: No API costs, no rate limits. Once you have the model downloaded, inference is completely free.

Speed and Reliability: No network latency or dependency on external services. Your AI applications work even when you're offline.

Learning and Experimentation: Full control over model parameters, prompts, and fine-tuning opportunities without restrictions.

With Phi-4's compact size, these benefits are now accessible to anyone with a modern laptop—no expensive GPU required.

What You'll Need

Before we begin, make sure you have:

• Operating System: Windows 10/11, macOS (Intel or Apple Silicon), or Linux
• RAM: Minimum 16GB (32GB recommended for optimal performance)
• Storage: At least 5 - 10GB of free disk space
• Processor: Any modern CPU (GPU optional but provides faster inference)

Note: Phi-4 works remarkably well even on consumer hardware 😀.

Step 1: Installing Microsoft Foundry Local

Microsoft Foundry Local is designed to make running AI models locally as simple as possible. It handles model downloads, manages memory efficiently, provides OpenAI-compatible APIs, and automatically optimizes for your hardware.

For Windows Users:

Open PowerShell or Command Prompt and run:

winget install Microsoft.FoundryLocal

For macOS Users (Apple Silicon):

Open Terminal and run:

brew install microsoft/foundrylocal/foundrylocal

Verify Installation:

Open your terminal and type. This should return the Microsoft Foundry Local version, confirming installation:

foundry --version

Step 2: Downloading Phi-4-Mini

For this tutorial, we'll use Phi-4-mini, the lightweight 3.8 billion parameter version that's perfect for learning and experimentation.

Open your terminal and run:

foundry model run phi-4-mini

You should see your download begin and something similar to the image below

Available Phi Models on Foundry Local

While we're using phi-4-mini for this guide, Foundry Local offers several Phi model variants  and other open-source models optimized for different hardware and use cases:

Note: Foundry Local automatically selects the best variant for your hardware. If you have an NVIDIA GPU, it will use the GPU-optimized version. Otherwise, it will use the CPU-optimized version.

run the command below to see full list of models

foundry model list

Step 3: Test It Out

Once the download completes, an interactive session will begin. Let's test Phi-4-mini's capabilities with a few different prompts:

Example 1: Explanation

Phi-4-mini provides a thorough, well-structured explanation! It starts with the basic definition, explains the process in biological systems, gives real-world examples (plant cells, human blood cells). The response is detailed yet accessible.

Example 2: Mathematical Problem Solving

Excellent step-by-step solution! Phi-4-mini breaks down the problem methodically:
1. Distributes on the left side
2. Isolates the variable terms
3. Simplifies progressively
4. Arrives at the final answer: x = 11

The model shows its work clearly, making it easy to follow the logic and ideal for educational purposes

Example 3: Code Generation

The model provides a concise Python function using string slicing ([::-1]) - the most Pythonic approach to reversing a string. It includes clear documentation with a docstring explaining the function's purpose, provides example usage demonstrating the output, and even explains how the slicing notation works under the hood. The response shows that the model understands not just how to write the code, but why this approach is preferred - noting that the [::-1] slice notation means "start at the end of the string and end at position 0, move with the step -1, negative one, which means one step backwards." This showcases the model's ability to generate production-ready code with proper documentation while being educational about Python idioms. 

 

To exit the interactive session, type `/bye` 

Step 4: Extending Phi-4 with Real-Time Tools

Understanding Phi-4's Knowledge Cutoff

Like all language models, Phi-4 has a knowledge cutoff date from its training data (typically several months old). This means it won't know about very recent events, current prices, or breaking news. For example, if you ask "Who won the 2024 NBA championship?" it might not have the answer.

The good thing is, there's a powerful work-around.

While Phi-4 is incredibly capable, connecting it to external tools like web search, databases, or APIs transforms it from a static knowledge base into a dynamic reasoning engine. This is where Microsoft Foundry's REST API comes in.

Microsoft Foundry provides a simple API that lets you integrate Phi-4 into Python applications and connect it to real-time data sources. Here's a practical example: building a web-enhanced AI assistant.

Web-Enhanced AI Assistant

This simple application combines Phi-4's reasoning with real-time web search, allowing it to answer current questions accurately.

Prerequisites:

pip install foundry-local-sdk requests ddgs

Create phi4_web_assistant.py:

import requests from foundry_local import FoundryLocalManager from ddgs import DDGS import json def search_web(query): """Search the web and return top results""" try: results = list(DDGS().text(query, max_results=3)) if not results: return "No search results found." search_summary = "\n\n".join([ f"[Source {i+1}] {r['title']}\n{r['body'][:500]}" for i, r in enumerate(results) ]) return search_summary except Exception as e: return f"Search failed: {e}" def ask_phi4(endpoint, model_id, prompt): """Send a prompt to Phi-4 and stream response""" response = requests.post( f"{endpoint}/chat/completions", json={ "model": model_id, "messages": [{"role": "user", "content": prompt}], "stream": True }, stream=True, timeout=180 ) full_response = "" for line in response.iter_lines(): if line: line_text = line.decode('utf-8') if line_text.startswith('data: '): line_text = line_text[6:] # Remove 'data: ' prefix if line_text.strip() == '[DONE]': break try: data = json.loads(line_text) if 'choices' in data and len(data['choices']) > 0: delta = data['choices'][0].get('delta', {}) if 'content' in delta: chunk = delta['content'] print(chunk, end="", flush=True) full_response += chunk except json.JSONDecodeError: continue print() return full_response def web_enhanced_query(question): """Combine web search with Phi-4 reasoning""" # By using an alias, the most suitable model will be downloaded # to your device automatically alias = "phi-4-mini" # Create a FoundryLocalManager instance. This will start the Foundry # Local service if it is not already running and load the specified model. manager = FoundryLocalManager(alias) model_info = manager.get_model_info(alias) print("🔍 Searching the web...\n") search_results = search_web(question) prompt = f"""Here are recent search results: {search_results} Question: {question} Using only the information above, give a clear answer with specific details.""" print("🤖 Phi-4 Answer:\n") return ask_phi4(manager.endpoint, model_info.id, prompt) if __name__ == "__main__": # Try different questions question = "Who won the 2024 NBA championship?" # question = "What is the latest iPhone model released in 2024?" # question = "What is the current price of Bitcoin?" print(f"Question: {question}\n") print("=" * 60 + "\n") web_enhanced_query(question) print("\n" + "=" * 60)

 

Run It:

python phi4_web_assistant.py

What Makes This Powerful

By connecting Phi-4 to external tools, you create an intelligent system that:

• Accesses Real-Time Information:  Get news, weather, sports scores, and breaking developments
• Verifies Facts: Cross-reference information with multiple sources
• Extends Capabilities: Connect to databases, APIs, file systems, or any other tool
• Enables Complex Applications: Build research assistants, customer support bots, educational tutors, and personal assistants

This same pattern can be applied to connect Phi-4 to:

• Databases: Query your company's internal data
• APIs: Weather services, stock prices, translation services
• File Systems: Analyze documents and spreadsheets
• IoT Devices: Control smart home systems

The possibilities are endless when you combine local AI reasoning with real-world data access.

Troubleshooting Common Issues

Service not running: Make sure Foundry Local is properly installed and the service is running. Try restarting with foundry --version to verify installation.

Model downloads slowly: Check your internet connection and ensure you have enough disk space (5-10GB per model).

Out of memory: Close other applications or try using a smaller model variant like phi-3.5-mini instead of the full phi-4.

Connection issues: Verify that no other services are using the same ports. Foundry Local typically runs on http://localhost:5272.

Model not found: Run foundry model list to see available models, then use foundry model run <model-name> to download and run a specific model.

Your Next Steps with Foundry Local

Congratulations! You now have Phi-4 running locally through Microsoft Foundry Local and understand how to extend it with external tools like web search. This combination of local AI reasoning with real-time data access opens up countless possibilities for building intelligent applications.

Coming in Future Posts

In the coming weeks, we'll explore advanced topics using Hugging Face:

• Fine-tuning Phi models on your own data for domain-specific applications
• Phi-4-multimodal: Analyze images, process audio, and combine multiple data types
• Advanced deployment patterns: RAG systems and multi-agent orchestration

Resources to Explore

• EdgeAI for Beginners Course: Comprehensive 36-45 hour course covering Edge AI fundamentals, optimization, and production deployment
• Phi-4 Technical Report: Deep dive into architecture and benchmarks
• Phi Cookbook on GitHub: Practical examples and recipes
• Foundry Local Documentation: Complete technical documentation and API reference
• Module 08: Foundry Local Toolkit: 10 comprehensive samples including RAG applications and multi-agent systems

Keep experimenting with Foundry Local, and stay tuned as we unlock the full potential of Edge AI!

What will you build with Phi-4? Share your ideas and projects in the comments below!

 

 

 

Last Friday’s session was a game-changer for anyone looking to keep AI use safe, ethical, and compliant. We didn’t just talk theory—we showed real-world strategies for monitoring Copilot interactions and protecting sensitive data with Microsoft Purview Communication Compliance.

 

Missed the session?  No worries we have you covered.    You can watch it here https://aka.ms/Compliance-Meets-Ai-Session-Five 

🔥 Top Highlights

• The Big Picture
  Copilot is transforming productivity—but with great power comes great responsibility. Communication Compliance helps you spot risky prompts, prevent data leaks, and enforce ethical AI use across Copilot, Copilot Chat, Agents and Copilot Studio. 
• Policy Power Moves
  Learn how to build smart policies that detect sensitive info like MRNs, credit card numbers, or custom keywords. We explored trainable classifiers for prompt injection attacks and inappropriate content—plus tips for scoping policies to specific teams or roles. 
• From Alerts to Action
  Tag it. Resolve it. Escalate it. Even kick off Power Automate workflows for instant notifications. We showed how to turn alerts into actionable compliance steps that keep your organization secure. 
• Insights That Matter
  Dive into dashboards that reveal top triggered policies, sensitive data trends, and user activity—so you can make informed decisions and strengthen governance. 

✅ Next Up: Insider Risk Management for Copilot

📅 Date: 11.7.25
🎤 Host: Kevin Uy
👉 https://aka.ms/ComplianceMeetsAI

Don’t miss this one—we’re taking compliance to the next level!