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

Meet the Writer: Hacker Noon's Contributor Naresh Waghela, Technology Writer & Digital Marketing Pro

1 Share

Welcome to HackerNoon’s Meet the Writer Interview series, where we learn a bit more about the contributors that have written some of our favorite stories.


1. Tell us a bit about yourself. Name, profession, and personal interests.

My name is Naresh Waghela, and I am a Senior SEO Executive, technology writer, and digital marketing professional. I specialize in SEO strategy, content optimization, digital growth, and emerging technologies.

I have a strong interest in Artificial Intelligence, Large Language Models (LLMs), Generative AI, and how technology is transforming the digital landscape. I enjoy researching complex technical subjects and turning them into practical, easy-to-understand content that helps readers learn something valuable.

2. What was your latest HackerNoon Top Story about?

My latest HackerNoon story, "Making Local LLMs Usable on 8GB GPUs," explores how developers can run and optimize local Large Language Models on GPUs with limited VRAM.

The goal was to demonstrate that working with AI models locally does not always require expensive, high-end hardware. With the right optimization techniques, developers can make AI more accessible, practical, and affordable.

3. Do you usually write on similar topics? If not, what do you usually write about?

I write about a variety of topics, including Artificial Intelligence, SEO, digital marketing, Generative AI, technology trends, and online visibility.

I am particularly interested in the intersection of AI and search, including Answer Engine Optimization (AEO), Generative Engine Optimization (GEO), and how AI-powered search is changing the way people discover information online.

4. What is your usual writing routine like?

My writing process usually starts with research. I explore a topic, understand its technical aspects, review available information, and identify what readers would find most useful.

I then organize my ideas into a clear structure and focus on making the content informative, practical, and engaging. I also spend time reviewing and refining the article to ensure accuracy and readability.

5. What is the biggest challenge you have when it comes to writing?

One of the biggest challenges is simplifying complex technical concepts without losing their technical accuracy.

Technology evolves quickly, especially in AI and machine learning. It takes continuous research and learning to ensure that the information remains relevant, reliable, and useful to readers.

6. What is the next thing you hope to achieve in your career?

I want to continue growing as a technology writer and digital strategist while exploring the possibilities of Artificial Intelligence.

One of my long-term goals is to contribute meaningful insights to the global technology community and help bridge the gap between complex AI innovations and practical real-world applications.

7. What is your guilty pleasure of choice?

I genuinely enjoy exploring new technologies, experimenting with AI tools, and discovering interesting ideas that can turn into useful projects. Sometimes, what starts as casual curiosity becomes hours of research and experimentation.

I enjoy spending quality time with my family and exploring new places whenever I get the opportunity. It gives me a refreshing break from professional responsibilities and helps me maintain a healthy perspective.

9. What can the HackerNoon community expect to read from you next?

Readers can expect more content around Local LLMs, Generative AI, practical AI implementations, AI-powered search, and the future of digital marketing.

I am particularly interested in exploring how developers and businesses can use AI efficiently without always depending on expensive infrastructure.

10. What's your opinion on HackerNoon as a platform for writers?

HackerNoon is a valuable platform for independent technology writers. It provides an opportunity to share ideas, reach a global audience, and become part of a community that values technology, innovation, and knowledge sharing.

I appreciate the platform's support for writers and its efforts to make technical knowledge accessible to a wider audience.

11. Do you have any closing words?

I believe that learning should never stop, especially in the technology industry. Every new development brings an opportunity to explore, experiment, and share knowledge.

Thank you to the HackerNoon editorial team and community for providing a platform where writers can share their ideas and contribute to the global technology conversation.

Read the whole story
alvinashcraft
just a second ago
reply
Pennsylvania, USA
Share this story
Delete

Meet the Writer: Alena Belova on Reputation, AI Search and the Numbers Nobody Publishes

1 Share


Welcome to HackerNoon’s Meet the Writer Interview series, where we learn a bit more about the contributors that have written some of our favorite stories.


So let’s start! Tell us a bit about yourself. For example, name, profession, and personal interests.

My first job, in 2015, was finding out what people really think of things: market research, then reputation analysis for a national lottery brand. Everyone has a view of a lottery. Nobody is neutral. Then I moved to Istanbul and co-founded an e-commerce business selling Turkish goods directly to customers. That is where I learned what I now tell founders: you can be the voice of your company, but the product needs its own accounts, its own email and its own search presence from day one.

Later I worked on a large language model project. From that side you learn two things quickly. An answer is never as fixed as it looks: while a model is still being worked on, the same question can come back noticeably different from one round to the next. And geography matters, just as it always did in search. The same question asked from two countries can return two different pictures of the same company.

That path explains where I am now. I'm a partner at BARS Agency. We build and promote digital products, work on reputation and on how people and companies are presented in AI search. Geometrika started there as a tool we built for ourselves and our clients, to see how AI assistants describe a brand and which sources they lean on, so that strategy could start from data instead of guesses. Exhibo, a global art gallery and culture platform where I'm co-founder and editor-in-chief, asks the same question about culture: which galleries, museums and places become visible online and which quietly drop out.

On paper, these look like different careers. It's one question asked in different rooms: how does something get seen and why do people believe what they see?

I studied art history and I'm studying psychology now, which covers both halves of that question. I lived in Istanbul for several years. These days I live between Doha, Dubai and Egypt.

Interesting! What was your latest Hackernoon Top story about?

My latest Top Story asked why a two-hour transfer in the Alps can cost more than the flight that got you there. It belongs to a series I keep coming back to: hidden economics, the prices everyone pays and nobody explains. The newest piece in it is about film rebates in the Middle East. The detail I can't stop thinking about is that a desert now comes with a percentage attached. Every line producer knows the rates by heart. Almost no government in the region publishes what it has actually paid out.

The method doesn't change from piece to piece. Start with a number that should be public. Find out whether it is. If it is, read every row of it.

Do you usually write on similar topics? If not, what do you usually write about?

On HackerNoon it's mostly search, AI and the psychology around them. Somewhere along the way the psychology pieces and the search pieces turned into the same subject. People tend to accept a coherent, confident explanation without checking how it was put together. Memory does it to us: a manager sincerely remembers backing the idea that won. AI answers do it for us: one fluent paragraph, assembled from sources of very different quality, reads as settled fact.

Elsewhere it's culture. At Exhibo I write about art, architecture and the stories attached to objects and places. One pattern keeps coming back: fiction borrows a real place and forgets to give it back. Tatooine is in Tunisia. Agrabah is stitched together from real cities.

The subjects wander. The question underneath doesn't: what is actually going on beneath something everyone takes at face value?

Great! What is your usual writing routine like (if you have one?)

I start with a table. Whatever I want to know, row by row. Half of it usually fills in an afternoon. The piece lives in the cells that refuse to fill.

Then I go to the primary documents, which in this region often means a French PDF, a ministry decree or a press release that is generous with every number except the one you need. When I find a dataset I add it back up against its own totals before I trust a single figure from it.

Being a writer in tech can be a challenge. It’s not often our main role, but an addition to another one. What is the biggest challenge you have when it comes to writing?

The research eats the writing. I can spend a week finding out that a number almost never exists in public. That week is invisible in the final piece. Finding out that something isn't there is a finding too. It just takes longer to write down.

The other challenge is restraint. When you've read seven years of a ledger, you want to show the reader every row. The reader wants three.

What is the next thing you hope to achieve in your career?

I want companies to be able to see how AI systems describe them and where that picture comes from, the way they once learned to read their own search results. Most still check it by asking ChatGPT about themselves once and hoping for the best. And what actually moves those answers is rarely what anyone expects. Start a podcast and the assistants often pick it up. I once shared a few of my own photos of desert monasteries. Within weeks the AI version of me had become a cultural heritage contributor and was drifting towards "philanthropist". Nobody has ever complained about that particular error.

I want the same for culture. A serious gallery in Doha or a small museum in Cairo shouldn't disappear from what people find online simply because the information about it was never made easy to find.

Wow, that’s admirable. Now, something more casual: What is your guilty pleasure of choice?

Trips planned around exactly one thing I want to see. Lately it's usually a ruin with a desert around it, though it can just as easily be a coastline or a forest. Everything else is allowed to happen on the way, as long as there's European coffee somewhere on the route.

And when the list runs out, I go out into the desert just to look at nothing for an hour. It is the only place where my phone and I agree to ignore each other.

Languages. Spanish, Arabic and, less gracefully, Turkish. Spanish feels familiar, at least in its logic. Arabic and Turkish don't. Many Arabic words are built from three-consonant roots, so one root gives you a writer, a book and an office. In Turkish a whole sentence can be a single word thirty letters long. Both break my brain a little.

Translators and AI do fine with a menu. Face to face, they still get lost. So I'm doing it the long way.

And art, which stopped being a hobby the day it became a job. I will still talk Monet and Manet with anyone who confuses them.

What can the Hacker Noon community expect to read from you next?

First, an experiment I've wanted to run for a while: asking every major AI assistant who I am, then tracing the wrong answers back to where they came from, when they came from anywhere at all. A machine's idea of you is assembled from places you have forgotten you ever wrote.

Then more hidden economics: who pays for a free museum. The British Museum opened free in 1759, on a collection a public lottery had helped pay for. In 2026 the Louvre and the Grand Egyptian Museum both raised their prices. Someone always pays. The question is who. And whether they know it.

What’s your opinion on HackerNoon as a platform for writers?

Where else would a story about airport transfers in the Alps sit next to one about falling in love with chatbots? I've stopped asking which of them is the tech story.

Thanks for taking time to join our “Meet the writer” series. It was a pleasure. Do you have any closing words?

If you ever go looking for a number and it isn't there, write that down. The absence is usually the story.

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

Foundry IQ: now managed for you in every Foundry project

1 Share

Foundry IQ: Now managed for you in every Foundry project

Building AI agents that can answer questions from your documents just got simpler.

Today we're announcing that every Microsoft Foundry project will include a managed Foundry IQ resource. Create knowledge bases and ground agents directly from your project, with no separate Foundry IQ (Azure AI Search) service to provision or manage.

With a managed Foundry IQ resource, it's easier to connect your agent to a knowledge base and activate market-leading agentic retrieval, ingestion, content security, indexing, and source connections within your Foundry agent-building experience. You choose the content; Foundry IQ manages the underlying grounding infrastructure.

Request access to the Foundry Managed Knowledge preview. We're starting with limited preview access and plan to roll out managed Foundry IQ to all Microsoft Foundry projects in December 2026.

How it works

Start with an eligible project and permissions to create a knowledge base and access the content you want to use.

Step 1: Open Knowledge in your Foundry project and select Create a knowledge base. In the configuration pane, use the Managed by Foundry resource and enter a name for your knowledge base.

 

Step 2: Select Upload files to add your files as a knowledge source. Foundry IQ processes the uploaded content and prepares it for retrieval through a searchable index. Once the knowledge source status changes to Active, save the knowledge base. You can also connect a knowledge source supported by the managed preview.

For supported file formats, upload limits, and processing details, see Create a file knowledge source.

 

 

Find evidence across documents with agentic retrieval

With model-based query planning enabled, Foundry IQ can break a complex question into focused searches, run them in parallel, and bring the relevant passages together for the agent.

For example, asking "How do our Q3 sales in Europe compare with our Q2 forecast?" may require retrieving actual sales results, forecast assumptions, and regional performance data from different documents. Foundry IQ can plan and execute focused searches across those sources to gather the evidence needed for a grounded response.

Source references let users check where the answer came from. Learn how agentic retrieval works.

Use microsoft-retriever-1 out of the box for fast, low-cost retrieval, or bring your own supported model to tune the trade-off between latency, cost, and answer quality. Different workloads may benefit from different models depending on query complexity, retrieval requirements, and performance goals.

Ground your agent and test its answers

From the saved knowledge base, select Add to an agent.

In the agent playground, ask a question that draws on multiple files and open a citation to check that the source supports the answer.

Then try a question answered by one document and another the documents can't answer. For the latter, check that the agent acknowledges the gap.

 

 

Choose how to run Foundry IQ

Use a managed Foundry IQ resource when you want to create a knowledge base in your project and have Foundry manage the search infrastructure.

Bring your own Foundry IQ (Azure AI Search) resource when you want to reuse existing search indexes or indexing pipelines, define custom index schemas, or control the search resource configuration directly.

Supported knowledge sources and configuration options vary by setup.

Get started

Request access to private preview and try grounding an agent with a set of documents you know well.

Additional resources:

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

External agents in Microsoft Foundry are now generally available

1 Share

Built your agent somewhere else? Foundry can still help you measure and improve it.

External agents in Microsoft Foundry are now generally available. If your agent runs outside Foundry and sends OpenTelemetry traces to Application Insights, you can register it in Foundry and use those traces to observe and evaluate it, without moving or rebuilding the agent. Registration, the agent trace view, Agent Insights, and continuous evaluation of production traces are generally available. Other capabilities in this post are in preview and are labeled where they appear.

Why use production traces? Because they show you what your tests missed. Take Contoso Travel, a fictional company that runs its own trip-planning agent outside Foundry.* Before launch, the agent passed every test the team wrote. After launch, users asked about carry-on bag rules and planned trips with three or four cities. Neither was in the test set. That's normal: tests cover the scenarios your team thought of, and real users bring the rest.

This post follows Contoso as they connect the agent to Foundry, find problems in production, turn expert review into tests, and use those tests to measure and improve the agent.

Connect the agent you already have

Your agent keeps running where it is, on its existing endpoint. You send its traces to Application Insights, register it in Foundry, and Foundry reads the traces from there.

Before you begin, you need:

  • An Application Insights resource connected to your Foundry project.
  • An agent that emits OpenTelemetry traces following the GenAI semantic conventions, with a gen_ai.agent.id attribute on its invoke_agent span. Agents built with frameworks other than the one shown here can also connect if they emit compatible traces.
  • The Foundry User role on the project, and Monitoring Reader on the Application Insights resource to view traces.

For the full list of prerequisites, see Register external agents for observability and evaluation.

Contoso's agent is built with Microsoft Agent Framework in Python and runs on Azure Kubernetes Service. Connecting it takes three steps.

Step 1: Send traces to Application Insights

import os from agent_framework import Agent from agent_framework.openai import OpenAIChatCompletionClient from azure.identity import DefaultAzureCredential from microsoft.opentelemetry import use_microsoft_opentelemetry # Send traces, including prompts and responses, to Application Insights. use_microsoft_opentelemetry( enable_azure_monitor=True, azure_monitor_connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"], enable_sensitive_data=True, ) client = OpenAIChatCompletionClient( model=os.environ["AZURE_OPENAI_DEPLOYMENT"], azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"], credential=DefaultAzureCredential(), ) agent = Agent( client, "You are Contoso Travel's trip-planning assistant...", id="contoso-trip-planner", # Emitted as gen_ai.agent.id. Register the agent with this ID in step 2. name="contoso-trip-planner", tools=[search_flights, search_hotels, policy_lookup], )

This uses the Microsoft OpenTelemetry distro. Call use_microsoft_opentelemetry once at startup, before you create the agent.

Decide early how you'll handle message content. enable_sensitive_data=True records prompts and responses in your traces. Evaluators that score what the agent said, such as quality and rubric evaluators, need that content. The tracing docs recommend turning content recording off in production unless you need it. Before you turn it on in production, decide what content you're allowed to capture, who can see it, how long you keep it, and whether to redact it first. For the full set of considerations, see Restrict access to sensitive content in Microsoft Foundry traces and Tracing and data handling.

Step 2: Register the agent in Foundry

In the Foundry portal, go to Build > Agents > New agent > Link external agent, then enter the agent name and its OpenTelemetry ID.

Or use the SDK (azure-ai-projects 2.11.0 or later):

import os from azure.ai.projects import AIProjectClient from azure.ai.projects.models import ExternalAgentDefinition from azure.identity import DefaultAzureCredential project = AIProjectClient( endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"], credential=DefaultAzureCredential(), ) project.agents.create_version( agent_name="contoso-trip-planner", definition=ExternalAgentDefinition(otel_agent_id="contoso-trip-planner"), )

Step 3: Check that traces arrive

Send the agent a few requests, then open the agent's Traces tab in Foundry. Traces usually appear within a few minutes.

If traces don't show up, see Troubleshoot missing traces.

That's the setup. The rest of this post builds on those traces, and you can adopt each part on its own.

Find problems in production

With traces flowing, the next step is finding what's going wrong. Once an agent is live, there are too many conversations to read one by one, and bad answers often don't show up as errors in logs.

Start with the trace view. Filter by time range, status, or token count to narrow down the traces you want to review, then open a run. The trace view shows each run step by step, based on what your traces record, such as model calls, tool calls with their inputs and outputs, and messages. That context can help you investigate where a run went wrong, rather than seeing only the final result.

For a deeper look across many traces, use Agent Insights. You can run it on demand or periodically. It analyzes the agent's recent traces with a model you choose, then groups recurring issues and shows each one with its severity, the linked traces, and a proposed next step. Foundry doesn't have access to an external agent's code, so for external agents that proposal is general guidance for you to apply in your own code. Changing an insight's status records your decision. It doesn't change your agent.

Contoso's Agent Insights run flagged a recurring multi-city issue: the agent searched every pair of cities and then searched the same legs again. Around the same time, the support team saw complaints about carry-on answers. Filtering the traces to bag questions showed the agent quoting a size limit that was out of date. It answered from its instructions and never called policy_lookup, the tool that returns the current policy. Instead of reading traces one by one, the team used these signals to decide which traces to look at closely.

Turn human expert review into reusable tests

Agent Insights shows you where to look. Deciding whether an answer is actually wrong often takes someone who knows the business. An LLM judge can help score whether an answer is relevant and grounded, but a general-purpose LLM judge may not know that your airline partner changed its bag rules last month. Your domain experts do, but their judgment often ends up in a chat thread or a support ticket and doesn't make it back into testing.

In Foundry, a human expert's review can become a test you re-run. Foundry calls this human in the loop. 

Annotate the trace (preview). Reviewers can rate a run, add tags, leave a comment, and write the answer they expected. Contoso's support lead reviewed the carry-on traces, marked them as incorrect, and wrote the expected answer with the current limit. The support lead did the same for a few multi-city trips.

One useful practice, also recommended in the annotation docs, is to annotate good runs as well as bad ones, and to say in the comment why an answer is wrong. A score alone doesn't record the reason.

Turn annotations into test cases. Foundry can generate dataset rows from annotated traces. A generated row keeps the user's question and the reviewer's expected answer, and Foundry can add a task-level rubric (preview): pass/fail criteria for that specific case. For a carry-on question, one criterion checks that the agent calls policy_lookup before giving a bag rule. The team reviewed the rows, edited one that was too strict, and added them to their golden dataset: a small, reviewed set of test cases the team trusts and re-runs to compare agent versions.

Define shared quality criteria. Task-level rubrics check specific scenarios. A shared rubric applies the same criteria across an evaluation. Foundry can generate one from a description of the agent's job that you write, plus its production traces, and the team edits it to match their standards. Contoso added a criterion that policy answers must come from policy_lookup, so the carry-on lesson applies to fees and seat rules too. When they regenerate the rubric later, Foundry keeps the dimensions they edited and the version history.

As a result, the support lead's judgment is captured in evaluation artifacts the team can reuse, and the tests come from questions users actually asked.

Measure and improve

With a golden dataset and a shared rubric, Contoso can measure the agent the same way every time. That matters because quality can change after launch, for example when a tool's data changes or someone edits a prompt. To know whether a change helped, you need to measure the same way before and after.

You can also evaluate the agent continuously. Foundry scores a sample of its production traces at an interval you set, such as every hour. Intelligent sampling picks a varied set of traces rather than a random one. Use the shared rubric, built-in evaluators, or your own custom evaluators. Contoso added a custom evaluator that checks each answer against the current policy, the kind of fact a general-purpose judge wouldn't know. Each scheduled run records its scores, so you can track quality over time and set an alert in Azure Monitor when a score falls. Low scores are also a good place to look for the next traces to annotate.

With the problems identified, the team had two ways to improve the agent.

Fix it yourself. For carry-on bags, the cause was clear. The team updated the instructions to always call policy_lookup for bag and fee questions, then re-ran the golden dataset. In this example, the carry-on rows passed and the other rows still passed.

Learn from past traces with skill optimization (preview). Multi-city trips were harder to fix by hand, so the team tried skill optimization. It analyzes past traces, along with any annotations and evaluation results, and proposes a new or updated skill: a versioned folder of instructions, with a SKILL.md file and optional scripts and reference files, that an agent can load when it needs them. The team ran it on recent traces with a focus on multi-city planning. It returned findings and a proposed skill.

A successful run means the run finished. It doesn't mean the proposal is better. The team reviewed the findings and the proposed skill before trying it. Because the agent runs outside Foundry, they downloaded the skill into the agent's project, then re-ran the golden dataset to compare it with the current version. A skill ships only if the comparison shows it helps.

Either way, the check is the same: run the same golden dataset before and after and compare.

Put it together

Each piece works on its own, and they also connect into one loop. Here's the carry-on issue from start to finish:

  1. Detect: support complaints and a trace filter surface outdated carry-on answers.
  2. Review: the support lead marks the traces incorrect and writes the expected answer.
  3. Test: the annotated traces become rows in the golden dataset.
  4. Fix and re-run: the team updates the instructions and re-runs the golden dataset.
  5. Ship and monitor: Foundry continuously evaluates a sample of production traffic.

Steps 1 to 4 fix the issue in front of you. Over time, the team adds reviewed cases to the golden dataset and refines the shared rubric, so later evaluations include what they learned earlier.

Pre-launch testing still matters. Production can add scenarios those tests missed, including unexpected requests or misuse, and expert review helps you decide which ones should become test cases.

Start where you are

You don't need everything at once. Start at the top and go as far as you need:

StageWhat to do
ConnectLink your agent and check its traces
LearnFilter and review traces, run Agent Insights, and annotate traces that show the problems your team cares about
CaptureBuild a golden dataset and define evaluation criteria
MeasureContinuously evaluate a sample of production traces
ImproveTest each proposed change against the same golden dataset

Get started

Register your external agent, send it a few requests, and open its Traces tab. To try the full workflow, start from our external agent sample.

Reference

Preview features are subject to the Supplemental Terms of Use for Microsoft Azure Previews.

*Contoso Travel and all data and results in this post are fictional and for illustration only.

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

Inside the architecture: How connectors work with Azure Functions

1 Share

Say you run a shared support inbox. Each time a customer writes in, you want a function to read the email, pick out the important parts, and post a summary in your team's Teams channel. The business logic might be twenty lines. The rest is authorization, change detection, event delivery, and a second set of permissions to post in Teams, and you rebuild most of it for every service you touch.

Azure Connectors and the Connector SDKs take that work on. The platform manages connections and authorization. The same app can react to events in one service and call operations in another. Webhook and poll delivery give you push or pull, so you can pick what fits your app. One SDK per language covers the Connector catalog with typed operations and payloads, VS Code tooling handles setup, and SDKs are available for .NET, Python, and Node.js from day one.

Underneath those promises are a handful of pieces we built and a few decisions about where each one stops. The support inbox runs through all of them.

Starting from what Azure already has

Azure already runs more than 1,000 managed Connectors, connecting to 1,600+ services. They power Azure Logic Apps and Power Automate, and API Hub hosts their connections, OAuth consent, and runtime. Logic Apps already knows how to run Connector triggers, whether the source sends notifications, accepts a webhook subscription, or has to be polled.

So we didn't write a second integration for each service. We built a new front door to the existing Connector runtime, one that application code can use directly, and added the glue Azure Functions needs on top. Most of the new work falls into four areas:

  • A control plane, the Connector Namespace, that exposes connections, access policies, and trigger configurations as Azure resources.
  • A runtime layer that proxies SDK calls into API Hub and turns trigger configurations into system-managed workflows with a delivery step at the end.
  • A Functions Connector extension, with host and worker pieces, that receives events by webhook or by polling and feeds the Functions scale controller.
  • One code generator that emits typed SDKs for .NET, Python, and Node.js from live Connector metadata, plus tooling that sets everything up.

Azure Connectors and Azure Functions architecture: the Outlook mailbox, the connector platform, and the Function App, with every flow from the email arriving to the summary reaching Teams

The control plane: Connector Namespace

A Connector Namespace is an Azure Resource Manager resource of type `Microsoft.Web/connectorGateways`. Under it sit three child resource types: connections, connection access policies, and trigger configurations. Because they're ARM resources, you can create them with Bicep, the CLI, or the VS Code tooling, and they get the usual Azure role-based access control and lifecycle.

A connection is the application-facing name for a backing API Hub connection, the same kind Logic Apps uses. The consent you grant for Outlook lives there. An access policy lists the Microsoft Entra identities, such as a Function App's managed identity, that may use a connection. That split means the identity that calls the connection and the account that consented to the mailbox are separate, and you can change one without touching the other.

Authorize the connections: the Function App's managed identity presents a token to the access policies, and the Outlook and Teams connections hold OAuth consent for their accounts

 

A trigger configuration describes an event source. Its properties include the connection, the connector operation (for the support inbox, `OnNewEmailV3`), the operation's parameters, optional trigger conditions and settings, and a delivery mode. For webhook delivery it carries the callback details; for Poll delivery the service fills in the polling endpoints.

Each namespace also gets a stable host name, and a background job repairs its DNS record if it drifts.

The action path: a proxy into API Hub

When your handler posts the summary to Teams, the generated SDK client sends an HTTPS request to the connection's runtime URL. On the platform side that URL maps to `api/connectorGateways/{gateway}/connections/{connection}/runtime`, followed by the operation's own path.

Behind that route, the runtime processor handles each request in four steps:

  1. It resolves the application-facing connection to its backing API Hub connection and environment, in the namespace's scale unit.
  2. It builds the API Hub runtime URL and checks that the requested path stays inside that connection, so a caller can't reach a different connection by rewriting the path.
  3. It strips identity headers supplied by the caller and attaches a platform service token, plus headers that pass the caller's managed identity through.
  4. It forwards the method, path, query, and body to API Hub, which runs the connector operation against Teams.

The caller authenticates with a Microsoft Entra token for the API Hub audience. In the Node.js SDK the default scope is `https://apihub.azure.com/.default`, and the token comes from any Azure Identity `TokenCredential`, typically the Function App's managed identity.

The SDK side is thin on purpose. Generated clients extend a shared base class that holds the runtime URL and credential. A shared HTTP pipeline built on Azure Core adds the token, a user agent, tracing, and retries. Retries apply by default only to safe methods such as `GET` and `HEAD`, because retrying a `POST` that sends a message could send it twice. Paged operations follow `nextLink` values. When a continuation link points at a different host, as some connector back ends return, the SDK reroutes its path and query through the connection's runtime URL, so paging stays behind the proxy. Failures surface as a `ConnectorError` that carries the connector name, the operation, the status code, and the response body.

The trigger path: system-managed workflows

When you create a trigger configuration, the trigger API validates the request, generates a Logic Apps workflow definition, creates the workflow directly in a platform-owned subscription under a generated name, and stores the workflow details alongside the trigger configuration. Updates rewrite the workflow, and deleting the trigger configuration removes the workflow, its Poll queue, and its message history.

The trigger configuration generates the backing trigger workflow, which uses the Outlook connection

The workflow generator picks the right trigger shape for the operation's metadata: a notification subscription, a webhook subscription, or a recurring poll. It adds `splitOn` for operations that return batches, so each item becomes its own run unless the configuration opts out, and it applies any trigger conditions you set. The workflow ends with a connector delivery action.

We generate a workflow per trigger configuration because Logic Apps already has years of hardening around subscription renewal, polling state, and trigger history, and every connector trigger already runs on it. The workflow stays an implementation detail: customers work with the trigger configuration resource and never see or edit the workflow.

Two ways to deliver an event

How the platform notices a new email and how the event reaches your function are separate problems. The backing workflow handles the first. The delivery action at the end of the workflow handles the second, and it supports two transports.

Webhook delivery

For webhook delivery, which is the default, the delivery action makes an HTTPS call to the callback in the trigger configuration, using the workflow engine's HTTP retry policy. On the Function App side, the callback is the host's `/runtime/webhooks/connector` route, protected by a system key named `connector_extension`. A `functionName` query parameter selects the function. The host returns `202` when the invocation succeeds, `400` for a missing or invalid name, `404` for an unknown function, and `500` when the invocation fails.

Poll delivery

For Poll delivery, the delivery action writes the event to an Azure Storage queue owned by that trigger configuration and records it in a message history table. Storage queue messages are limited to 64 KiB, so when an event is larger the action queues a reference to the workflow run's output instead of the output itself.

The Poll runtime API sits in front of the queue and has four operations: `receive`, `acknowledge`, `hasMessages`, and `approximateQueueDepth`. `receive` hands out events under a temporary lease with an opaque lock token. `acknowledge` deletes an event only when the message ID and a still-valid lock token match. If the lease expires first, the event becomes visible again. The reported depth is approximate and excludes leased messages.

Deliver the event by Poll: the delivery action enqueues the event, and the Functions host receives and acknowledges it from the Poll queue

Poll delivery means the Function App never exposes an inbound endpoint, and work can build up safely when the app is busy, scaled to zero, or running on a developer's laptop.

Inside Azure Functions: the connector extension

The Functions side has two layers. A host extension, written as a WebJobs extension, owns transport and scaling. A worker extension for each language turns payloads into typed objects for your handler.

The host extension

The host extension registers a `connectorTrigger` binding. Each function picks webhook or Poll delivery, and the binding starts the matching listener.

The Poll listener runs a receive loop. When the queue is empty it backs off with jitter, up to a configurable maximum interval, and receive failures get their own capped backoff. It authenticates to the polling endpoint with the connection's credential, usually the Function App's managed identity. A function that takes one event at a time can run several invocations in parallel, up to `MaxConcurrentCalls`. A batched function processes one batch at a time per listener. An event is acknowledged only after its invocation succeeds; a failed invocation leaves the event unacknowledged so it comes back when the lease expires. When an event holds a link to a large output, the listener downloads it, with a 100 MiB default cap.

Poll delivery also plugs into Azure Functions target-based scaling. The connector trigger reports how much work is waiting by reading the queue's approximate depth through the same Poll runtime API. Azure Functions does the scaling, aiming for `ceil(depth / target)` instances. The target is the function's pending-event threshold, or the per-instance concurrency that the platform supplies when it has one. Batch size and concurrency don't change that calculation.

 

Batching therefore happens in several places. The source trigger can return a collection, `splitOn` can split it into separate runs, and the Poll listener can deliver several events to one invocation. The batch settings have the same meaning in every language:

 

Setting.NET isolatedPythonNode.js
Receive several events per invocation`IsBatched = true``cardinality=func.Cardinality.MANY``cardinality: Cardinality.Many`
Maximum events per invocation`MaxBatchSize``max_batch_size``maxBatchSize`
Concurrent single-event calls`MaxConcurrentCalls``max_concurrent_calls``maxConcurrentCalls`
Pending events per instance, for scaling`TargetPendingEventThreshold``target_pending_event_threshold``targetPendingEventThreshold`

The batch size can be 1 through 32 and defaults to 1.

The worker extensions

Because the host extension does the transport work, each language worker only has to bind payloads. The .NET isolated worker extension deserializes the payload into the type your function declares, such as a generated `Office365OnNewEmailTriggerPayload`, or into `ConnectorEvent[]` when you also want each Poll message ID. Python functions use the `connector_trigger` decorator from the `azure-functions` library. Other workers reach the same host extension through the Functions extension bundle and the `connectorTrigger` binding type.

The Node.js extension shows how thin this layer is. One generic wrapper registers the trigger and flattens every payload shape (a single item, a collection in `body.value`, or an array of Poll envelopes) into one list of items, keeping the original in `rawPayload`. Each connector's helper is then a few lines that add a friendly alias and borrow the item type from the generated SDK. This is the whole OneDrive for Business file:

 
import { BlobMetadata } from "@azure/connectors/generated/OneDriveForBusinessExtensions"; import { OneDriveFileTriggerContext } from "../../types"; import { createConnectorTrigger } from "./createConnectorTrigger"; const registerFileTrigger = createConnectorTrigger<BlobMetadata, OneDriveFileTriggerContext>( (context) => ({ ...context, files: context.items }), ); export const onNewFiles = registerFileTrigger; export const onUpdatedFiles = registerFileTrigger;

`BlobMetadata` comes from the same generated module that the OneDrive client uses for actions, so a trigger payload and an action response share one type, defined once from the connector's metadata.

Calling out from the handler

After reading the email, the handler posts a summary to Teams. That call leaves the Function App through the same connector platform, going the other way.

The handler calls a generated Teams client with typed input. The client holds the Teams connection's runtime URL and an Azure Identity credential, gets a Microsoft Entra token, usually for the Function App's managed identity, and sends the request. The Function App never holds a Teams token or secret.

The connection's access policies decide whether that identity may use the Teams connection, and the connection holds the OAuth consent for the account that posts. The connector runtime resolves the connection, replaces the caller's identity headers with a platform token, and runs the operation against Teams.

Post the summary to Teams: the handler calls the Teams SDK client, the request goes through the connector runtime using the Function App's identity and the Teams connection's consent, and the runtime posts the message to Teams

This path doesn't depend on how the email arrived, so it works the same with webhook or Poll delivery and with any connector in the catalog. Idempotency is the handler's job. The SDK won't retry a failed post, but a redelivered event runs the whole invocation again, so the handler should check before posting the same summary twice.

One generator, three SDKs

The SDKs are generated. A shared generator in the Logic Apps codebase, `CodefulSdkGenerator`, reads live connector Swagger definitions through Azure Resource Manager, cleans them up, and emits clients for C#, Python, and TypeScript. Each SDK repository records what produced it in a generation manifest: the generator commits, the metadata API version, and a hash of every connector's Swagger input. That makes each regeneration traceable to a specific generator revision and a specific set of connector definitions.

Besides action methods, the generator emits models for request and response bodies, typed trigger payloads and trigger operation constants, catalog constants that list the available connectors, and support for paging and dynamic schemas. Each language then has a small handwritten runtime (the base client, the HTTP pipeline, errors, and paging) that the generated code builds on. Naming rules are kept consistent across languages, so the same connector and operation have recognizable names whether you write C#, Python, or TypeScript.

For setup, the VS Code connection manager and the connection-setup skill create the namespace and connection through the ARM preview API, open the OAuth consent page and check that the connection reports `Connected`, add access policies for your developer identity or the Function App's managed identity, and write the runtime URLs into local or deployed app settings.

Recap

When a customer writes in, the backing workflow detects the email through API Hub's existing connector trigger. The delivery action then either calls the Function App's webhook or writes to a per-trigger Storage queue that the host extension polls and scales on. The language worker binds the payload to a type that came from the same generator as the SDK, and the handler uses a generated Teams client whose calls go through the namespace's runtime proxy into API Hub.

Each piece reuses what was already there: the Logic Apps workflow engine for triggers, API Hub for connections and connector runtime, the Functions extension model and scale controller for hosting, and Azure Identity for credentials. The new parts are the namespace resources that tie them together, the delivery step, the Functions extension, and the generator that keeps every language's types in step with the connectors themselves.

References

Connectors SDKs
Azure Functions connector extensions
ComponentRepository
Host extension and .NET isolated worker extensionAzure/azure-functions-connector-extension
Python worker extensionazurefunctions-extensions-connectors
Node.js worker extensionazure-functions-nodejs-extensions-connectors
Samples
SampleRepository
.NET email triage into TeamsAzure-Samples/functions-connectors-net-e2e-email-users-teams
.NET connector samplesAzure/Connectors-NET-samples
Python connector samplesAzure-Samples/functions-connectors-python
TypeScript connector samplesAzure-Samples/functions-connectors-typescript

 

Note: The connector platform internals described in the post (the resource model, runtime proxy, trigger workflows, delivery action, and Poll runtime API) aren't in a public repository, so they have no links here.

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

Introducing unified tasks and plans for Copilot and Microsoft 365

1 Share

For years, customers have had to decide between using Microsoft To Do, basic plans in Planner, or premium plans in Planner for tracking their tasks and managing work. Capabilities varied across these experiences, creating confusion and limiting how easily work could flow across tools, integrations, and AI experiences. Moving forward, this will no longer be a hurdle.

Today, we are introducing unified plans, a single system for tracking your work as an individual, as a team, and as an organization. The new unified plans service will be available across Microsoft 365—whether in Outlook, Microsoft Teams, Planner, and Loop. Additionally, unified plans are now available in Microsoft Copilot and Microsoft Cowork, with availability in Autopilot also planned.

A unified platform for people and agents across Microsoft 365

Unified plans bring features from To Do and basic and premium plan types together on one shared foundation, where premium features are available according to your assigned Microsoft Copilot, Planner Plan 1, or Planner and Project Plan 3 license. Premium features such as Goals view, Timeline view, and custom fields have already rolled out in unified plans, and additional premium features such as sprints and backlogs, task hierarchy, dependencies, and more are on the roadmap.

Also to note, our licensing structure and collaboration capabilities are not changing. Planner users will be able to collaborate on tasks together in shared plans, regardless of which license they have. For example, a project lead with Planner Plan 1 can set goals for a plan while teammates with Planner in Microsoft 365 can track and update the tasks corresponding to those goals. This allows teams to coordinate work in a single shared plan without requiring all team members to have the same license. For a full list of features available by plan, see the Planner plans and pricing comparison.

Additionally, this unified platform makes accessing Planner through Copilot, Cowork and Autopilot easier because it’s all part of Work IQ. In short, we’re building one platform for Microsoft 365 tasks and plans that connects the work people manage individually, the plans they execute together, and the tools and agents that help them move that work forward.

Build on a shared foundation

Unified plans bring task and planning capabilities onto a shared foundation to reduce the complexity of working across separate systems, and support ongoing Planner extensibility. As part of our strategy to move toward unified plans, we’re transitioning to a fully Azure-based service. We will no longer be investing in Dataverse-based plans and will be bringing premium capabilities, Microsoft 365, and Copilot integration to our Azure-based unified task and plan infrastructure.

Soon we will be redesigning the plan creation experience to minimize confusion for our users by removing the “Basic” label from unified plans and templates. Premium plans will remain supported as we transition, though we encourage our users to begin adopting unified plans (currently created as a basic plan).

A screenshot of the Create a plan dialog shows the new Create your own plan option. Please note, design may change.

Extend your Planner plans

Today, To Do and basic and premium plans have separate APIs and connectors, with differences in the planning data and capabilities they expose. With a shared foundation, we now have a single set of extensibility options across Planner. This also provides more consistent ways for organizations to build integrations without requiring a different approach for each plan type, with access to more planning capabilities as API support expands.

If you need to extend your Planner plans, we recommend using the extensibility options below:

  1. Microsoft Graph APIs let developers work programmatically with plans and tasks—for example, by creating tasks from an organization’s intake process or connecting Planner data to a custom application. The first version of the unified task and plan Graph APIs are now in beta. These APIs will also include the new ‘default plan’ where an individual’s tasks will be stored.
  2. Power Automate  connects Planner to business workflows. The direction is toward a single Planner connector that works across the unified platform, reducing the need for separate workflows for different plan types.
  3. Model Context Protocol (MCP) server makes it easier to connect Planner capabilities into agent-driven workflows. Designed for custom agents, the Planner MCP server is a part of Work IQ and connects planning and execution across Copilot and other Microsoft 365 experiences.

If your organization is investing in extending or customizing Planner, we encourage you to build unified plans using these extensibility options wherever they support your requirements.

What’s new and what’s coming soon to unified plans in Planner

Since moving basic plans to the unified foundation back in February, we’ve introduced more than a dozen features to unified plans, including Goals view, task chat, custom templates, Copilot integration, Capacity view, Timeline view, and more. You’re likely familiar with several of these features which already exist in premium plans today.

Additionally, we’re excited to announce new features that are currently rolling out or will soon be rolling out in unified plans. Together, as part of one unified plan type, these features will help individuals and teams:

Organize and visualize work

Alongside the recently rolled out custom templates, which enable teams to reuse their meticulously-structured plans instead of starting from scratch, we're introducing features such as conditional coloring, bucket colors, and custom views to allow users to more easily scan their plans and focus on the work that matters to them.

Conditional coloring is currently rolling out in unified plans in Grid view. Similar to conditional formatting in Excel, this feature lets users visually highlight tasks based on selected fields, conditions, and values to ensure that important task details are easier to spot.

A screenshot of a plan in Grid view shows the Conditional Coloring window open with a list of options—Task name, Priority, Status, Due date, Start date, Finish date, Assigned to, Label, Completion (%)—to select from the Field drop-down.

We’ve also brought bucket colors to unified plans, so users can color code their buckets by selecting the paint palette icon that appears next to the bucket title on hover.

A screenshot of a plan in Board view shows the paint palette icon next to the bucket title. The color picker for a bucket has been opened, showing 25 colors to choose from.

Custom views, once rolled out in unified plans, will allow users to save a customized view of a plan and return to it later simply by selecting the Custom views drop-down in the upper right corner and selecting Save current view. With custom views, team members will be able to reuse saved views without having to reapply filters, sorting, grouping, and other customizations.

A screenshot of a Planner plan in Board view shows the Custom views dropdown in the upper right corner with the Save current view option selected.

Collaborate where work happens

With task chat, which rolled out in unified plans earlier this year, users can ask a question, share an update, or bring someone directly into a task using @mentions to notify team members in Outlook and in Teams. Users can also now manage their tasks and shared plans through the Planner app in Outlook.

Additionally, Planner can now be added as a tab in both private and shared Teams channels, allowing team members to access their unified plans where they already collaborate.

Finally, tasks assigned through collaborative recurring meeting notes in Microsoft Teams can soon be tracked in existing Planner plans, alongside other work, helping users both remember and follow through with tasks assigned in Teams meetings.

Structure larger efforts and understand progress

Task hierarchy, which is planned to roll out in unified plans, will allow teams to break down larger efforts into tasks with subtasks in Grid view. With task hierarchy, you’ll be able to more easily track your workstreams and define larger tasks in greater detail while maintaining a simple, low-maintenance structure using Add a new subtask or Make this a subtask from the More options (three horizontal dots) drop-down menu.

A screenshot of a Planner plan in Grid view shows the More options drop-down menu with options to Add a new subtask and Make this a subtask. Please note, design may change.

You will also be able to easily undo this by selecting Promote task.

A screenshot of a Planner plan in Grid view shows the More options drop-down menu with options to Add a new subtask and Promote task. Please note, design may change.

Teams and leads need to see when work is happening and how that work connects to larger goals. With Timeline view, which rolled out in unified plans in October, teams can view work over time, while Goals view in unified plans allows users to connect their tasks to overarching team goals and update goal details as work moves forward.

Manage your portfolios

Connected plans allows users to connect plans together, creating a portfolio view across the team's work. By combining this with custom columns and all the tools in Planner, managing a portfolio becomes easier, while allowing individual teams to manage subtasks, owners, and delivery dates in a dedicated plan.

All of this data is available in Copilot which allows you to build rich reports and workflows in seconds.

A screenshot of a portfolio of tasks in Grid view shows four project tasks, each linked to its own connected plan.

Recognize changes and team capacity

As plans grow, teams also need to understand what has changed and how work is distributed. Task history, which is currently rolling out in unified plans, will help teams stay up to date on changes made to a task. With task history, you can view recent activity to see what changed, when it changed, and track progress over time.

Capacity view, which rolled out in unified plans in October, allows team leads to review their plan’s work by assignee and time. With Capacity view, you can see scheduled and unscheduled tasks together in a single view, understand who is working on tasks when, and adjust work across weeks if plans change. Select the Show unscheduled toggle to view unscheduled tasks in a separate pane to the right of the capacity view, and drag and drop unscheduled tasks to assign the work based on capacity.

A screenshot of the new Capacity view in Planner shows task bars by assignee and a list of unscheduled tasks in the right pane.

Work with Copilot and agents in your plans

Unified plans are where AI capabilities in Planner come together. With a Microsoft Copilot add-on license, the Planner Agent can work directly in your plans. For example, teams can assign tasks to the agent or ask the agent to generate status reports grounded in their plan’s details. Additionally, users with a Microsoft Copilot license can manage Planner tasks directly in Microsoft Copilot and Copilot Chat.

The Planner Plugin allows Cowork to directly read and take action across plans at scale and the Planner MCP server is part of the Work IQ APIs bringing Planner capabilities into custom agent-driven workflows. Together, these experiences connect the tools that help people move work forward in the plans that organize it.

Personal task management in Planner and what’s next for Microsoft To Do

Alongside these improvements to unified plans, we’re making Planner a simpler place to manage your own work. We’ll soon roll out a redesigned My tasks experience that makes it easier to capture and track your own tasks, keep important work front and center, and stay on top of tasks assigned to you. For people using work or school accounts, Planner brings individual task management and team planning together in one place.

A preview of the updated My tasks experience in Planner for the web. Please note, design may change.

Going forward, new private tasks created in Planner will be stored directly in Planner, in a private plan just for you, rather than in To Do. Bringing individual and shared work onto the same foundation helps us deliver more consistent capabilities and connect your own tasks with Copilot, Cowork, and other agents.

As we bring personal task management into Planner, we will phase out To Do. The To Do apps will retire on June 30, 2027. Connections that other apps use to access To Do tasks will continue beyond that date, and we’ll provide separate notice before those connections are retired. We’re also updating existing task integrations across Microsoft 365 to connect with Planner, so you’ll be able to create or manage tasks in the Microsoft experiences you already use. Although To Do tasks are already visible in Planner, they will not be migrated to the new private plan. Customers using personal Microsoft accounts will need to choose another app. Our To Do transition guidance  will help you understand what’s changing and plan your next steps.

What this means for your organization

When creating a new plan in Planner, we recommend creating a new basic (unified) plan which supports the capabilities and integrations your organization needs. Some scenarios may still require premium plans in the interim while premium features are being brought into unified plans. If you need to extend your plan, we recommend using the extensibility options highlighted above.

A screenshot of the existing Create a plan dialog shows both options for creating a Basic plan or a Premium plan.

For admins, unified plans do not require a Dataverse environment or Dataverse storage capacity. Existing premium plans continue to use Dataverse.

For organizations using To Do, preparing for this change includes confirming Planner access for affected users and reviewing workflows and integrations that depend on To Do. Our To Do transition guidance will help admins prepare users for the move to Planner and understand what’s changing for existing tasks.

Unified plans are the foundation for our work to connect personal tasks, team plans, and agents across Microsoft 365. Bringing that work together gives people and agents clearer context about goals and ownership to carry work forward.

For upcoming Planner capabilities and estimated release dates, visit the AI at Work Roadmap.

What’s happening with premium plans

One of the most common questions we’ve been hearing is, "What's happening with premium plans?" You've likely noticed that our most recently released features work only with basic plans. That includes AI capabilities such as Planner capabilities in Microsoft Copilot, Planner Agent in Copilot, the Planner plugin for Cowork, and the Planner MCP server in Work IQ. These capabilities rely on the Planner MCP server, which supports only basic plans and their data. Other new Planner features, such as Task chat, Custom templates, Capacity view, have also rolled out in basic plans and will not be available in premium plans.

It’s important to note that basic plans are now unified plans, built on one shared foundation, that eliminate the division between plan types and the tradeoffs that come with it. Moving forward, all new Planner features and capabilities will be developed for and rolled out to unified plans—and over time, we will continue to incrementally bring premium features to unified plans.

Learn more

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