Whether your team hosts its own AI models, you have an API key from a model provider, or you want to experiment with a model running on your machine, Bring Your Own Model (BYOM) lets you use those models without leaving Visual Studio.

BYOM is now generally available in Visual Studio 18.12. Since the August Preview, your feedback has shaped improvements for team deployments, enterprise networks, and personal projects. This release brings multiple configurations for the same provider, a dedicated custom-endpoint experience that includes local models, more control over API compatibility, and improved proxy support.

No GitHub sign-in is required. If you can’t access GitHub, you can still use your chosen models in Visual Studio—including local or internally hosted models in air-gapped environments—provided the model endpoint is reachable and its authentication requirements are met.

More than one connection to the same provider

Your work doesn’t always fit into a single provider configuration. You might use one account for personal projects and another for work, connect to separate Microsoft Foundry resources, or keep an experimental deployment alongside your team’s approved endpoint.

You can now keep multiple configurations for the same provider and give them meaningful names, such as “Work” and “Personal.” Each keeps its own connection details and models, so you can choose the right setup without removing and re-adding a provider.

A clearer path to custom endpoints

Many developers don’t connect directly to a model vendor’s public endpoint. You might use a self-hosted inference server, an AI gateway, or an endpoint provided by your organization.

The new Custom Endpoint provider gives OpenAI-compatible services, including OpenRouter, their own place in provider configuration. Enter your endpoint URL and an API key if required. Where the endpoint provides a compatible model listing, Visual Studio can surface the models it returns.

You can also connect to local models served by LM Studio. Start the local server, then add its OpenAI-compatible URL using Custom Endpoint to use your model in Visual Studio’s Agent Mode.

Match the API to your model

When adding a custom model, you can now select the API format supported by your provider: OpenAI-compatible Completions or Responses, or Anthropic-compatible Messages. You can also view and change the configured format in Manage models

You can also configure context size, maximum output, tool calling, and vision support to match your model and deployment.

Better suited to enterprise environments

For organizations, model choice needs to work with existing network settings and policies.

We’ve improved proxy support so provider connections and Agent Mode both use Visual Studio’s resolved proxy configuration.

Administrators can enable or disable BYOM through organizational policy.

Getting Started

Try BYOM in Visual Studio:

1. Install Visual Studio 18.12 GA.
2. Open Chat and use the model picker to choose Manage models.
3. Choose Add model provider, then select Microsoft Foundry, OpenAI, Anthropic, Ollama, or Custom Endpoint.
4. Configure the connection, give it a meaningful name, and add the models you want to use.
5. Select your model and start working in Agent Mode.

Note: If you don’t see Add model provider, your organization’s administrator may have disabled bring-your-own-model access.

Keep shaping what comes next

We’re continuing to learn from the models, deployments, and environments you use. Tell us what’s working, where setup still gets in your way, and what would make BYOM more useful through the Developer Community forum or our short survey.

Your feedback is helping shape what comes next. Happy coding!

The post Bring Your Own Model is now generally available in Visual Studio appeared first on Visual Studio Blog.

Clinical research rarely ends with the questions defined in a trial protocol. Medical experts also explore the data from new angles: testing a hypothesis, comparing patient populations, visualizing a trend, or identifying a promising direction for further research. 

As part of a forward-deployed engineering engagement, a joint Microsoft and Novo Nordisk development team built an agent that helps medical experts perform this kind of secondary analysis of clinical trial data.  We described the original project in a Microsoft customer story. More recently, we reimplemented the solution as a hosted agent in Microsoft Foundry. 

The move gave us a simpler operating model, stronger session isolation, and a direct path into Foundry’s tracing, evaluation, experimentation, optimization, and governance capabilities. It also taught us practical lessons about infrastructure planning, observability, and preserving the learning loop that already made the agent better over time. 

Here’s what changed, what we measured, and what we would recommend to teams making a similar move. 

An agent for questions that don’t have a fixed workflow 

Secondary analysis of clinical data is a great task for an agent because the execution path depends heavily on the question. The agent interprets the request, inspects the available data, writes and executes analysis code, examines the result, and often revises its approach before returning a summary and visualization.

This isn’t just attaching a chat interface to a single API. The agent needs a reasoning loop, access to domain-specific skills, and tools for working with data. In our implementation, code execution is the central tool. The agent can generate analysis code and visualizations inside a controlled environment while the surrounding application manages the conversation and presents the result to the user. 

Our first production architecture ran the agent in Azure Container Apps. We used PostgreSQL for conversation storage and Azure Container Apps dynamic sessions for sandboxed code execution. That architecture gave us explicit control over every component, and it proved the value of the use case. 

It also meant that our team owned much of the platform around the agent: container scaling, session lifecycle, conversation persistence, execution isolation, networking, telemetry, and the integration among them. Foundry hosted agents offered a simpler division of responsibility. 

Moving the runtime boundary into Foundry 

A hosted agent is our code, packaged as a container, running on infrastructure managed by Foundry Agent Service. We retain control of the orchestration logic, models, tools, and runtime behavior. Foundry manages the endpoint, agent identity, session compute, state persistence, scaling, and lifecycle around it. 

At runtime, each session gets its own VM-isolated sandbox. Foundry provisions compute on demand, keeps it active while the session is in use, and de-provisions it after the configured idle period. Session files can persist and be restored when the session resumes. Scaling follows active sessions rather than a replica count that we have to predict and configure. 

For Novo’s workload, that model aligned well with the unit of work we were building for: one expert conducting one analysis session. It also changed the architecture in four important ways: 

1. Scaling became session-native. We no longer needed to connect application-level session creation to a separately scaled pool of execution environments. The platform owns that lifecycle.
2. Isolation became the default unit of execution. Each session runs in a VM-isolated sandbox rather than sharing a process or general-purpose application container with other sessions. That matters when the workload includes model-generated code operating on sensitive clinical data.
3. Network isolation became part of the service architecture. Foundry Agent Service supports private networking, including virtual network integration and private access to dependent Azure resources. This lets us design controls for both ingress and egress around the agent environment. Those controls are especially important for data that must remain inside an approved network boundary.
4. The agent joined a broader development lifecycle. Traces, evaluations, experiments, monitoring, and optimization can now be connected through the same platform. Microsoft Agent 365 integration also provides a path to enterprise inventory, identity, access control, and lifecycle governance.

Using Foundry hosted agents didn’tt remove our responsibility for security or quality. We still had to define access controls, minimize and protect telemetry, test the agent for our use case, and review every system it can call. What changed is that several controls we previously assembled ourselves are now platform capabilities we can configure and operate consistently. 

Lessons learned 

Here are the top lessons we learned during this project—and some practical advice for your own hosted agents projects in Foundry: 

Lesson 1: Treat infrastructure choices as product decisions 

Private networking should be an early architecture decision, not a production hardening task left until the end. 

Hosted agents consume network capacity according to sessions. The Foundry account, its projects, hosted agents, concurrent sessions, and agent revisions all contribute to IP usage. Because the assigned subnet is an immutable reference at the account level, an undersized range can turn a capacity adjustment into a broader infrastructure migration. 

Our advice is to estimate peak concurrent sessions across the account, include headroom for deployments and growth, and involve the network team before creating the Foundry resource. The current networking guidance recommends a /24 subnet for production hosted agent deployments and documents /27 as the supported minimum for smaller deployments. 

We used Azure Verified Modules as the foundation for repeatable environments. That gave us a strong starting point, but infrastructure as code doesn’t remove the need to inspect generated dependencies. Throughput for resources like Azure Cosmos DB should reflect expected concurrency and data access patterns. Where a setting requires an operational adjustment, capture it in the deployment process or operator runbook rather than leaving it as unwritten production knowledge. 

Subnet sizing, database throughput, private endpoints, DNS, and concurrency aren’t separate infrastructure details. Together, they shape the scale ceiling and reliability of the product. 

Lesson 2: Make traces easy to navigate 

Foundry tracing uses OpenTelemetry and stores telemetry in Azure Monitor Application Insights. It can capture user inputs, agent outputs, model calls, tool activity, token usage, and latency. That gives us the raw material to understand both reliability and agent behavior. 

During the migration, we sent agent traces to both Application Insights and Langfuse. Keeping the existing telemetry path available gave the team continuity while we connected the agent to Foundry’s observability capabilities. 

An engineer needs to move quickly from a reported problem to the relevant interaction: what the user asked, what the agent returned, how many operations the run produced, how long it took, and how many tokens it consumed. Stable user, session, conversation, agent-version, and trace identifiers make those views searchable and connect activity across the frontend, backend, agent, and tools. 

Be equally deliberate about what not to record. Foundry’s tracing guidance notes that traces can include prompts, outputs, tool arguments, and tool results. For clinical workloads, telemetry needs the same access control, minimization, redaction, and retention discipline as other sensitive production data. 

Lesson 3: Preserve the learning loop during migration 

We kept the backend contracts stable, which made the migration significantly easier. Our evaluation framework could call the Foundry-hosted implementation through the same interface it used before, so moving the runtime didn’t require us to rebuild the quality system around it. 

We could continue to run the same evaluation set against the agent and apply the same graders to its output. Those graders included comparisons with golden answers supplied by subject matter experts. The resulting scores gave us a baseline for the migration, guarded against regressions, and pointed to areas where changes to instructions, tools, or orchestration improved the system. 

This is where the broader Foundry lifecycle becomes especially useful. Traces explain what happened in a run. Evaluations measure the result. Experiments compare alternatives. Optimization turns that evidence into candidate improvements. Bringing those capabilities closer together creates a shorter path from a production observation to a tested change.

CONTINUOUS LEARNING LOOP 

The takeaway 

Our original architecture gave Novo a working agent for a valuable and demanding research scenario. Moving it to hosted agents let us keep control of the agent logic while transferring more of the undifferentiated runtime work to Foundry. The result is not only a different place to run a container. It’s a cleaner platform boundary: isolated compute per session, managed scaling and identity, private networking, durable state, and an integrated path from tracing to evaluation and optimization. 

For teams deciding how to take an agent from prototype to production, that boundary is worth evaluating early. Build the part that makes your agent distinct. Let the platform carry more of what every production agent needs.

The post From custom infrastructure to hosted agents appeared first on Command Line.

.NET 11 is here and Syncfusion Essential Studio is ready

.NET 11 is now generally available, bringing updates across the .NET runtime, C# 15, ASP.NET Core and Blazor, .NET MAUI, Windows development, libraries, tooling, and AI development.

For teams maintaining production applications, however, a new .NET release brings an immediate practical question:

Are the UI components and document-processing libraries our applications depend on ready for the new runtime?

With day-one .NET 11 support, Syncfusion® Essential Studio enables developers to begin evaluating the new release without waiting for a later compatibility update across supported Syncfusion platforms.

That includes applications built with:

• .NET MAUI
• Blazor
• WPF
• WinForms
• WinUI
• Syncfusion Document SDK libraries

Upgrading a production application still requires testing your own dependencies, application scenarios, deployment environment, and Microsoft’s .NET 11 breaking changes. Day-one support means the Syncfusion compatibility layer is available when you begin that evaluation.

Let’s look at what .NET 11 support means for Syncfusion developers, the framework changes worth knowing about, and the steps to consider when upgrading.

Syncfusion .NET 11 support at a glance

If your application uses more than one Syncfusion package or platform dependency, update the related packages together and validate the complete application before deploying the .NET 11 build to production.

What day-one .NET 11 support means for developers

Framework compatibility involves more than changing the target framework and rebuilding.

A .NET application can depend on UI components, document libraries, third-party packages, native dependencies, publishing modes, operating-system capabilities, and application-specific requirements.

When evaluating .NET 11, consider the complete application.

Update supported packages

Use Syncfusion NuGet package versions that support .NET 11 and keep related Syncfusion packages aligned.

Review .NET 11 breaking changes

Review Microsoft’s compatibility and breaking changes documentation for the frameworks and APIs your application uses.

Test platform-specific behavior

Validate behavior that matters to your application, such as:

• Data loading and editing.
• Filtering and sorting.
• Virtualization.
• Charts and visualization.
• Forms and validation.
• Scheduling.
• Themes and styling.
• Printing and export.
• Document generation and conversion.

Retest business-critical scenarios

A successful build does not confirm that every application scenario behaves exactly as it did previously.

Run your application’s unit, integration, UI, regression, and performance tests against representative workloads before production deployment.

.NET 11 highlights that matter for Syncfusion developers

.NET 11 includes a large number of changes across the ecosystem.

Rather than reproducing the complete .NET 11 release notes, here are some of the changes particularly relevant to developers building UI-heavy and enterprise applications with Syncfusion.

.NET MAUI: CoreCLR, XAML, and developer productivity

One of the most significant changes in .NET 11 for .NET MAUI is the move to CoreCLR as the default runtime across supported MAUI platforms.

For developers, this brings the MAUI runtime closer to the broader .NET ecosystem and contributes to improvements in areas such as debugging, profiling, performance, and development experience.

.NET 11 also continues improving the XAML development experience.

Highlights include:

• Improvements to XAML source generation.
• Better binding diagnostics.
• Lazy ResourceDictionary loading.
• XAML Incremental Hot Reload improvements.
• Improvements for compiled bindings.
• Additional controls and platform capabilities.
• Testing and accessibility improvements.

The framework also includes enhancements to maps, animations, CollectionView behavior, and native platform experiences.

What this means for Syncfusion .NET MAUI developers

Syncfusion .NET MAUI controls support .NET 11, so existing applications can evaluate the new runtime while continuing to use controls such as DataGrid, Scheduler, Charts, and other Syncfusion UI components.

When upgrading, test the scenarios most important to your application.

For example:

• DataGrid grouping, filtering, editing, and virtualization.
• Scheduler navigation and interactions.
• Chart rendering and updates.
• Large datasets.
• Device-specific layouts.
• Application startup and navigation.
• Existing XAML and binding behavior.

Blazor: Better forms, virtualization, and agentic UI experiences

.NET 11 adds several capabilities to Blazor and ASP.NET Core that are relevant to data-driven enterprise applications.

Improved form validation

Blazor static server-side rendering forms gain improved client-side and asynchronous validation capabilities.

For applications with complex forms, this makes it easier to provide immediate validation while supporting rules that depend on remote APIs or other asynchronous operations.

Better virtualization

The Virtualize component receives improvements for items with different heights and adds capabilities for controlling scrolling and viewport behavior.

These improvements can be useful in interfaces such as:

• Chat experiences.
• Activity feeds.
• Logs.
• Large dynamic lists.

Static SSR improvements

.NET 11 expands static SSR capabilities, including improvements around caching, session-related scenarios, and state management.

Agentic UI development

.NET 11 also advances the AI application story for Blazor.

Microsoft is introducing experimental capabilities for building richer agentic interfaces, including scenarios where applications can stream AI output, render tool interactions, manage approvals, and coordinate UI state with AI agents.

For Syncfusion Blazor developers, this expands the range of AI-driven application experiences that can be explored alongside existing Syncfusion UI components.

What this means for Syncfusion Blazor developers

Syncfusion Blazor components support .NET 11.

For applications using DataGrid, Scheduler, Charts, forms, dashboards, or other interactive components, validate:

• Data binding.
• Sorting and filtering.
• Virtualization.
• Form validation.
• Interactive render modes.
• Export operations.
• Authentication-related behavior.
• Server and WebAssembly deployment scenarios used by your application.

Desktop development: WPF, WinForms, and WinUI

.NET 11 also brings runtime, library, tooling, and Windows-development improvements relevant to desktop applications.

Runtime and JIT improvements

The .NET 11 runtime includes optimizations across JIT compilation, asynchronous operations, code generation, and core libraries.

These improvements can benefit applicable workloads, although the impact depends on the code paths and application.

Runtime Async

.NET 11 includes Runtime Async as a preview feature.

Runtime Async moves more of the mechanics behind asynchronous execution into the runtime, with goals including lower overhead and cleaner async stack traces.

Because it remains a preview capability, evaluate it separately before considering it for production application code.

WinForms improvements

.NET 11 includes improvements for Windows Forms across areas such as:

• Visual styling.
• Full-screen and kiosk scenarios.
• System visual settings.
• Startup behavior.
• Rendering and layout.
• Input handling.

WPF improvements

WPF receives reliability and rendering updates across several desktop scenarios.

Syncfusion desktop controls

Syncfusion WPF, WinForms, and WinUI controls support .NET 11.

When upgrading a desktop application, validate scenarios such as:

• DataGrid rendering and editing.
• Chart updates.
• Theming.
• High-DPI behavior.
• Keyboard and pointer interaction.
• Printing.
• Export.
• Document viewing.
• Window and layout behavior.

C# 15 comes with .NET 11

C# 15 is the default language version for projects targeting .NET 11.

It introduces new language capabilities including:

• Collection expression arguments.
• Union types.
• Closed hierarchies.
• Extension indexers.
• Labeled break and continue.
• Additional memory-safety work.

These language features are independent of Syncfusion components, but developers can use supported C# 15 capabilities alongside Syncfusion applications targeting .NET 11.

As with any new language feature, evaluate whether it improves the clarity and maintainability of the specific application rather than adopting it simply because it is new.

Syncfusion Document SDK libraries on .NET 11

Syncfusion Document SDK libraries also support .NET 11.

This means document-processing applications can evaluate the new runtime while continuing to use Syncfusion libraries for document-processing tasks involving formats such as PDF, Word, Excel, and PowerPoint.

.NET 11 includes runtime and library optimizations that may benefit some document-processing workloads.

However, a newer runtime does not guarantee that every document operation becomes faster.

The performance difference depends on factors including:

• The document operation.
• Input-file size and complexity.
• Memory allocation behavior.
• Runtime execution paths.
• Application concurrency.
• Publishing configuration.
• Hardware.
• Syncfusion package version.

Our internal validation showed lower execution times in several selected Document SDK operations on .NET 11, while some operations showed little or no difference compared with .NET 10.

The important takeaway is not that every operation receives the same improvement.

If document-processing performance matters to your application, benchmark your own representative files and workloads on both runtimes before making performance assumptions.

How to upgrade a Syncfusion application to .NET 11

The exact upgrade process depends on your application platform, but this provides a practical starting point.

1. Install the .NET 11 SDK and compatible development tools

Install the final .NET 11 SDK and ensure that your development and CI environments use compatible tooling.

Verify the installed SDKs with:

dotnet --list-sdks

Avoid mixing preview and final SDK versions between developer machines and CI unless that configuration is intentional.

2. Update the target framework

Update the project’s target framework to the appropriate .NET 11 target framework moniker for your application type.

For a standard .NET application, for example:

<TargetFramework>net11.0</TargetFramework>

Windows desktop and .NET MAUI projects use the corresponding platform-specific target frameworks.

Follow Microsoft’s platform documentation for the exact TFM required by your application.

3. Update Syncfusion packages

Update to Syncfusion package versions that support .NET 11.

For applications using multiple Syncfusion packages, keep compatible package versions aligned instead of updating individual dependencies in isolation.

4. Restore packages and workloads

Restore the application dependencies and any required platform workloads.

dotnet restore

For platforms such as .NET MAUI, make sure the corresponding .NET 11 workloads are installed and up to date.

5. Review breaking changes

Check Microsoft’s .NET 11 compatibility documentation for changes relevant to:

• Runtime behavior.
• ASP.NET Core.
• .NET MAUI.
• WPF.
• WinForms.
• Libraries.
• SDK and tooling.

Also review application-specific third-party dependencies before upgrading production projects.

6. Build the application

Perform a clean build and resolve any compilation, package, workload, or analyzer issues.

7. Run regression tests

Test the application scenarios your users actually depend on.

Do not treat a successful build as the end of the upgrade validation.

What should you test before moving to production?

The validation checklist depends on the platform.

.NET MAUI

Test:

• Startup.
• Navigation.
• DataGrid behavior.
• Charts.
• Scheduler.
• XAML bindings.
• Large datasets.
• Device-specific layouts.
• Android, iOS, Windows, and macOS scenarios your application supports.

Blazor

Test:

• Server and WebAssembly scenarios you use.
• Forms and validation.
• Data loading.
• Virtualization.
• Authentication.
• Grid operations.
• Export.
• Interactive components.
• Reconnection and server-state behavior where applicable.

WPF, WinForms, and WinUI

Test:

• Rendering.
• Editing.
• Themes.
• High-DPI displays.
• Accessibility.
• Printing.
• Export.
• Keyboard and pointer input.
• Window behavior.

Document SDK

Test representative:

• PDF operations.
• Word conversions.
• Excel imports and exports.
• PowerPoint operations.
• Large files.
• Concurrent processing.
• Memory consumption.
• Production deployment configuration.

Whenever performance is important, measure the application using the files, hardware, concurrency, and deployment model that reflect your actual production workload.

Should you move to .NET 11 immediately?

.NET 11 is a Standard Term Support (STS) release.

Whether you should upgrade immediately depends on your organization’s requirements.

.NET 11 may be a good fit when you want:

• Access to the latest framework and runtime capabilities.
• The newest .NET MAUI and Blazor improvements.
• C# 15.
• Current AI and agentic development capabilities.
• The latest runtime and tooling improvements.

Organizations that prioritize a longer support window may decide to remain on a supported LTS release depending on their lifecycle requirements.

The important point is that Syncfusion’s .NET 11 support lets you make that decision based on your application strategy rather than waiting for component compatibility.

Get started with Syncfusion and .NET 11

.NET 11 brings updates across runtime performance, developer tooling, C# 15, .NET MAUI, Blazor, desktop development, core libraries, and AI application development.

With day-one .NET 11 support across Syncfusion Essential Studio UI components and Document SDK libraries, developers can begin evaluating these capabilities within their existing Syncfusion development environments.

If you’re planning an upgrade:

• Install the final .NET 11 SDK.
• Update to the Syncfusion packages that support .NET 11.
• Retarget the application.
• Review breaking changes.
• Build and test representative workloads.
• Validate production-critical behavior before deployment.

Explore the latest Syncfusion Essential Studio release from your Syncfusion license and download page.

If you have questions while upgrading, use the Syncfusion support forum, support portal, or feedback portal.

How SQL Server People Can Stay Relevant With AI

Chapters

• 00:00:00 – Introduction
• 00:02:28 – Query Plan Analyzer Tool
• 00:04:55 – Robot Setup and Automation
• 00:07:20 – Idea Implementation and Execution
• 00:09:24 – Conclusion

Full Transcript

Erik Darling here with Darling Data. And in today’s video, we are not going to talk directly about SQL Server. We are going to talk about how to stay relevant in the age of AI, right? All the AI stuff going on.

Even, I mean, I think that’s, it’s obviously a stupid term. We all know that they’re LLMs, right? We all know it’s not artificial intelligence. It’s just random word generators. We just happen to, you know, be pretty, pretty decent at coding sometimes and whatnot.

Um, and I got some stuff to say about that. Uh, down in the video description, uh, you’ll find all sorts of helpful links. You can hire me for consulting, buy my training, uh, at a discount.

It’s coupons down there and everything, because I care about your financial stability. Uh, you can become a supporting member of the channel. Uh, ask me office hours questions and, you know, the usual, like, subscribe, tell a friend, tell your mom, tell your dad.

Tell your auntie Debbie the works. Uh, if you would like free SQL Server performance monitoring courtesy of, uh, well, you know, my, my robots building this stuff. Uh, cause I, I could never do this on my own.

It’s big and crazy and codey. Uh, I’m a database idiot. I can, I don’t build this stuff. Uh, I just direct the, I just direct the show, right? It’s up here using my, my, my inherent product manager intuition, right?

To build good things and good features, uh, that help you. Uh, and they helped me too. Cause I still, you know, use it to look at things for people.

It’s good. Uh, but totally free, totally open source. You don’t have to pay me anything. You don’t, there’s no email signup, no phone home, none of that stuff. Uh, just get on in there, have a good time, monitor your SQL servers and get answers, right?

Uh, cause they, they, you, you can have your robots talk to the performance data via MCP tools, right? Read only, no ad hoc SQL. Just say what’s going on here, robot.

Depending on the robot you’re using, don’t use co-pilot. Yeah, you might get some okay answers. Uh, I will be in pass, I will be at pass summit west in Seattle. Uh, you come so close to flawless some days and, uh, one preposition.

I will be about Seattle, around pass summit west. Uh, November 9th through 11th. I have a pre-con there.

Uh, advanced T-SQL that doesn’t suck. I can teach you how to argue better with the robots, right? I can teach you robot law. Uh, and I have a regular session there about isolation levels where I’ll be, trying to convince you one last time, uh, that read committed is awful because it is.

But anyway, there’s one extra slide on this thing today. Uh, and the reason why this slide is here is because I am an old man. And as an old man, I have, I have an RSS reader on my phone.

And as an old man, I often look at my RSS feed. And I have a little folder on there. I use, I use Feedly for what it’s worth. Um, it’s, it’s okay.

Uh, I feel like the log out button is a little too easy to hit, but aside from that, it’s okay. Uh, and I, and I look at my SQL Server feed and it is 75% garbage, right? Um, you, you can tell just by the post title.

And, and I, and I know, right. Cause, uh, uh, I mean, there are just obvious tells you can, you look at the title of the post and you’re like, wow, this is going to be a joyless, jargon filled, uh, just no fun ride. That the, the, the, the person who published this had nothing to do with, right?

They, they didn’t write it. They probably didn’t look at it. The, they’re just plopping it out there for like, like content. There’s the wrong way to use AI, right?

And no one, no one wants to read it. No one is attracted to that, right? No one cares about this. Uh, it is not 2023 where that is a novel way to use, uh, artificial, uh, LLMs or artificial intelligence, not quite super intelligence yet, but that, that is, that is not the way to do it. Um, no one, no one needs to read about SQL Server is written by a robot on whatever training data or whatever, whatever random idea you had.

That’s old retreaded material. It’s not, it’s not the way to do it. Right.

And it’s, it’s sad to watch these people just continue to flounder with these awful posts over and over again. Uh, you do it by building things for people, right? Build helpful tools, right?

Because that is, that is what you can do now, right? Just writing blog content. You, you, if, if you already have a blog that I follow, that means that you were already a blogger. You were already writing things that I wanted to read.

You don’t need AI to do that. You can do all sorts of crazy things with it. You just never dreamed of. Right.

Uh, teach people how you use it to do your job. Right. Um, I have, I have a, a, a Claude plugins folder in my GitHub repo and I’m going to be building that out. Uh, it’s got stuff in there that helps people use these tools that everyone is pretty much.

If you’re doing this stuff, like if you’re not taking advantage of these things, you’re kind of dumb. Uh, and you know, like I’m trying to help people use them better for the SQL Server stuff that I know well. Right.

And so then that Claude plugins folder, there’s all sorts of ways to help Claude get a little, be a little bit better at SQL Server stuff, query plans and analysis and all that. Uh, I’m building, I have a monitoring tool that I’m building. Right.

Uh, for free. So people can monitor SQL Server for free and get good quality monitoring without paying some idiots $3,000 a server to, to the privilege of an ugly dashboard. Right.

Uh, I’ve got a plan analyzer tool that helps you just stick a query plan in there and gives you all the stuff that I would say about a query plan right in front of you. Right. Helpful things for people.

Right. Things that like I could never do on my own. Right. Uh, other stuff that I do with it is, you know, uh, I, I, like what I want to add in there soon is like how to set up, uh, your robots. So that not only can they like, you know, bit like, like, like do stuff, but they can like talk to SQL Server and try things out.

Otherwise, you know, one of the big problems that you hear about, you know, is like, of course, hallucinations. The query was wrong. Oh, all this stuff.

Yeah. Half of it is because if like, if you blindfolded a person, right. Or if you ask the average person to write like a DMV query off the top of their head, they probably would screw it up too. Right.

So, uh, and then, but you know, like a person you’ll be like, oh, it’s okay. We’re on it. I see that column names wrong. Uh, then they’d be like, oh, but look, IntelliSense got the right one. And there we go.

Now it’s working. Right. So like, like, like what the robots do go the extra mile and do the thing so that if they make a mistake, they can just correct themselves. It’s not that hard.

Right. Like everyone gets stuff wrong. You just need to get them a little bit more in there. Um, but the, the, the big thing is that you see just a complete lack of ambition, uh, with the, the way that a lot of people are using these tools. Right.

There is no, uh, like get out there and like lock stuff down. And like, all like any idea that you have in your head becomes a thing almost instantly. Right.

It’s like a grand, it’s not like free, but it’s a lot more free than how, like what you would have had to do before to make an idea a thing. So don’t be timid with it. Right.

If you have an idea, get it out there. Right. It doesn’t have to be perfect at first. It doesn’t have to be everything at first. Just get something out there and working. Uh, you know, like, like, like every time that I’ve tried to use it. Uh, any LLM out there, uh, even when like, I, you know, I, I, I give it access to my entire blog.

It’s like, this is me. This is how I write. This is my voice.

Uh, it, it can’t, it can’t, they don’t get it right. Right. Like they, you know, like there’s an approximation in there, but it’s always like, uh, but that’s just like, it’s the, it’s the wrong way to do it. Everyone knows when you, when you didn’t write something yourself, uh, it’s just, it’s just too obvious.

And like, you know, it’s like build cool stuff that, and like, you know, put yourself around it. Uh, you know, like Brent has a bunch of posts that he used Claude to make animations, but it’s still Brent around all those animations. It’s not him just saying, Hey, Claude, go make a picture and write the post for me.

And then bang publish. Right. Like that’s what you do. Like all the stuff that would be a nightmare for you to do on your own. Right.

You have to go get a graphic art degree and learn like some Adobe product to do that stuff. You don’t have to anymore. These are, these are the, these are the, these are the things that people should be filling in the blanks with. Right.

It’s, it’s not having AI impersonate you in the world. That is a sad, sad state of affairs. Anyway.

Uh, those are my thoughts on what people should be doing with our, our newfound robot friends that, that they are largely not. Uh, just approaching things the wrong way, going at things all wrong, holding it wrong, as a wise man once said. And, uh, though, I think those are unfortunately the people who are not going to do a good job of surviving, uh, these token fueled times of ours, these token fueled spending frenzies, because the, you’re, you’re just doing the stuff that you already did with it.

Right. Go big. Right.

Get out there, do something enormous. Right. Cause you can, right. It’s, it’s, it’s a thing that you can do. All right. Anyway. Thank you for watching.

Uh, I hope you enjoyed yourselves to some degree. Uh, I don’t know if you’ve learned anything, but perhaps you’ve been moderately entertained for a moment. All right.

Thank you for watching.

Going Further

If this is the kind of SQL Server stuff you love learning about: these days I have AI do the annoying stuff for me. My new video course teaches you to work the same way, and I teach whole teams in a one-day workshop. Someone still has to know enough SQL Server to keep the robots in check, and that’s what my training is for.

The post How SQL Server People Can Stay Relevant With AI appeared first on Darling Data.

So, uh, you can do this:

In dark mode too:

Here’s how:

1. Download the free ClaudiaIDE extension for Visual Studio. It’s a VSIX file. Put it in your downloads folder.
2. Technically, extensions aren’t supported by SSMS v22 yet, so you’ll have to run this PowerShell script to install it. SSMS will relaunch with ClaudiaIDE’s default background image.
3. Go into C:\Program Files\Microsoft SQL Server Management Studio 22\Release\Common7\IDE\Extensions\ClaudiaIDE\Images – or wherever your SSMS is installed – and drop the images you’d like to use there. Ideally, it’s PNG files with transparencies, so they’ll work in both dark & light mode.
4. In SSMS into Tools, Options, ClaudiaIDE, dark/light themes. You can set a single image, use slideshow to have it rotate through the images, and even use animated movies or gifs like Tom Hardy standing in front of a burning plane.

My favorite source for short loops like that is /r/Cinemagraphs, like winter in Kyoto, a racing Ducati, or that burning plane from Dunkirk.

Or if you’d like to stare at me all day – and who wouldn’t – then here’s a zip file of transparent images of me to rotate through in slideshow mode. The default rotation of 1 minute feels a little frantic though – I’d do 10 minutes. Set the stretch mode to “None” for these so they stay on the bottom right side of your editor. Enjoy!

When it comes to AI, we believe Bing users should have a choice in how they search. That’s why Bing offers both AI-powered and traditional search experiences, including a browser extension that lets people easily turn off AI features in Bing.

AI is doing powerful things for search, and our research shows users want to have the option to choose whether or not AI is involved in every session. Sometimes a quick AI-generated summary is exactly what you need. Other times, you’d rather scan the results, compare sources and decide for yourself what information to trust.

We’re proud of the AI experiences we’re building in Bing. Being able to turn AI answers off when you want to isn’t a step back from AI. It’s a step toward putting you in charge of how you use it.

Two ways to search without AI answers on Bing

The Microsoft Bing AI Search Choice extension (preview)

After you install this browser extension, a simple toggle lets you choose whether to see AI-generated answers on Bing. Turn it on for fast, helpful summaries, or switch it off to focus on familiar search results and links. Your preference applies across all your Bing searches. The extension is available for Google Chrome and Microsoft Edge, and it also sets Bing as your default search engine.

Get it for Chrome: https://chromewebstore.google.com/detail/microsoft-bing-ai-search/mcaabonmnmphidjfohjkdobemneigopa

Get it for Microsoft Edge: https://microsoftedge.microsoft.com/addons/detail/microsoft-bing-ai-search-/pmjianmjibiamoboooofebdpagpdekao

The -ai operator

Bing also offers an option that doesn’t require installing anything. Simply add -ai to any Bing search to get results without AI-generated answers. Try it: why is the sky blue -ai

Tell us what you think

The extension is in preview, so we may make changes based on your feedback. Give it a try, then let us know what’s working, what’s missing and what else would help you choose when AI is part of your searches. Reach us on X.