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

Microsoft Scout: From personal project to enterprise-ready personal agent

1 Share

Early this year, OpenClaw demos were seemingly everywhere, though many seemed to amount at best to a cool party trick (“Look, my agent ordered a pizza”). But it got long-time Microsoft employee Omar Shahine thinking: How useful could claws actually be? 

Very, it turned out. In his spare time, Shahine created Lobster, a personal AI assistant built on OpenClaw. It has its own Apple ID and email address, so he can text with it from any device with iMessage. He initially split Lobster into a trio of agents, each with its own security profile and tool access (eight weeks in, that number had increased to nine always-on agents). Lobster handles travel logistics, proactively sends family reminders ahead of time, and generally helps Shahine and his family stay organized and get things done. And after presenting Lobster to Microsoft’s AI Accelerator group, it landed Shahine a new job: bringing OpenClaw to M365 and the cloud as CVP of what was deemed “Project Lobster.” 

At the same time, Microsoft Member of Technical Staff Jakob Werner was pursuing a similar idea with a twist: a desktop app-based agent inspired by OpenClaw. The goal was to deliver a powerful enterprise-secure personal AI assistant that anyone within Microsoft could use. In just a couple weeks, what was referred to internally as “Clawpilot” had already been downloaded by thousands of Microsoft employees, and that community continues to grow. 

When Shahine started assembling a small team of enthusiastic builders—Ocean’s 11, naturally—Werner quickly joined their ranks. The two recently caught up in Redmond, Washington, to compare notes on building these always-on, autonomous agents and navigating the worlds of enterprise security, agentic memory, and more.

Embracing the spirit of open source 

The Project Lobster team is representative of a new way of working within Microsoft, fueled by AI advancements. It’s a tight-knit group that prefers to collaborate asynchronously. There’s a general consensus against meetings. Everyone contributes to the codebase, including Shahine. And there’s no traditional executive assistant among their ranks: Each team member actively uses prototypes throughout the day to fully immerse themselves in the tech as they’re building it. There’s even a growing open-source community around the team that mirrors what’s found with open-source projects outside Microsoft’s walls. 

“I’ve never seen a project inside the company where so many people showed up with their ideas and their code and did the work to produce a PR,” says Shahine. 

> I’ve never seen a project inside the company where so many people showed up with their ideas.

In fact, internal excitement around Project Lobster has been such that the team fielded pull requests (PRs) left and right during the early building phase, which they reviewed to determine whether they met the bar to make it into the product. Even some of Shahine’s changes didn’t make the cut. The focus had to remain on the central goal of the product: Creating an always-on personal agent for work. An AI helper that learns your goals, adapts to your daily work patterns, and acts with context, identifying issues before they surface, keeping projects on track and driving outcomes without constant input. An agent that can detect when a calendar is overbooked and propose specific changes before the week begins or identify when a decision is stalled and draft a targeted follow-up to unblock it. 

“We have to determine if a given PR changes the central idea of the product or not—and the speed of that review is human speed, not AI speed,” notes Werner. “Anyone can make a PR super quickly now. We’re trying to help the community and teach contributors how to review PRs.” 

While the work began as an internal experiment, it quickly turned into a customer-focused effort that’s culminated with the introduction of Microsoft Scout—an always-on personal agent powered by OpenClaw open-source technology. 

From experiment to enterprise-ready product 

Microsoft Scout operates autonomously—with its own identity—acting on your behalf. It works across cloud, desktop, and web browser, so it can connect across the surfaces you use—Teams, Outlook, OneDrive, and SharePoint—and the systems where work lives, including email, calendar, and contacts. 

Unlike your average claw in the wild, Microsoft Scout combines OpenClaw code with enterprise identity, governance, and security. Every package is ingested through a curated, signed Microsoft supply chain, and every tool call, model request, and network hop is mediated by a zero-trust runtime—the agent’s container is treated as untrusted, with Microsoft-controlled identity, tokens, and policy sitting outside it. With Agent 365, admins get a single control plane, and Microsoft Purview gives security teams the same compliance and DLP signal they already get from other M365 surfaces. 

“It’s a super powerful tool,” acknowledges Werner. “And to be enterprise secure, we needed to make sure the data governance was right, that the privacy was right, and that it doesn’t cancel a meeting and send all your personal information to that email chain. If I send my agent to you, it shouldn’t tell you everything about me. These areas are possible to contain, but we also had to do it in a balanced way that doesn’t restrict the possibilities down to nothing.” 

It’s a tradeoff worth making. And with Microsoft’s tried and trusted enterprise security offerings and ongoing research and innovation in the space, the team had a solid foundation from which to address the challenge. 

The role of agentic memory 

In order for an always-on personal AI agent to be truly useful, it needs to be proactive—and that requires context powered by Work IQ. Over time, Microsoft Scout understands the way you work, uses the same productivity tools you use, and takes things off your plate without the need for constant prompts. It learns your goals, adapts to your daily work patterns, and acts with intent. Unlike previous technological waves, this is software that’s truly personalized. That’s transformative, but it’s not without tradeoffs. 

“OpenClaw, Claude Code, GitHub Copilot CLI, these are agentic coding harnesses that are basically remembering—writing things down just like people do,” Shahine notes. “They write things down like a diary. But just like it needs to remember things, it needs to forget some things, too.” 

> Just like it needs to remember things, it needs to forget some things, too.

As an example, Shahine points back to the introduction of memory to ChatGPT. He spent some time telling ChatGPT that his daughter was 17 while his son was 13. But a year later, that information remained static. The system didn’t have a concept that some facts need to change over time, while other pieces of information—like your name—will stay exactly the same. 

“In the design phase, I was thinking about the human and how humans memorize things,” says Werner. “I forget things that are irrelevant because I didn’t use them. So I built a system where, if I’m going to use it repeatedly, it’s going to stick. But if I’m not going to use it regularly, I want the system to forget. I don’t want to have an infinite diary of things, right? So there’s kind of layers of memory, and it kind of disappears over time if it’s not used. Meanwhile, the relevance of other pieces of memory grows as you use them more.” 

Forming a new center of gravity 

When they first joined forces, Werner introduced Shahine to the concept of gravity—the framework around which he operated. 

“To build a truly great product, I don’t think I can make it myself,” Werner explains. “We need to collaborate with other people. But how do we influence other people to collaborate with us? And the mindset I use and try to instill in my team is gravity. We build something and make it so big in influence—not in the number of features, but in its influence—that when exciting new ideas pop up, they want to try and join the gravity of our work rather than dissolve focus.” 

“And I didn’t really know what you were talking about until my new role was announced,” admits Shahine. “But since then, I’ve received hundreds if not thousands of messages from people who want to help, people who want to learn, people who want to show me what they did, and customers who want to know ASAP when they’re going to get their hands on what we’re building. There are a lot of other words for that—user pull, signal—but your mantra of gravity really resonates with me now.” 


Microsoft employees have already been using an early Microsoft Scout desktop experience. We built this to learn how always-on agents show up in real work, and we’re seeing it take on coordination, surface risks earlier, and keep work moving without constant prompting. 

We’re now extending that early experience to Frontier organizations. Microsoft Scout is available as an experimental release through Frontier, giving customers a chance to explore how it can fit into their own workflows. 

Access requires Frontier enrollment, Intune policy configuration, and an opt-in attestation. Users with a GitHub Copilot license can then download and install the experience. Learn more.

The post Microsoft Scout: From personal project to enterprise-ready personal agent appeared first on Command Line.

Read the whole story
alvinashcraft
12 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Azure DevOps and GitHub: Journeying into the AI Era

1 Share

AI is changing how software gets planned, built, and reviewed. As teams adopt agentic development, the platform underneath those workflows matters more. They need tools that bring planning, coding, security, and collaboration together—and can keep pace with how development is evolving.

That’s why we’re delivering the newest agentic capabilities on GitHub across planning, coding, code review, and security. For teams driving active development, that often means moving repositories to GitHub to unlock the latest AI-powered workflows, while continuing to use Azure Boards and Pipelines. For teams that need more time migrating repos to GitHub, we’re continuing to invest in Azure DevOps with improvements focused on security and code quality in the workflows they rely on today.

Unlocking agentic development on GitHub

Organizations that move repositories to GitHub unlock the full agentic development experience, including a broad choice of models from Anthropic, OpenAI, Google, and others in Copilot, along with agentic workflows across GitHub, VS Code, mobile, CLI, and integrations like Teams, Slack, and Azure Boards. Enterprise governance is built in through an agent control plane that provides visibility, audit, and policy management.

Teams can continue using Azure DevOps capabilities such as Azure Boards, Pipelines, and Test Plans alongside their GitHub repos. Azure DevOps basic usage rights are included with GitHub Enterprise, making it easier to adopt a hybrid model without additional overhead. Enterprise Live Migrations and deeper GitHub–Azure DevOps integration make it practical to transition at enterprise scale, as reflected in Microsoft’s own migration journey.

Enterprise Live Migrations — Preview

Large repos and complex organizations need migration options that respect how their teams operate. Enterprise Live Migrations (ELM), now available in preview, enables organizations to migrate multiple repositories together with minimal cutover downtime. ELM supports starting migration without locking the Azure DevOps repository, allowing developers to continue working while teams transition at a pace that fits their portfolio and operational needs. Repository history, branches, and metadata are preserved throughout the migration process. For organizations choosing GitHub for source control while continuing to use Azure DevOps for planning, CI/CD and testing, ELM is designed to make that transition significantly easier and less disruptive. A script-based migration experience is available today in preview, with a more streamlined end-to-end experience coming soon. Join the waitlist for early access to Enterprise Live Migration.

Customer zero: How Microsoft is moving to GitHub internally

Microsoft is using this model internally too. In the Copilot, Agents, and Platform team, a small migration team has moved 1,575 repositories from Azure Repos to GitHub Enterprise, helping drive a company-wide shift at scale. Today, more than 3,000 developers are on GitHub, and 45% of pull requests now happen there.

AI is the forcing function. GitHub is where Copilot, agents, and new AI workflows ship first and run at scale, so moving source control there gives teams faster access to the latest capabilities. At the same time, teams can continue to use Azure Pipelines and Azure Boards in Azure DevOps while they move their code to GitHub, without waiting for a full platform transformation.

For a deeper look at how the team approached the migration, including practical best practices and lessons learned, see the related blog post.

Connecting agents to your DevOps context

As teams adopt hybrid workflows across GitHub and Azure DevOps, agents need context from the systems where work gets planned, built, reviewed, and shipped. GitHub already provides a remote MCP server for repository and workflow context. The new Azure DevOps remote MCP server in preview extends that model to Azure DevOps, bringing work items, builds, pull requests, test plans, and other project context directly into agentic workflows.

The service is fully hosted by Microsoft, geo-routed, and stateless, with no Azure DevOps customer data persisted within the MCP service itself. It’s also available in Azure AI Foundry for building custom agents, and we’re working to make it available in Copilot Studio and Microsoft 365 Copilot so teams can connect Azure DevOps to their agents without managing additional infrastructure.

Security and quality improvements for Azure DevOps repositories

For teams continuing to run repos on Azure DevOps, we’re bringing AI-powered capabilities directly into the workflows they already use. The updates below focus on two areas that matter most: improving code quality in pull requests and helping developers remediate security issues faster.

Copilot Code Review for Azure DevOps — Preview

With Copilot Code Review, now in preview, developers can request an automated review on any pull request and receive inline comments and suggestions directly in the Azure DevOps pull request experience. Organization administrators maintain full control over adoption and enablement through settings at the org, project, or repository level. Usage is billed using GitHub AI Credits through the same Azure subscription your organization already uses for Azure DevOps, with no separate license management required. Copilot Code Review is designed to complement, not replace, human reviewers. It doesn’t block merges or count toward required reviewers. Instead, it acts as an additional layer of review that helps surface issues earlier, allowing engineers to focus their attention on the changes that matter most. Join the waitlist for early access to Copilot Code Review for Azure DevOps.

Autofix for CodeQL in Azure DevOps — Preview

Security issues are only valuable to surface if teams can fix them efficiently. Autofix for CodeQL alerts, now in preview for Azure Repos as part of GitHub Advanced Security for Azure DevOps, brings AI-powered remediation directly into the code security workflow. With Autofix, developers can request a suggested fix for an open CodeQL alert, and Copilot automatically creates a pull request with the proposed remediation ready for review. It’s the same Autofix experience GitHub customers have used to significantly reduce time-to-remediation for security issues. Preview today covers a subset of CodeQL alerts and will expand over time toward broader coverage across code scanning alerts as we move toward general availability. Join the waitlist for early access to autofix for CodeQL in Azure DevOps.

Apple Silicon Macs for Azure Pipelines, with pay-per-minute billing

Apple Silicon Macs — a capability many customers have been waiting for — are now available as Microsoft-hosted agents in Azure Pipelines with pay-per-minute billing. Teams can now run faster Apple-native builds for iOS and macOS without managing their own Mac infrastructure or planning capacity for parallel jobs, while paying through a flexible usage-based model that scales with pipeline demand.

Moving forward

GitHub is where the newest AI-powered development workflows are taking shape, and for many teams that will increasingly mean moving source control there over time. We’re investing to make that transition practical, whether you’re migrating repositories now, adopting a hybrid Azure DevOps + GitHub model, or moving repositories in phases based on complexity and business priorities.

Across each of those paths, the goal is the same: help teams move forward with stronger security, better code quality, and access to the latest agentic capabilities.

The post Azure DevOps and GitHub: Journeying into the AI Era appeared first on Azure DevOps Blog.

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

5 Heart Animations Using .NET MAUI

1 Share

Try your hand at some simple, engaging animations in .NET MAUI. Here are five heart animations you can master today!

I’m a big fan of animations that capture the user’s attention—the kind that don’t just make an app look pretty, but also have the ability to guide users and clearly communicate what’s happening. When used correctly, animations become a key part of design and usability. ✨

In .NET MAUI, we have simple yet very powerful animations that allow us to add that dynamic touch without unnecessary complexity. With just a few lines of code, we can transform common interactions into more natural and enjoyable experiences.

I genuinely love this article, because in it we’ll learn how to create five super-creative animations that elevate our application and showcase the beautiful and powerful things we can achieve using the basic animations available in .NET MAUI

1. Heart ECG Monitor

Heart ECG Monitor Demo

OMG, can we do this in .NET MAUI?? Yess!!! (This is my favorite animation, hahaha).

Let’s create an ECG monitor–style animation, where we can see the movement of the line. To achieve this, we’ll work with both XAML and code-behind.

Let’s start with the XAML.

The design includes a heart and some lines that simulate the monitor’s movement. Both elements will be vertically aligned, so the layout that will contain our design is a VerticalStackLayout.

Inside this layout, we’ll add:

➖ An Image for the heart
➖ And a GraphicsView to draw and animate the monitor lines

<VerticalStackLayout Padding="24" Spacing="16"
   
    <!-- Heart --> 
    <Image x:Name="Heart" 
    Source="redheart" 
    WidthRequest="35" 
    HeightRequest="35" 
    HorizontalOptions="Center" />
    
    <!-- ECG --> 
    <GraphicsView x:Name="Ecg" 
    HeightRequest="120" />

</VerticalStackLayout>

Perfect! Now we’ll continue with the code that brings the monitor and the heart to life. For the purpose of this example, we’ll add everything directly in the code-behind. And how do we locate the code-behind? For example, if your XAML file is called MainPage.xaml, the code-behind is in MainPage.xaml.cs.

Variable Declaration

WindowSize: This variable allows us to control how many heartbeats can be displayed on the screen at the same time. The higher this value is, the more heartbeats will be visible before they move out of view. As a result, a larger WindowSize makes the heartbeat appear slower on the monitor.

Beat: We define an array to represent a complete heartbeat. Values close to zero represent the baseline, while higher values represent the peaks.

_samples: This variable represents what should be displayed on the screen. Initially, we fill it with zeros to display a flat line.

EcgDrawable: This holds the object responsible for drawing the monitor signal.

_i: Finally, we have the index that will be used to iterate through the Beat array.

// Variables
 
const int WindowSize = 140; 
static readonly float[] Beat = 
    { 
    0,0,0, .12f,.25f,.12f, 0, -.25f,1f,-.35f, 0,0, .20f,.35f,.20f, 0,0,0,0 
};

readonly List<float> _samples = Enumerable.Repeat(0f, WindowSize).ToList(); 
readonly EcgDrawable _drawable; 
int _i;

Continuing with the Constructor

Once we have all the required variables defined, the next step is to connect the components and start the animation inside the constructor.

First, we create an instance of EcgDrawable and assign it to the GraphicsView. This allows the view to know how to render the ECG signal based on the provided samples.

Next, we configure a timer using the Dispatcher. This timer is responsible for updating the signal at a regular interval, which helps us achieve a smooth and continuous animation.

On each timer tick:

  • The next value from the heartbeat pattern is added to the samples list.
  • The window size is preserved by removing the oldest value.
  • The GraphicsView is invalidated to force a redraw.

Finally, we start the timer, and the heart monitor animation begins automatically.

In code, it looks like this:

public HeartAnimations() 
{ 
    InitializeComponent(); 
    _drawable = new EcgDrawable(_samples); 
    Ecg.Drawable = _drawable; 
    var t = Dispatcher.CreateTimer(); 
    t.Interval = TimeSpan.FromMilliseconds(16); 
    t.Tick += (_, __) => 
    { 
    _samples.Add(Beat[_i++ % Beat.Length]); 
    if (_samples.Count > WindowSize) _samples.RemoveAt(0); 
    Ecg.Invalidate(); 
    }; 
    t.Start(); 
}

Finally, let’s add the EcgDrawable class.

This class is responsible for visually rendering the ECG signal inside the GraphicsView component. It takes the list of values that represent the heart signal and transforms them into a continuous line, automatically calculating:

  • The vertical position of the signal
  • The horizontal distribution of each point

In code, this translates to the following:

class EcgDrawable(IReadOnlyList<float> samples) : IDrawable 
{ 
    public void Draw(ICanvas c, RectF r) 
    { 
    if (samples.Count < 2) return; 
    c.StrokeColor = Colors.Red; 
    c.StrokeSize = 2; 
    var baseline = r.Top + r.Height * .55f; 
    var amp = r.Height * .35f; 
    var dx = r.Width / (samples.Count - 1); 
    var p = new PathF(); 
    p.MoveTo(r.Left, baseline - samples[0] * amp);  
    for (int i = 1; i < samples.Count; i++) 
    p.LineTo(r.Left + i * dx, baseline - samples[i] * amp);
     
    c.DrawPath(p); 
    } 
}

And that’s it! We’ve just finished building the Heart ECG Monitor animation. See? It wasn’t that hard! I encourage you to try it out and experiment with it on your own.

Now, let’s move on to the next animation!

2. Heart Ripple Pulse

Heart Ripple Pulse

This animation represents the heartbeat and the waves generated by that pulse.

Here, we combine several simple animations and use a Grid as the main container to overlay all the elements in the same space, making them feel like a single, unified animation.

We’ll start with the XAML, where we will define:

➖ Two Border components in red color, representing the ripple waves.

➖ A heart image, which will act as the main element at the center.

<Grid HorizontalOptions="Center" 
    VerticalOptions="Start" 
    Margin="0,100" 
    WidthRequest="140" 
    HeightRequest="140">
    
    <Border x:Name="Ripple1" 
    Stroke="Red" 
    StrokeThickness="3" 
    Opacity="0" 
    Scale="0.2" 
    StrokeShape="RoundRectangle 999" />
     
    <Border x:Name="Ripple2" 
    Stroke="Red" 
    StrokeThickness="3" 
    Opacity="0" 
    Scale="0.2" 
    StrokeShape="RoundRectangle 999" />
     
    <Image x:Name="Heart" 
    Source="redheart.png" 
    WidthRequest="48" 
    HeightRequest="48" 
    HorizontalOptions="Center" 
    VerticalOptions="Center" />

</Grid>

To bring our animation to life, we’ll work with the OnAppearing and in a method called Loop.

OnAppearing: To explore something different, this time we’ll work with the OnAppearing method (✍️ please make sure to declare the _running bool variable).

When the screen appears, we call the Loop method, which is responsible for running the animation cycle.

protected override void OnAppearing() 
{ 
    base.OnAppearing(); 
    _running = true; 
    _ = Loop(); 
}

Loop(): This is where the magic happens. ✨ Inside this method:

  • We trigger the heart pop, a subtle scale effect on the heart
  • We animate the two circular lines to create the ripple effect
  • We use a delay to give each animation enough time and make them clearly distinguishable

Thanks to this approach, we achieve a smooth, easy-to-follow and well-synchronized animation.

In code, this would look like the following:

async Task Loop() 
{ 
    while (_running) 
    { 
    // Reset 
    Ripple1.Opacity = Ripple2.Opacity = 0; 
    Ripple1.Scale = Ripple2.Scale = 0.2; 
    Heart.Scale = 1;
     
    // Heart pop 
    _ = Heart.ScaleTo(1.12, 90, Easing.CubicOut)
    
    .ContinueWith(_ => MainThread.InvokeOnMainThreadAsync( 
    () => Heart.ScaleTo(1.0, 120, Easing.CubicInOut)));
    
    // Ripple 1 
    _ = Task.WhenAll( 
    Ripple1.FadeTo(0.45, 60, Easing.CubicOut), 
    Ripple1.ScaleTo(1.8, 700, Easing.CubicOut) 
    ).ContinueWith(_ => MainThread.InvokeOnMainThreadAsync( 
    () => Ripple1.FadeTo(0, 250, Easing.CubicIn)));

    // Ripple 2 
    await Task.Delay(120); 
    _ = Task.WhenAll( 
    Ripple2.FadeTo(0.35, 60, Easing.CubicOut), 
    Ripple2.ScaleTo(1.8, 700, Easing.CubicOut) 
    ).ContinueWith(_ => MainThread.InvokeOnMainThreadAsync( 
    () => Ripple2.FadeTo(0, 250, Easing.CubicIn)));
     
    await Task.Delay(650); 
    } 
}

And that’s it! Let’s keep going and jump into the next animation!

3. Blinking Heart

Blinking Heart

In this animation, we’ll make a heart blink in a subtle and elegant way. We’ll start with the XAML. In this case, the structure is very simple, since we only need a single heart image, centered on the screen. From this single element, we’ll build the entire animation.

<Image x:Name="Heart"  
    Source="redheart.png"  
    WidthRequest="56"  
    HeightRequest="56"  
    HorizontalOptions="Center"  
    VerticalOptions="Center" />

We’ll continue working with OnAppearing to start the animation, and additionally we’ll create a method called BlinkLoop() to handle the animation logic. This one is composed of FadeTo and ScaleTo animations, which allow us to play with the icon’s opacity and size, creating the blinking effect.

In code, it would look like the following:

protected override void OnAppearing() 
{ 
    base.OnAppearing(); 
    _running = true; 
    _ = BlinkLoop(); 
} 
async Task BlinkLoop() 
{

    while (_running) 
    { 
    await Task.WhenAll( 
    Heart.FadeTo(0.35, 220, Easing.CubicInOut), 
    Heart.ScaleTo(0.95, 220, Easing.CubicInOut) 
    ); 
    
    await Task.WhenAll( 
    Heart.FadeTo(1, 220, Easing.CubicInOut), 
    Heart.ScaleTo(1, 220, Easing.CubicInOut) 
    ); 
    } 
}

All set! Ready to move on to the next animation ✨

4. Rotating Heart

Rotate Heart

Now we’ll create an animation where our heart rotates. ❤️ This type of animation is very useful, for example, as a loading indicator in your screens.

To get started with the implementation, we’ll begin by adding the Image in XAML, as shown below:

<Image x:Name="Heart" 
    Source="redheart.png" 
    WidthRequest="64" 
    HeightRequest="64" 
    HorizontalOptions="Center" 
    VerticalOptions="Center" />

And in the code-behind, it’s time to bring the heart to life! ❤️

We’ll use the OnAppearing method, and for the animation (✍️ please make sure to declare the _isRunning bool variable), we’ll rely on RotateTo(), as shown below:

protected override async void OnAppearing() 
{ 
    base.OnAppearing(); 
    _isRunning = true; 
    
    while (_isRunning) 
    { 
    await Heart.RotateTo(360, 4000, Easing.Linear); 
    Heart.Rotation = 0; 
    } 
}

Done! Let’s bring the next animation to life ✨

5. Jumping Heart

Heart Jumping

For our final animation, we’ll make the heart jump up and down in a continuous loop.

This animation also works great as a loading indicator, adding a playful touch to your screen.

Let’s start by adding the Image to the XAML:

<Image x:Name="Heart" 
    Source="redheart.png" 
    WidthRequest="64" 
    HeightRequest="64" 
    HorizontalOptions="Center" 
    VerticalOptions="Center" />

In the code-behind, we’ll create the animation by working with TranslationTo and the TranslationY methods, as shown below:

protected override async void OnAppearing() 
{ 
    base.OnAppearing(); 
    _isRunning = true; 
    Heart.TranslationY = -120;
 
    while (_isRunning)
    
    { 
    await Heart.TranslateTo(0, 0, 600, Easing.CubicOut); 
    await Heart.TranslateTo(0, -12, 120, Easing.CubicInOut); 
    await Heart.TranslateTo(0, 0, 120, Easing.CubicInOut); 
    await Heart.TranslateTo(0, -120, 450, Easing.CubicIn); 
    } 
}

And that’s all—thanks for building this with me!

Conclusion

And that’s it! We’ve successfully created five awesome, ready-to-use animations with .NET MAUI. Each one was designed to be easy to implement, demonstrating just how powerful even the most basic animations can be when used correctly.

I hope this article has inspired you and sparked new ideas for incorporating animations into your current and future .NET MAUI projects ✨

As always, if you have any questions or would like me to explore any of these animations in more detail, feel free to leave a comment — I’d be happy to help!

See you in the next article! ‍♀️

Read the whole story
alvinashcraft
2 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Azure Cosmos DB MCP Toolkit Is Now Generally Available — Bringing Your Database to AI Agents at Scale

1 Share

Since we introduced the Azure Cosmos DB MCP Toolkit at Ignite 2025 in preview, the response has been clear: developers want a straightforward way to connect AI agents to their production databases. Customers asked for stability, broader embedding provider support, and a smoother path from experimentation to production.

Today, we’re announcing the general availability of the Azure Cosmos DB MCP Toolkit (v1.1.2), now with deeper Microsoft Foundry integration, multi-provider embedding support, and the reliability improvements you asked for.

Azure Cosmos DB MCP Toolkit generally available

The Problem: Getting AI Agents to Talk to Your Data Is Harder Than It Should Be

Building an AI agent is one thing. Getting that agent to securely read, search, and reason over your actual production data is another challenge entirely.

Most teams face the same friction:

  • Custom integration code for every agent-to-database connection
  • Security concerns around giving LLMs direct database access
  • Embedding lock-in to a single provider, making it hard to switch or optimize
  • Brittle scripts that break when configurations change or permissions shift

You end up spending more time wiring plumbing than building the intelligent experiences your users actually want.

What’s New in the GA Release

The v1.1.2 GA release focuses on three areas customers asked for most: flexibility, reliability, and developer experience.

Multi-Provider Embedding Support

Vector search is no longer locked to a single embedding provider. The toolkit now supports:

  • Azure AI Services (Cognitive Services endpoints)
  • Azure AI Foundry project endpoints
  • OpenAI native API

The system automatically detects your endpoint type based on URL pattern — no manual configuration flags needed. A new IEmbeddingClient abstraction layer means you can swap providers without changing your agent code.

         
    {    
      "OPENAI_ENDPOINT": "https://your-resource.cognitiveservices.azure.com/",    
      "OPENAI_API_KEY": "your-key",    
      "OPENAI_EMBEDDING_DEPLOYMENT": "text-embedding-ada-002"    
    }    

Whether you’re using Azure AI Services, a Foundry project endpoint, or OpenAI directly — the same configuration pattern works. The toolkit figures out the rest.

 

Whether you’re using Azure AI Services, a Foundry project endpoint, or OpenAI directly — the same configuration pattern works. The toolkit figures out the rest.

Improved Reliability and Error Handling

We heard the feedback on rough edges during preview. The GA release includes fixes for:

  • Role assignment scripts (Assign-Role-To-Users.ps1, Assign-Role-To-Current-User.ps1, Verify-Role-Assignments.ps1) now handle edge cases correctly
  • Structured error responses — Role-denied tool calls return a proper 403 JSON-RPC response instead of a 500 error
  • Foundry connection parameter handling works correctly when using project names
  • Startup validation rejects invalid endpoint configurations early with actionable guidance

Better MCP Transport and Compatibility

  • MCP HTTP transport is now properly registered for SDK endpoint mapping
  • External MCP clients connect reliably at /mcp
  • The web UI and SDK endpoints coexist without conflicts

Microsoft Foundry Integration

The MCP Toolkit integrates directly with Microsoft Foundry, giving your agents access to Cosmos DB in just a few clicks:

  1. Navigate to your Foundry project
  2. Go to Build → Create agent
  3. Select + Add in the tools section
  4. Select the Catalog tab
  5. Choose Azure Cosmos DB and click Create

That’s it. Your agent can now query databases, perform vector searches, and discover schemas — all through the standardized MCP protocol with enterprise-grade security (Entra ID, RBAC, managed identities).

 

What You Can Build

The toolkit exposes 8 MCP tools that cover the most common agent-to-database patterns:

 

Tool What It Does
list_databases Discover all databases in your account
list_collections Explore containers within a database
get_recent_documents Retrieve recent documents sorted by timestamp
find_document_by_id Look up specific documents by ID
text_search Search by property values using CONTAINS
vector_search Semantic search using vector embeddings
get_approximate_schema Sample and infer container schemas

 

Example: AI-Powered Support Agent

A support agent receives “What’s the status of order #12345?” and autonomously:

  1. Calls find_document_by_id to retrieve the order
  2. Reads shipping status and estimated delivery
  3. Responds with a personalized, accurate answer — no human lookup required

Example: Knowledge Base with RAG

A documentation agent uses vector_search to find semantically relevant articles, synthesizes answers from multiple sources, and cites specific documents — all backed by Cosmos DB’s global distribution and low latency.

Getting Started

# Clone the toolkit git clone https://github.com/AzureCosmosDB/MCPToolKit.git

# Configure your environment cp .env.example .env # Set your Cosmos DB connection, embedding endpoint, and auth settings

# Run the MCP server dotnet run For detailed setup including Entra ID authentication and managed identity configuration, see the Quick Start Guide.

If you’re setting up your development environment for Azure Cosmos DB, watch this session Azure Cosmos DB Dev Environment with AI | at Azure Cosmos DB Conf 2026 

The Bottom Line

The Azure Cosmos DB MCP Toolkit v1.1 is production-ready, open source, and designed to get out of your way. Swap between Azure AI Services, Azure AI Foundry, or OpenAI embeddings without touching your agent code. Add Cosmos DB tools to a Foundry agent straight from the catalog. Run it at scale with proper error handling, validated configurations, and enterprise-grade RBAC then extend it however you need.

If you’ve been waiting for GA to move forward — now’s the time. If you’ve been running the preview, upgrade to v1.1 for the multi-provider embedding support and stability fixes.

If you’ve been waiting for GA to move forward — now’s the time. If you’ve been running the preview, upgrade to v1.1 for stability fixes.

 

About Azure Cosmos DB

Azure Cosmos DB is a fully managed and serverless NoSQL and vector database for modern app development, including AI applications. With its SLA-backed speed and availability as well as instant dynamic scalability, it is ideal for real-time NoSQL and MongoDB applications that require high performance and distributed computing over massive volumes of NoSQL and vector data.

To stay in the loop on Azure Cosmos DB updates, follow us on XYouTube, and LinkedIn.  Join the discussion with other developers on the #nosql channel on the Microsoft Open Source Discord.

 

The post Azure Cosmos DB MCP Toolkit Is Now Generally Available — Bringing Your Database to AI Agents at Scale appeared first on Azure Cosmos DB Blog.

Read the whole story
alvinashcraft
4 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

MSSQL Extension for VS Code: Azure SQL Database Provisioning and More

1 Share

The MSSQL extension for VS Code v1.43 expands what’s possible inside Visual Studio Code with the General Availability of Schema Designer with GitHub Copilot, Data API builder, and SQL Notebooks. We’re also introducing the Public Preview of Azure SQL Database provisioning, giving developers a guided way to create Azure SQL databases directly from VS Code.

What’s new in MSSQL extension for VS Code v1.43

Here’s a summary of the key features in this release:

  • Azure SQL database Provisioning (Preview): Create Azure SQL databases directly from VS Code through a guided provisioning experience, with support for both local container and free-tier options.
  • Schema Designer with GitHub Copilot (GA): Design and evolve database schemas using natural language, visual change tracking, and migration-ready ORM script generation.
  • SQL Notebooks (GA): Build interactive, Jupyter-based SQL notebooks with multi-kernel support, rich results, and Markdown documentation.
  • Data API builder with GitHub Copilot (GA): Generate REST, GraphQL, and MCP endpoints from SQL databases with guided configuration, GitHub Copilot assistance, and column-level exposure controls.

Azure SQL database Provisioning (Preview)

The MSSQL extension for Visual Studio Code now introduces Azure SQL Database provisioning in public preview, starting with the free tier so you can create and connect to a fully managed cloud database directly from your editor at no cost.

With a guided wizard on the Deployments page, you authenticate with your Azure account, then configure your subscription, resource group, server, and database on a single page. Your connection is added automatically the moment provisioning completes. You never leave Visual Studio Code, and you don’t have to pay to get started. You choose what happens when the free monthly limit is reached: auto-pause until the next calendar month, or continue at standard serverless rates.

Whether you are prototyping a new application, validating a proof of concept, or experimenting with vector search and AI-ready workloads, you now have a fully managed Azure SQL Database ready to query in minutes. From there, you can continue into Schema Designer, where GitHub Copilot helps you design and evolve your data model visually. You can then go to data API builder, where GitHub Copilot generates back-end endpoints directly from your schema. Together, these experiences give you an end-to-end path from a provisioned database to a working back end, all inside Visual Studio Code.

Schema Designer with GitHub Copilot (GA)

Schema Designer with GitHub Copilot integration is now generally available in the MSSQL extension for Visual Studio Code, bringing AI-assisted schema design, visual change tracking, and ORM script generation into one workflow. Describe the schema changes you want, review Copilot-generated updates in the Change Tracking panel, and generate migration-ready ORM scripts from your visual design.

Key highlights

  • Natural language schema creation: Describe your schema in conversational prompts, and GitHub Copilot generates the tables, columns, data types, and relationships automatically, all reflected live in the visual diagram and T-SQL script.
  • Schema evolution: Modify existing schemas by asking GitHub Copilot to add columns, rename tables, change data types, or create new relationships. Each change is presented individually with Accept/Undo controls so you stay in full control.
  • ORM script generation: Generate migration-ready ORM scripts from visual schema changes, including Prisma, Sequelize, TypeORM, Drizzle, SQLAlchemy, and EF Core.
  • Change review with diff view: Before applying changes to your database, review a consolidated diff showing all pending modifications. Schema-qualified names (schema.table, schema.column) make it easy to understand exactly what will change.
  • Bootstrap from scratch: Start from an empty database and build a complete application schema using only natural language prompts, ideal for rapid prototyping and proof-of-concept work.
  • Import external artifacts: Feed JSON files, documents, or even images into the Schema Designer and let GitHub Copilot generate matching schema elements, accelerating migrations and reverse engineering workflows.
  • Validation and guardrails: GitHub Copilot flags potential issues like missing primary keys, invalid data types, and normalization concerns, helping you catch design problems early.

schema designer copilot sequelize example image For full documentation, see GitHub Copilot integration in Schema Designer.

SQL Notebooks (GA)

SQL Notebooks bring native Jupyter notebook support to the MSSQL extension for VS Code v1.41, combining interactive SQL query execution with Markdown documentation cells for reproducible analysis, runbook documentation, and educational content.

Screenshot 2026 03 18 at 2 22 37 AM image

Key highlights

  • Interactive SQL execution: Execute T-SQL queries cell by cell with inline results displayed in a rich data grid that supports sorting, filtering, null highlighting, and copy with headers.
  • Native .ipynb format: Notebooks use the standard Jupyter .ipynb format, making them portable and compatible with existing notebook tooling and version control workflows.
  • Markdown documentation: Combine SQL cells with Markdown cells to create self-documenting query collections, runbooks, and tutorials.
  • IntelliSense support: Get table and column suggestions from your active database connection as you write SQL, bringing the same productivity features you expect from the query editor.
  • Database context switching: Connect each notebook to a SQL Server instance and switch between databases on the same server without reconnecting.
  • Multi-kernel support: Install complementary extensions like the Jupyter extension to unlock additional kernels such as Python, enabling you to combine SQL and Python cells in the same notebook for end-to-end data workflows.

Screenshot 2026 03 18 at 2 22 45 AM image

For full documentation, see SQL Notebooks.

Data API builder with GitHub Copilot Integration (GA)

Data API builder with GitHub Copilot integration is now generally available in the MSSQL extension for Visual Studio Code, helping you generate REST, GraphQL, and MCP endpoints from your SQL database schema. This release adds column-level configuration, so you can choose exactly which columns are exposed in the generated API while using GitHub Copilot to help plan and update your configuration.

Key highlights

  • Column-level configuration: Select tables or columns from your database, organized by schema, and configure CRUD permissions (Create, Read, Update, Delete) independently for each entity with granular role-based access control.
  • Multiple API types: Choose REST, GraphQL, MCP, or any combination. Data API builder generates the appropriate endpoints and configuration automatically.
  • Configuration preview: Review the generated Data API builder configuration file (JSON) in a read-only Definition panel before deploying, ensuring full transparency into what will be created.
  • One-click Docker deployment: Deploy your API as a local Docker container with an automated prerequisite check wizard that validates Docker availability, pulls the Data API builder image, and starts the container.
  • Built-in API testing: Once your API is running, open the Swagger UI (REST) or Nitro GraphQL playground endpoints directly in the VS Code Simple Browser, so you can validate your APIs without ever leaving the editor.
  • GitHub Copilot chat integration: Use natural language in GitHub Copilot chat to configure entities, set permissions, and generate Data API builder configurations. Ask questions like “Add all HR tables with read-only access” and GitHub Copilot handles the rest.

For full documentation, see Data API builder

Conclusion

The MSSQL extension for VS Code v1.41 introduces Schema Designer with GitHub Copilot, Data API builder, SQL Notebooks, Edit Data (GA), Data-tier Application (GA), Fabric integration (GA), and SQL Database Projects static code analysis (GA): seven major updates that bring AI-powered schema design, instant API generation, interactive notebooks, and enterprise-grade tooling to your SQL development workflow. Together, these capabilities make the MSSQL extension more powerful, more integrated, and more developer-friendly than ever.

If there’s something you’d love to see in a future update, here’s how you can contribute:

  • 💬 GitHub discussions – Share your ideas and suggestions to improve the extension
  • ✨ New feature requests – Request missing capabilities and help shape future updates
  • 🐞 Report bugs – Help us track down and fix issues to make the extension more reliable

Want to see these features in action?

Thanks for being part of the journey—happy coding! 🚀

The post MSSQL Extension for VS Code: Azure SQL Database Provisioning and More appeared first on Azure SQL Dev Corner.

Read the whole story
alvinashcraft
5 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Daily Reading List – June 2, 2026 (#796)

1 Share

Just wrapped up the day in Stockholm with more fun customer chats, and some rehearsals for the big event here tomorrow. And after a five hour dinner with people, my social battery is sub-zero.

[blog] State of SDLC Security 2026. The Wiz team shared a few data points in this blog post and links to a downloadable report.

[article] Coders are refusing to work without AI — and that could come back to bite them. It could. But I’d also refuse (a few years ago) to code without an IDE, or ask for anything but a cloud server. We get used to things that help us!

[blog] How we used Gemini to build Google I/O 2026. Creative teams everywhere should be using these tools. Apply your own ideas and produce output that would’ve seemed impossible just a year ago.

[blog] The Go language server can do some impressive code navigation. Some geeky love here for some thoughtful things we added for users of our language server.

[article] The DIY platform trap that’s burning out engineering teams. It’s the build versus buy debate. Building your own platform has benefits, and risks. I think the typical rule holds that you should only build differentiators.

[blog] Introducing the GKE standby buffer: Improve node startup times without blowing your budget. Over-provision to be safe, or endure a slow auto-scaling when the burst comes? There’s now a third option for Kubernetes users.

[blog] Why is test-driven development with agents so helpful for security? Aron shares some good thinking here. Can TDD be a security and stability gate for your AI coding agent?

[blog] Iterating on Frontend Design with Stitch and Antigravity CLI. This is the biggest change that AI has made for me. All of a sudden, I can work on parts of the stack (like the frontend) that were inaccessible to me before.

[article] Get a Good Return on Your AI Investments. We have plenty of anecdotal feedback about AI in software teams, but Nathen brings receipts.

[blog] Developer’s guide to Gemini Enterprise and A2UI integration. Instead of getting walls of text back from your AI chat tool, what if you could get rich, dynamic UIs composed on the fly? You can. Here’s how.

Want to get this update sent to you every day? Subscribe to my RSS feed or subscribe via email below:



Read the whole story
alvinashcraft
5 minutes ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories