Signal blog Official Microsoft Blog Command Line Microsoft On The Issues Asia Canada Europe, Middle East and Africa Latin America The Code of Us What's new AI Innovation Digital Transformation Sustainability Security Work & Life Diversity & Inclusion Unlocked Microsoft 365 Azure Copilot Windows Surface XBOX Deals Small Business Support Windows Apps Outlook OneDrive Microsoft Teams OneNote Microsoft Edge Moving from Skype to Teams Computers Shop XBOX Accessories VR & mixed reality Certified Refurbished Trade-in for cash XBOX Game Pass Ultimate PC Game Pass XBOX games PC games Microsoft AI Microsoft Security Dynamics 365 Microsoft 365 for business Microsoft Power Platform Windows 365 Small Business Digital Sovereignty Azure Microsoft Developer Microsoft Learn Support for AI marketplace apps Microsoft Tech Community Microsoft Marketplace Software companies Visual Studio Microsoft Rewards Free downloads & security Education Gift cards Licensing Unlocked stories View Sitemap

By builders, for builders.

A Microsoft publication

Building a fully autonomous meeting invite capability for Autopilot

How the Microsoft-Decision-1 model helped get this across the finish line.

Editorโ€™s note: This post originally appeared on omarknows.ai.


Decision models are a new type of model that have recently emerged. I was very curious to see how I could use them, in particular because I have a few problems I wasnโ€™t able to solve well enoughโ€”this post details how I was able to use a decision model to apply it to a problem we wish to solve in Microsoft Autopilot and a problem Iโ€™m passionate about solving.

The point of this post is to share how I approached solving this problem, though building a prototype to prove it works. That prototype is now operating 24/7 on my laptop as I continue to learn from it and improve it.

Microsoft Autopilot is our โ€œdigital teammateโ€ product, part of the Copilot family of products. It was first announced at Microsoft Build in June 2026 as โ€œScoutโ€ and was formally rolled out to private preview customers in September 2026. I lead this team and work on many of its features. It sits in the product category today with products like Metaโ€™s Muse, OpenAIโ€™s Dots, Claude Duet, and Grokโ€™s Grok Bot. Autopilot is built on OpenClaw.

I still remember the moment. My manager told me Iโ€™d be getting an Executive Assistant. It was 14 years ago.

An EA. A real person whose whole job was to look after my time.

I pictured it right away. Mornings that started with a calendar that made sense. Someone who knew which meetings mattered and which ones Iโ€™d regret. Someone whoโ€™d quietly say โ€œhe canโ€™t make itโ€ so I didnโ€™t have to. Someone whoโ€™d notice I hadnโ€™t eaten lunch in three days and fix that too. For the first time in my career, I wouldnโ€™t be fighting my calendar alone. Iโ€™d have a partner in being my best self.

That feeling has stuck with me. Itโ€™s a little like being handed time back.

Hereโ€™s the thing, though. Most people will never feel it. Most people never get the partner. They just get the flood: the invites, the updates, the โ€œmoved to 3:30,โ€ the cancellations, and the reschedules of the cancellations.

Thatโ€™s a feature weโ€™re building for Autopilot. Before asking the team to build it, I wanted to live with it. So I used Scout, my AI desktop assistant, to prototype the part of an EA I needed most: the one that reads every invite, decides what to do, and only bothers me when it really needs my judgment.

I wanted to see, how close could I get to something that acted the way I acted.

An EA is one of the most valuable privileges a person at work can have, and one of the scarcest. The best ones know which relationship needs tending, which โ€œquick syncโ€ is really a fire, and when you need to be protected from yourself. I want to give a slice of that to everyone who will never get one, and give the EAs who exist today some of their own time back for exactly that kind of work.

Iโ€™ll show you exactly what goes into the decision model: the features, the JSON, the question schema, and the code that decides when itโ€™s allowed to act on its own.

The flood, in numbers

I pulled 90 days of mail metadata (July 24 to October 22) to see what I was dealing with:

The last two rows tell the story. Every meeting shows up more than three times, as an invite, an update, a โ€œtime changed,โ€ and then a cancellation. Each one is a tiny decision, and each one pulls my attention away from real work.

How EAs actually do it: delegate access

Hereโ€™s the part most people never see. Most executives with an EA donโ€™t read meeting invites at all. Not โ€œskim them.โ€ Not โ€œglance at them.โ€ They never see them.

Thatโ€™s because of a feature thatโ€™s been in Outlook for decades: delegate access. The exec grants their EA delegate rights on their calendar and sometimes their inbox, and then picks one setting that changes everything.

Outlook recommends the first. The executives who really want their time back pick the second. The invite routes to the EA. The EA decides. The EA accepts, declines, or proposes a new time, and the organizer sees the response as โ€œEA on behalf of Exec.โ€ The execโ€™s only interface to the whole mess is the calendar itself, which is now the output of someone elseโ€™s judgment instead of the input to their own.

Think about what that means for the 1,029 emails above. With a good EA on โ€œdelegates only,โ€ the exec sees zero of them. The updates, the โ€œmoved to 3:30,โ€ the cancellations, the reschedules of the cancellations: all absorbed. What the exec gets instead is an occasional โ€œDo you want to do the planning review Thursday, or should I send Sam?โ€ Thatโ€™s it.

Thatโ€™s why this matters so much, and why itโ€™s the design target for the agent:

  1. The calendar is the product, not the inbox. An EAโ€™s job isnโ€™t to sort invites faster. Itโ€™s to make sure the invites never become the execโ€™s problem.
  2. The EA acts with the execโ€™s authority. Delegate rights mean the RSVP is real. The organizer doesnโ€™t get a โ€œlet me check with my boss.โ€ They get an answer.
  3. Escalation is rare and specific. A good EA doesnโ€™t forward the invite back. They ask a question that already has a recommendation in it.
  4. Trust is earned, then extended. New EAs check in a lot. A year in, they just handle it. The permission was there on day one. The judgment took time.

An agent should work exactly like this. Itโ€™s a delegate. It holds the execโ€™s authority within limits, it absorbs the flood, and it only surfaces a decision when the decision is really the execโ€™s to make.

And hereโ€™s the part that gets lost when people talk about agents: EAs drown in this too. An EA who supports one exec is processing those 1,029 emails on their behalf. An EA who supports three is processing three thousand. Most of those decisions are the same handful of judgment calls, made over and over: is this a real conflict, does my exec actually need to be in the room, have we declined this before? Thatโ€™s time an EA isnโ€™t spending on the work only they can do.

So the same agent fits on both sides of the delegate setting. For someone with no EA, it is the delegate. For someone with an EA, itโ€™s the EAโ€™s assistant: it clears the obvious invites, drafts a recommendation with a confidence score on the rest, and hands the EA a short list of real decisions instead of a full inbox. The EA stays in charge. They just stop doing the bookkeeping.

My prototype cheats a little on the plumbing. Instead of a true Outlook delegate, an inbox rule routes every invite into a folder the agent owns, and the agent acts through my own delegated Microsoft Graph access. Functionally itโ€™s the โ€œdelegates onlyโ€ setup: invites go to the assistant, not to me. The Autopilot version is where that becomes a first-class delegate.

What I built

Itโ€™s a meeting triage agent, prototyped in Scout. Scout was the perfect workbench: it already has my mail, calendar, and Teams, it can run a script on a schedule, and I could change the behavior in a conversation instead of a sprint. Every lesson here goes straight into the Autopilot version.

Thatโ€™s the folder from the delegate section: all my invites land in Inbox โ€บ Meeting Requests, never in front of me. The agentโ€™s only job is to empty it.

It runs every 30 minutes, and every pass uses the same five steps:

The heart of it is one Node script, triage.mjs, that reads Microsoft Graph through Work IQ. Scout runs it on a schedule and talks to me in Teams.

Layer 1: Rules handle most of it

Hereโ€™s the first surprise. Most meeting email isnโ€™t a decision at all. Itโ€™s bookkeeping.

So before any AI gets involved, a plain function called classify() checks the invite against a list of rules:

The โ€œalways declineโ€ list is a file I never edit by hand. When I reply to the agent with โ€œalways decline,โ€ it writes the rule for me:

node triage.mjs rule decline "Weekly Vendor Roundup" "Omar said always decline"

Result: 167 of the 236 invites the agent has seen were fully handled by rules. Thatโ€™s 71% with no model call and no question to me.

Layer 2: Turning an invite into features

Hereโ€™s where it gets technical. A raw Outlook invite is a terrible input for a model. Itโ€™s HTML soup, a Teams join footer, a dial-in block, 40 attendees (some of whom are secretly lists of 800 people), and a subject line someone typed in a hurry.

So before anything gets judged, a function called enrich() turns each invite into features. It makes one extra Graph call per invite to get the full event, then derives everything below.

Signal 1: Conflicts, split into firm and soft

Not all conflicts are equal. The classifier splits overlapping events into two buckets:

const firm = others.filter(x => x.showAs !== 'free' && !x.isAllDay && (x.isOrganizer || x.responseStatus?.response === 'accepted') && x.showAs !== 'tentative' && x.showAs !== 'workingElsewhere'); const soft = others.filter(x => !firm.includes(x) && x.showAs !== 'free' && !x.isAllDay);

Firm means I accepted it (or I own it). Soft means itโ€™s sitting there tentative. Each conflict goes to the model with its title, showAs, my response, whether itโ€™s firm, and whether itโ€™s my own block (like a workout). That last flag matters: my own blocks give way to my manager, but nobody elseโ€™s meeting does.

Signal 2: Real audience size

This was the biggest lesson. An invite to all-org-updates@ looks like one attendee. Itโ€™s actually 800 people.

So every attendee address gets resolved against the directory:

const g = found.get(addr); // is it a group? const members = wiqFetch(`/groups/${g.id}/transitiveMembers/$count`); const mine = wiqFetch(`/me/memberOf/microsoft.graph.group?$filter=id eq '${g.id}'`);

Results are cached for 7 days, so each new list costs one lookup. From that, the agent computes totalReach (named people plus every listโ€™s real member count) and buckets it:

It also records invitedVia: โ€œby nameโ€ vs. โ€œdistribution list: Xโ€. Being invited by name to a six-person meeting and being one of 800 on a list are completely different signals, and Outlook shows them the same way.

Signal 3: The agenda, cleaned

The body is HTML. agendaText() strips tags and entities, cuts everything after the Teams join footer, removes every URL and passcode, and caps it at 2,000 characters:

t.split(/_{8,}|Microsoft Teams (?:meeting|Need help)|Join the meeting now|Meeting ID:/i)[0] .replace(/https?:\/\/\S+/g, '') .replace(/\bPasscode:\s*\S+/gi, '')

Join links never help a decision, and theyโ€™re the most sensitive thing in the invite. Gone.

Signal 4: How heavy is that day

dayLoad() looks at every event on the same day: meeting count, busy hours, whether Iโ€™m out of office, all-day items, and a cheap travel check (does any title say flight, hotel, airport, train?). A 30-minute sync on a light Tuesday and the same sync on a 9-hour travel day shouldnโ€™t get the same answer.

Signal 5: Whoโ€™s asking

The organizer gets a relationship label: manager, direct report (pulled live from /me/directReports), colleague, or external. Same for each named attendee.

Signal 6: My history

Two kinds:

Layer 3: The decision model (the part that feels like an EA)

Rules know my calendar. They donโ€™t know me.

A great EA reads the agenda and says โ€œyou should be there, they need a sign-off from you.โ€ They notice Iโ€™m one of 800 on a broadcast I can watch later. They remember I skipped this sync the last three times. Thatโ€™s judgment, and this is where it lives.

Structured questions, not a chat prompt

I didnโ€™t want โ€œhey, what should Omar do?โ€ in a chat window. That gets you a chatty, overconfident paragraph you canโ€™t gate on.

Instead, the decision model is a typed scoring API. You send two things:

  1. state: a JSON object describing the world.
  2. questions: a schema of what you want answered, with a fixed set of choices.

It sends back a choice, a confidence, and a probability for every option. Thatโ€™s the whole contract.

What goes into the state

Hereโ€™s a real request shape, with the values anonymized:

{ "model": "decision-model", "state": { "owner": "the user", "invitation": { "title": "Q4 Planning Review", "organizer": "A. Colleague", "organizerIsManager": false, "external": false, "when": "Thu Oct 29, 2:00 PM", "durationMinutes": 45, "allDay": false, "type": "single meeting", "organizerShowsAs": "busy", "currentResponse": "notResponded", "messageKind": "newMeetingRequest" }, "context": { "agenda": "Review the Q4 plan. Omar to sign off on the staffing section.", "yourRole": "required", "organizerRelation": "colleague", "invitedDirectly": true, "invitedVia": "by name", "distributionLists": 0, "totalReach": 6, "audience": "small group", "namedPeople": 6, "requiredCount": 5, "optionalCount": 1, "externalAttendees": 0, "attendees": [ { "name": "B. Person", "kind": "person", "type": "required", "relation": "direct report", "response": "accepted" } ], "location": "Microsoft Teams Meeting", "online": true, "inPerson": false, "importance": "normal", "recurrence": null, "dayLoad": { "date": "2026-10-29", "meetingsThatDay": 7, "busyHours": 5.5, "youAreOOF": false, "travel": false }, "yourHistoryWithThisMeeting": { "pastDecisionsOnThisMeeting": 3, "accepted": 3, "declined": 0, "keptTentative": 0 } }, "conflicts": [ { "title": "1:1", "showAs": "tentative", "yourResponse": "tentativelyAccepted", "firm": false, "yourOwnBlock": false, "when": "Thu 2:00 PM" } ], "standingRules": [ "Always decline meetings titled \"Weekly Vendor Roundup\"", "Decline anything while he is out of office", "Never accept a whole recurring series without asking", "External meetings: keep tentative, no RSVP" ], "pastVerdicts": [ { "title": "Org All-Hands", "verdict": "keep", "organizerRelation": "colleague", "recurring": true }, { "title": "Design Review", "verdict": "accept", "organizerRelation": "direct report", "recurring": false } ] }, "questions": { "verdict": { "...": "see below" } } }

A few details worth calling out:

What goes into the question

The question is a choice with instructions and a one-line definition for every option:

const QUESTION = { verdict: { type: 'choice', instructions: 'You triage meeting invitations for a busy executive. ...', criteria: { accept: 'He will attend; send an accept.', decline: 'He will not attend; send a decline.', keep: 'Leave it tentative without responding; decide later.', 'archive-only': 'No calendar decision needed; just file the email.', }, }, };

The instructions read a lot like the briefing Iโ€™d give a new EA on day one:

Notice whatโ€™s not in there: no examples of specific meetings, no โ€œOmar likes X.โ€ All of that comes from pastVerdictsand yourHistoryWithThisMeeting. The instructions describe how to think. The state describes who I am. That split is what lets it improve without me editing a prompt.

What comes back

{ "model": "decision-model", "answers": { "verdict": { "choice": "accept", "confidence": 0.94, "probabilities": { "accept": 0.94, "keep": 0.04, "decline": 0.02, "archive-only": 0.00 } } } }

The client is strict about it. If choice isnโ€™t one of the four verdicts, or confidence isnโ€™t a finite number, the answer is thrown out:

if (!a || !VERDICTS.includes(a.choice) || !Number.isFinite(a.confidence)) throw new Error('Invalid answer');

The probabilities matter more than I expected. A 51/49 split between accept and decline is a very different meeting than 94/4/2, even though both โ€œpick accept.โ€

The call itself

Plain fetch, bearer token from an environment variable, two-minute timeout, and retries with linear backoff on 424, 429 and 5xx:

for (let attempt = 0; attempt < 4; attempt++) { response = await fetch(ENDPOINT, { method: 'POST', headers: { Authorization: 'Bearer ' + apiKey, 'Content-Type': 'application/json' }, body: JSON.stringify({ model: MODEL, state, questions: QUESTION }), signal: AbortSignal.timeout(120000), }); if (![424, 429].includes(response.status) && response.status < 500) break; await new Promise(r => setTimeout(r, (attempt + 1) * 2000)); }

Invites are scored four at a time in parallel. A full pass with a dozen judgment calls takes seconds.

Two brains, one verdict

The model never works alone. Before itโ€™s called, the deterministic rules from Layer 1 have already produced an answer. That answer is saved as the fallback, and then the modelโ€™s verdict is merged in:

r.fallback = { action: r.action, reason: r.reason }; const d = await decide(buildState(r, { rules, history })); r.decision1 = d; if (r.hard) { r.reason += `; model said ${d.verdict}, constraint kept`; return; } r.action = d.verdict; r.reason = `model (${Math.round(d.confidence * 100)}%)`; if (d.verdict !== r.fallback.action) r.reason += `; rules said ${r.fallback.action}`; if (d.confidence < 0.6) r.reason += '; low confidence';

In English:

If the model is more than 90% confident, the agent acts. Otherwise it asks me.

Then everything has to pass one bright line:

If the model is more than 90% confident, the agent acts. Otherwise it asks me.

Exactly 90% doesnโ€™t count. A missing or stale score doesnโ€™t count. The verdict has to match the planned action, it canโ€™t contradict anything Iโ€™ve explicitly said, and it never accepts a whole recurring series on its own.

Two invites, side by side

A planning review. Six people, invited by name, agenda says โ€œOmar to sign off,โ€ only a tentative conflict, accepted it three times before. Rules: accept. Model: accept, 94%. The agent accepted it, archived the email, and I never saw it.

A company-wide Q&A. One distribution list (totalReach: 812, audience: broadcast), Iโ€™m optional, and it overlaps a meeting I accepted. Rules: decline (firm conflict). Model: keep tentative, 71%, because itโ€™s a broadcast I can watch later. Under the bar, so it came to me with both answers attached. I picked tentative, and that answer went into pastVerdictsfor next time.

So far the model has judged 30 invites. 17 cleared the bar and were handled without me. It disagreed with the plain rules 12 times, and thatโ€™s the point: the rules know my calendar, the model knows my habits.

Layer 4: Ask once, in Teams

Anything left over turns into one Teams message per meeting, each with an ID:

Q-1031 ยท B ยท Partner sync, Thu 2:00 PM
Suggestion: decline (78%). Conflicts with a confirmed 1:1.

I reply the way Iโ€™d talk to a person:

Approving a meeting is final. The agent doesnโ€™t come back with โ€œare you sure?โ€ A good EA wouldnโ€™t either.

Nothing about this message says it has to come to me. Point it at an EA and it reads the same way: a meeting, a suggestion, a confidence score, and a one-line reply to settle it.

Since October 16 it has asked me 33 questions about 236 invites.

Execute: built to be boring

This step is where I was most paranoid. A few design choices keep it safe:

Verify: the bug that taught me the most

verify re-reads Outlook and wonโ€™t call the run done until the live state matches the plan.

It still missed something. I had declined a large Q&A session, but it was back on my calendar as tentative. Hereโ€™s what happened:

  1. I declined the meeting.
  2. The organizer sent an update.
  3. Outlook made a brand new copy of the event (same meeting ID, new event ID) with my answer reset.
  4. The agent tried to decline the old copy, got a โ€œ404 not found,โ€ and logged it as done.
  5. verify only checked that the email had left the folder, so it passed.

The fix: the agent now looks up every live copy of a meeting by its shared calendar ID. If any copy is still unanswered, verify reports a calendarMismatch, and the next run answers it. A 404 only counts as done when no unanswered copies are left.

An EA would have noticed this just by glancing at the calendar. My agent has to check on purpose. Thatโ€™s the biggest difference between building this and having a person do it.

Learn: every answer pays forward

After each run, my approved accepts and declines are saved as past verdicts. The model reads them next time, so a meeting I declined twice isnโ€™t a 60% coin flip on the third try. Anything I say โ€œalwaysโ€ about becomes a rule, and that meeting leaves the AI layer completely.

Thatโ€™s why the question count keeps dropping. Rules absorb the obvious stuff, history absorbs the habits, and I only see whatโ€™s actually new.

What Iโ€™d tell you if youโ€™re building one

Everyone deserves an EA

The best EAs Iโ€™ve worked with are brilliant at the hard stuff: tradeoffs, relationships, reading the room. Nobody should spend their day on 16 meeting emails, least of all them.

Two things are true at once. Most people never get offered an Executive Assistant. They just get the invites. And the EAs who do exist spend a huge share of their week on exactly the triage this system does. The part of the job that eats the most time is the part software can finally do well, and handing it off makes the scarce thing go further: everyone gets a little of what I got, and every EA gets hours back for the work that actually needs a person.

Thatโ€™s why this isnโ€™t staying a personal hack. The prototype taught us what the Autopilot feature needs: rules first, a real decision model for the judgment calls, a bright line for when it acts, and a habit of asking instead of guessing.

I got that feeling of being handed time back. I want everyone to get it.

My Meeting Requests folder is finally empty.