DEV Community: Bala Madhusoodhanan

Automating Your Weekly Prep with an AI-Powered M365 Briefing with WorkIQ

Bala Madhusoodhanan — Tue, 30 Jun 2026 07:34:00 +0000

Intro:
We've explored the immense potential of Copilot to transform our daily workflows. But what if you could start every week not just prepared, but truly proactive? What if the overwhelming feeling of a Monday morning inbox, the forgotten follow-ups, or the surprise meeting tasks could become a thing of the past? We spend precious hours just sifting through emails, cross-referencing calendars, and trying to recall commitments, all before we even get to the actual work. Here is something evolved over time and the quality of response is amazing when workIQ is enabled.

Structure of the Prompt:
Most productivity loss doesn't happen because people are lazy — it happens because of invisible overhead: the mental energy spent remembering what's pending, deciding what to do next, or realising on Wednesday that something sent on Friday never got a response. This prompt eliminates that overhead systematically

Problem it solves	How
Inbox anxiety	Every actionable thread is surfaced and ranked — nothing lurks
Forgotten follow-ups	Sent Items review catches every unanswered request you made
Meeting unprepared	Category A/B meeting prep flags what needs doing before you walk in
Time blindness	The capacity overview shows next week's shape before it happens
Reactive Mondays	You start the week with a plan, not a pile
Manager communication gaps	The status draft means you never skip this because it takes too long
Distraction patterns	The productivity summary names the patterns so you can change them

GLOBAL SCOPE RULES (apply to every section below)

| Rule | Definition |
|---|---|
| **My identity** | From = me; "To me" = I appear in the To field (not Cc/Bcc only) |
| **Lookback** | Past 7 calendar days from the moment this prompt runs |
| **Lookahead** | Next 7 calendar days from the moment this prompt runs |
| **Deduplication** | Deduplicate conversation threads; represent each thread once using its latest qualifying message |
| **Internal domain** | Infer my organisation's domain from my email address; all other domains = External |
| **Automated exclusions** | Drop items from: noreply / no-reply / do-not-reply / no_reply senders; Teams notification emails (noreply@*.teams.microsoft.com); system alerts; OOO auto-replies (for response-detection only); digests; newsletters; bulk marketing |
| **Broadcast exclusions** | Drop subjects containing: E-Learning, Training reminder, Newsletter, Digest, Notification, Alert, System message, FYI only, Do not reply |
| **Calendar invite exclusions** | Drop calendar auto-notifications unless the body explicitly requests a non-calendar action |

---

## 📤 OUTPUT STRUCTURE

Produce the full report in this exact sequence of sections:

---

### SECTION 1 — 📥 INBOX: Outstanding Actions (Lookback 7 days)

**Purpose:** Surface every email in my Inbox that still requires action from me.

**Scope:**
- Folder: Inbox only (no subfolders, Archive, Junk, Deleted Items)
- Include only threads where I am on **To** (not Cc/Bcc only)
- Represent each thread once using the **latest inbound message** within the lookback window
- Apply all global exclusions above

**Inclusion logic (three tiers):**

| Tier | Condition |
|---|---|
| **@Mentions** | I am explicitly @mentioned in the message body |
| **Unread** | Message is Unread (including "seen on mobile but still Unread") |
| **Read – not replied** | Message is Read but I have NOT sent a reply after the latest inbound (compare my latest Sent timestamp in the thread vs. the latest inbound timestamp) |

**Prioritisation within section:**
1. @Mentions (newest → oldest)
2. Unread, no @mention (newest → oldest)
3. Read, not replied (newest → oldest)

**Output format:**

Start with the heading:

📥 Immediate Action — Inbox

Provide a single continuous numbered list across all tiers.
- Prefix @mention items with **‼️**
- For each item include: **Bold subject**, Sender (display name), Received date/time (local), one-line **Next step**

Then the heading:

📥 Action Required — Inbox

Remaining qualifying items in the same format.

Then:

📥 Other — Inbox

All examined inbox threads NOT included above: Sender – Subject – Received date (to confirm nothing was missed).

---

### SECTION 2 — 📨 SENT ITEMS: Awaiting Responses (Lookback 7 days)

**Purpose:** Surface emails I sent that requested action and have not yet received a meaningful response.

**Scope:**
- Folder: Sent Items only
- From = me; deduplicate threads; use my latest sent message per thread within the lookback window
- Apply all global exclusions

**Inclusion logic:**
- Include only emails where I **requested input, a decision, or a deliverable** (proposal, data, approval, feedback enabling next steps)
- Exclude emails where I only asked for simple confirmation ("Is this okay?") → move to Other
- Exclude emails where I only provided information/deliverables with no expectation of a reply → move to Other
- If mixed informational + action-request content, treat as **action-request**

**Response detection (per thread):**
- Check Inbox for any inbound reply **after** my latest sent timestamp in that thread
- Ignore OOO auto-replies for response detection
- Mark as **"No response yet"** if no qualifying inbound reply exists
- Mark as **"Responded – further action needed"** if an inbound reply exists AND that reply itself requests further action from me

**Prioritisation:**
1. Sent items where I explicitly **@mentioned** a recipient (and requested action) — newest → oldest
2. Sent items requesting action, **no response yet** — newest → oldest; same date → alphabetical by subject

**Internal vs External classification:**
- If ANY recipient is outside my organisation's domain → **External**
- Otherwise → **Internal**

**Output format:**

📨 Immediate Action — Sent Items

🌐 External

🏢 Internal

Prefix @mention items with **‼️**. Numbering is continuous across External + Internal (do not restart).

For each item include: **Bold subject**, Recipient(s) summarised, My latest sent date/time (local), Response status, first ~10 words of my sent body as a snippet, one-line **Next step** (include what I asked for).

📨 Action Required — Sent Items

🌐 External

🏢 Internal

📨 Other — Sent Items

All examined sent threads NOT included above: Recipient(s) – Subject – Sent date.

---

### SECTION 3 — 💬 TEAMS: Unanswered Mentions (Lookback 7 days)

**Purpose:** Surface Teams conversations where I was mentioned and have not replied.

**Scope:**
- Scan all Teams chats and channels where my name was **@mentioned** in the lookback window
- Exclude threads where I have replied **after** the mention
- Exclude automated bot messages and system notifications

**Output format:**

💬 Teams: Unanswered Mentions


For each item: **Bold conversation/channel name**, Mentioned by (display name), Date/time (local), Message snippet (~10 words), one-line **Next step**.

If nothing qualifies: state explicitly.

---

### SECTION 4 — 📊 LOOKBACK PRODUCTIVITY SUMMARY (Past 7 days)

**Purpose:** A concise, honest picture of how I spent my time and where I was most/least productive. Ground in Work IQ / Viva Insights data where available.

Produce the following sub-sections:

#### 4a. ⏱️ Time Distribution — How I Spent My Week

Analyse my calendar and meeting data for the past 7 days. Create meaningful categories that describe how I used my time (e.g., Deep Work, Internal Meetings, External Meetings, 1:1s, Admin & Planning, Learning, Unstructured/Fragmented time). For each category provide:
- Category name and a one-line description
- Estimated hours spent
- Estimated % of working time
- A brief assessment (e.g., "Well-balanced", "Potentially over-indexed", "Under-invested")

Present as a formatted table, then a short paragraph narrative.

#### 4b. 🏆 Key Wins & Decisions Made

List the 3–5 most significant outcomes, decisions, or deliverables completed in the past 7 days. Draw from email threads (closed action items), meeting notes/outcomes, and Teams conversations. Be specific and concise.

#### 4c. 🚧 Blockers & Escalations Identified

List items where progress stalled because I am waiting on others, or where a decision is overdue. Reference the relevant email/thread/meeting so I can act immediately.

#### 4d. 🔍 Collaboration & Interaction Highlights

Summarise the key people I collaborated with most intensely this week (internal and external). Note any collaboration patterns worth paying attention to (e.g., disproportionate time with one stakeholder, gaps in outreach to key contacts).

#### 4e. ⚠️ Distractions & Interruptions

Identify patterns that may have reduced focus time:
- High volume of ad-hoc meeting invitations accepted
- Fragmented calendar blocks (< 30 min between meetings)
- High email response rate outside core hours
- Teams message spikes during deep-work blocks

Provide 2–3 **concrete suggestions** to reduce these distractions next week.

---

### SECTION 5 — 📝 MANAGER STATUS UPDATE DRAFT (Lookback 7 days)

**Purpose:** A ready-to-send (or lightly edited) status update for my manager.

Draw from Sections 1–4 to draft a concise update. Format as an email body (no subject line needed — I will add that). Structure it exactly as:

📝 Draft: Weekly Status Update for My Manager


**Key Wins this week:**
(3–5 bullet points — specific, outcome-focused)

**Decisions Made / Closed:**
(2–3 bullet points — include who was involved)

**Blockers Needing Your Input:**
(List only items where manager action or awareness is genuinely needed; be direct about what you need from them)

**Focus for Next Week:**
(3–5 bullet points — drawn from Section 6 below)

Keep the tone professional but conversational. Total length: 150–250 words.

---

### SECTION 6 — 📅 UPCOMING WEEK: Meeting Preparation (Lookahead 7 days)

**Purpose:** Help me walk into next week fully prepared for every meeting that matters.

Analyse my calendar for the next 7 days. Apply the following classification:

#### Category A — Meetings I Organise (No Agenda Yet) ⚠️

List all meetings where I am the **organiser** and no agenda exists in the invite body. These need attention before the meeting. Sort by date (earliest first).

For each: **Bold meeting title**, Date/time (local), Attendees (summarised), one-line **Suggested agenda action** (e.g., "Draft and send agenda by [day]").

#### Category B — Meetings Where I Am Mentioned / Have Prep Tasks 📌

List meetings where I am **mentioned in the agenda** or where the invite body contains explicit tasks or action items assigned to me. Sort by date.

For each: **Bold meeting title**, Date/time (local), Organiser, the specific task or mention, one-line **Prep action**.

#### Category C — Other Relevant Meetings Requiring Attention 🔔

List any remaining meetings that do not fall into A or B but may still require my attention (e.g., strategic meetings, external client calls, presentations I am part of). **Exclude** routine recurring status meetings or check-ins unless I have a specific task.

For each: **Bold meeting title**, Date/time (local), Organiser, one-line **Why it matters / suggested prep**.

**Output heading:**

📅 Upcoming Week — Meeting Preparation

Category A: I Organise — No Agenda Yet

Category B: I'm Mentioned / Have Prep Tasks

Category C: Other Relevant Meetings


If a category is empty, state that explicitly.

---

### SECTION 7 — 🗓️ UPCOMING WEEK: Time & Capacity Overview (Lookahead 7 days)

**Purpose:** Give me a forward-looking picture of how my time is allocated next week so I can spot imbalances before they happen.

Using my calendar for the next 7 days:

1. **Estimated time in meetings** (hours and % of working week, assuming 40-hour week)
2. **Estimated free/focus time** available (hours and %)
3. **Busiest day** and **lightest day**
4. **Any back-to-back meeting chains** (3+ consecutive meetings with < 15 min break) — flag these explicitly
5. **Recommended focus blocks** — suggest 2–3 specific time slots (day + approximate time) where I should protect deep-work time based on my calendar gaps

Present as a short formatted summary with a brief planning recommendation at the end.

🗓️ Next Week — Capacity & Focus Planning


---

### SECTION 8 — ✅ CONSOLIDATED PRIORITY LIST (Action Checklist)

**Purpose:** One place to see everything I need to do, ranked by urgency. This is the section I act from.

Aggregate all action items from Sections 1–6. De-duplicate any items that appear in multiple sections. Rank using this priority order:

| Priority | Source |
|---|---|
| 🔴 Urgent | @Mentioned emails/Teams not replied + Sent items with deadline risk + No-agenda meetings happening in < 48 hours |
| 🟠 High | Unread emails requiring reply + Awaiting responses blocking progress + Meeting prep for Category A & B |
| 🟡 Medium | Read-not-replied emails + Category C meetings + Manager update draft |
| 🟢 Low / This week | Everything else identified in the report |

✅ Consolidated Priority List — Week of [Date]


Provide a single numbered list across all priorities. Format each line as:

`[Priority emoji] **[Action title]** — Source: [Section ref] — Due/By: [date or "ASAP"]`

---

## 🔒 FORMATTING & QUALITY RULES (apply globally)

- All section headings must appear exactly as written above
- Do not show full recipient/attendee lists — summarise (e.g., "3 recipients incl. [Name]")
- Do not expose email addresses in output — use display names only
- If a section has no qualifying items, state: *"Nothing to action here — you're clear."*
- Keep Next step recommendations to one line; be direct and specific (avoid vague verbs like "consider" or "look into")
- Flag any data gaps (e.g., if Teams data is unavailable, note it and skip that section gracefully)
- Total report should be scannable in under 10 minutes

Work IQ (Microsoft's Viva Insights / Workplace Analytics layer) is what transforms this from a email summary into a genuine productivity intelligence report. Here's specifically what it unlocks for each section:

Section	Without Work IQ	With Work IQ
Time Distribution (4a)	Rough estimates from calendar titles alone	Precise categorisation using meeting metadata, focus time signals, and collaboration patterns
Distractions (4e)	Generic observations	Actual data: after-hours email spikes, fragmented calendar blocks, meeting-acceptance rates, quiet hours violations
Collaboration Highlights (4d)	"You emailed these people"	Network analysis — who you over-collaborated with, who went dark, whether key stakeholders are being neglected
Blockers (4c)	Based on email threads only	Cross-referenced with task signals, missed response SLAs, and meeting outcomes
Capacity Planning (7)	Calendar gap counting	Focus time recommendations grounded in your actual historical deep-work patterns
Manager Update (5)	Reconstructed from memory	Drawn from verified activity data — wins and decisions have evidence behind them

What This Prompt Does
This is a single, scheduled intelligence briefing that runs every Sunday night and gives you a complete picture of the week behind you and the week ahead — without you having to open a single folder, scroll through a single inbox, or reconstruct anything from memory.
In one automated run, it:
Audits your Inbox — finds every thread that still needs action from you, ranked by urgency, with a suggested next step already written
Audits your Sent Items — surfaces emails where you're waiting on someone else, so nothing you kicked off gets forgotten
Scans Teams — catches any @mentions you haven't replied to, which are easy to miss when switching between channels
Summarises your past week — time distribution, key wins, blockers, collaboration patterns, and distractions — so you arrive Monday with self-awareness, not guesswork
Drafts your manager update — a ready-to-send status email built directly from your actual activity data, not from what you can remember on a Friday afternoon
Prepares you for every meeting next week — flags which ones have no agenda (and you're the organiser), which ones have tasks assigned to you, and which ones are strategically important
Maps your capacity — shows where your focus blocks are, where the back-to-back meeting chains are, and where to protect deep-work time before the week fills up
Produces one consolidated action checklist — a single ranked to-do list (🔴🟠🟡🟢) you can open Monday morning and act from immediately
The core idea is simple: you shouldn't have to do the triage yourself. The prompt does the triage; you do the thinking.

Augment intelligence i.e., you shouldn't have to do the triage yourself. The prompt does the triage; you do the thinking.

Transform Raw Data into Visual Insights in Copilot Studio with a Single Skill!

Bala Madhusoodhanan — Mon, 22 Jun 2026 05:42:44 +0000

Intro:
Your agent is a data powerhouse. It connects to APIs, pulls reports, and processes complex queries. But too often, the output looks something like this:

For the end users, this requires the user to actively parse, compare, and mentally visualize trends.

Now with the new Copilot Studio Run time engine, we could leverage Skills to enable this visualisation.

The "Data Visualization & Response Formatting": SkillMd

I've crafted a comprehensive SkillMd (a markdown-based skill definition) that you can drop directly into your Copilot Studio agent. This skill empowers your agent to:

Automatically Detect Data: When a response contains quantifiable data, the skill kicks in.
Smartly Select Charts: It intelligently chooses the best chart type (Pie, Bar, Line, etc.) based on the data's structure.
Render Visuals: It generates beautiful, interactive charts using Mermaid diagrams (which Copilot Studio supports natively!).
Pair with Precision: Every chart is accompanied by a precise markdown table for those who need exact figures.
Deliver Key Insights: It summarizes the most important trends and observations in plain language.
Propose Next Steps: It proactively suggests follow-up questions for deeper analysis.

In essence, this skill turns numbers into narratives. Anytime the agent detects data worth seeing — not just reading — it renders the right chart, pairs it with a precise table, and explains what the numbers mean. It activates automatically, so analysts and leadership get visual-first answers without having to ask.

markdown
# Skill: Data Visualization & Response Formatting

## Description

This skill enables the agent to render data points, metrics, and comparisons as **visual charts and graphs** alongside structured markdown tables. When a response involves quantifiable data (e.g., revenue, units, growth rates, period comparisons), the agent automatically selects the most appropriate chart type and renders it using supported formats such as **Mermaid diagrams**, **HTML/Chart.js snippets**, or **Python code blocks** (matplotlib/plotly) depending on the platform capabilities.


## When this skill is activated:

1. Identify that the user's query involves **quantifiable data points** (e.g., revenue, volume, rates, comparisons across periods or categories).
2. Determine the **most appropriate chart type** based on the data structure (see Chart Selection Guide below).
3. Render the chart using the best available format (Mermaid preferred for markdown environments).
4. Accompany every chart with a **supporting markdown table** containing the exact figures for reference and accessibility.
5. Provide a **"Key Insights"** section summarizing notable trends, highlights, or concerns in plain language.
6. End with a **proactive follow-up question** offering the user a logical next step for deeper analysis.


## Chart Selection Guide

| Data Scenario | Recommended Chart | When to Use |
|---|---|---|
| Comparing values across categories | **Bar Chart** (vertical) | 2–8 categories, single or dual metric |
| Showing change over time | **Line Chart** | 3+ time periods, trend identification |
| Showing proportion or share | **Pie / Donut Chart** | 2–6 categories, parts of a whole |
| Comparing two periods side by side | **Grouped Bar Chart** | Period-over-period comparison |
| Showing ranking or sorted performance | **Horizontal Bar Chart** | Ranking items by a single metric |
| Displaying distribution or variance | **Stacked Bar Chart** | Breakdown of a total across sub-categories |
| Single KPI or headline metric | **KPI Card (bold text block)** | One standout number with context |


## Rendering Formats (Priority Order)

### 1. Mermaid Diagrams (Preferred)
Use Mermaid syntax for environments that support it. Wrap in a fenced code block with `mermaid` language tag.

**Bar Chart Example:**

~~~
mermaid
xychart-beta
    title "Sales by Category — Current vs Prior Period"
    x-axis ["Category A", "Category B"]
    y-axis "Value" 0 --> 100
    bar [64.5, 16.4]
    bar [67.9, 16.2]

~~~plaintext

**Pie Chart Example:**

~~~
mermaid
pie title Share by Category — Current Period
    "Category A" : 54
    "Category B" : 31
    "Category C" : 15

~~~plaintext

**Line Chart Example:**

~~~
mermaid
xychart-beta
    title "Performance Trend Over Time"
    x-axis ["Period 1", "Period 2", "Period 3", "Period 4", "Period 5", "Period 6"]
    y-axis "Value" 50 --> 90
    line [62.3, 68.1, 71.4, 65.9, 67.9, 70.2]

~~~python

### 2. Python Code Blocks (Fallback)
If Mermaid is not supported, provide a ready-to-run Python code block using `matplotlib` or `plotly`.

~~~
python
import matplotlib.pyplot as plt

categories = ['Category A', 'Category B']
current = [64.5, 16.4]
prior = [67.9, 16.2]

x = range(len(categories))
width = 0.35

fig, ax = plt.subplots()
ax.bar([i - width/2 for i in x], current, width, label='Current Period', color='#1a1a1a')
ax.bar([i + width/2 for i in x], prior, width, label='Prior Period', color='#c4a35a')

ax.set_ylabel('Value')
ax.set_title('Performance — Current vs Prior Period')
ax.set_xticks(x)
ax.set_xticklabels(categories)
ax.legend()
plt.tight_layout()
plt.show()

~~~html

### 3. HTML/Chart.js Snippet (Web Environments)
For web-based agent interfaces that render HTML.


## Formatting & Style Rules

- **Always pair a chart with a data table** — charts for quick visual insight, tables for exact numbers.
- **Chart titles** must clearly state: metric, period, and unit of measure (e.g., *"Revenue — Current vs Prior Period (USD)"*).
- **Number formatting** in tables:
  - Currency: `$XX,XXX,XXX` (with commas)
  - Units: `XX,XXX` (with commas)
  - Percentages: `+X.X%` or `-X.X%` (always show sign)
  - Changes: prefix with `+` or `-` to indicate direction
- **Key Insights** should be **2–4 bullet points**, each tied to a specific visual observation.
- **Follow-up suggestions** should guide toward deeper or adjacent analysis.


## Examples

### Example 1: Multi-Category Period Comparison (Bar Chart + Table)

**User request:** *"Show me Category A and Category B results for the current period vs the prior period"*

**Expected behavior:**

> The agent renders a **grouped bar chart** comparing both categories across the two periods, followed by a detailed table:

~~~
mermaid
xychart-beta
    title "Revenue — Current vs Prior Period"
    x-axis ["Category A", "Category B"]
    y-axis "Revenue" 0 --> 80
    bar [64.5, 16.4]
    bar [67.9, 16.2]

~~~markdown

> **Revenue Summary**
>
> | Category | Current Period | Prior Period | Change ($) | Change (%) |
> |----------|---------------|--------------|------------|------------|
> | Category A | $64,461,922 | $67,850,448 | -$3,388,526 | -5.0% |
> | Category B | $16,449,638 | $16,162,736 | +$286,901 | +1.8% |
>
> **Key Insights**
> - **Category A** declined 5.0% — visible in the chart as a shorter bar vs the prior period.
> - **Category B** grew modestly at +1.8%, nearly flat visually but positive momentum.
>
> *Would you like a deeper breakdown by sub-category or a trend view across multiple periods?*


### Example 2: Trend Over Time (Line Chart)

**User request:** *"Show me the performance trend for the last 6 periods"*

**Expected behavior:**

> The agent renders a **line chart** showing the trajectory, followed by the data table:

~~~
mermaid
xychart-beta
    title "Performance Trend — Last 6 Periods"
    x-axis ["P1", "P2", "P3", "P4", "P5", "P6"]
    y-axis "Value" 50 --> 90
    line [62.3, 67.9, 70.2, 74.5, 68.1, 64.5]

~~~markdown

> | Period | Value | Period-over-Period Change (%) |
> |--------|-------|------------------------------|
> | P1 | $62,300,000 | — |
> | P2 | $67,900,000 | +9.0% |
> | P3 | $70,200,000 | +3.4% |
> | P4 | $74,500,000 | +6.1% |
> | P5 | $68,100,000 | -8.6% |
> | P6 | $64,500,000 | -5.3% |
>
> **Key Insights**
> - Performance peaked in **P4** at $74.5M before declining for two consecutive periods.
> - The downward trend (-8.6% → -5.3%) suggests softening performance — worth investigating the underlying drivers.
>
> *Would you like me to overlay a forecast line or break this down by sub-category?*


### Example 3: Proportional Share (Pie Chart)

**User request:** *"What's the share breakdown by category for the current period?"*

**Expected behavior:**

> The agent renders a **pie chart** showing proportional share:

~~~
mermaid
pie title Share by Category — Current Period
    "Category A" : 54
    "Category B" : 31
    "Category C" : 15
~~~

> | Category | Value | Share (%) |
> |----------|-------|-----------|
> | Category A | $285,400,000 | 54% |
> | Category B | $163,900,000 | 31% |
> | Category C | $79,300,000 | 15% |
> | **Total** | **$528,600,000** | **100%** |
>
> **Key Insights**
> - **Category A** is the dominant contributor at 54% of the total.
> - **Category B** contributes nearly a third — any softness here materially impacts the overall number.
>
> *Would you like to see how this split has shifted compared to the prior period?*


### Example 4: Data Not Available

**User request:** *"Chart the margin breakdown for this segment"*

**Expected behavior:**

> I'm sorry, margin data for that segment is not available in my current dataset. I can visualize **revenue** and **volume** breakdowns with charts and tables. Would that be helpful?


## Notes

- This skill activates **automatically** when the agent detects **2+ comparable data points** — the user does not need to explicitly request a chart.
- For **single data points** with no comparison, use a **KPI-style bold text block** instead of a chart, and prompt the user for a comparison dimension.
- **Charts and tables are complementary** — never render a chart without an accompanying data table.
- The **follow-up question** should guide toward a deeper or adjacent analysis, never repeating what was already shown.
- When the rendering environment doesn't support Mermaid, fall back to Python code blocks with clear instructions.
- All figures must be **grounded in source data** — never fabricate or estimate values to populate a chart.

plaintext

Empower your Copilot Studio agent with visual intelligence:

pie title Revenue Composition (Q1–Q3 2026)
    "Software (£)" : 20000
    "Hardware (£)" : 12000
    "Services (£)" : 7500

Navigating the New Copilot Studio: A "Good, Bad, and Nitty-Gritty" First Look

Bala Madhusoodhanan — Tue, 16 Jun 2026 07:23:00 +0000

Intro:
The latest iteration of Copilot Studio has landed (announced last week at MSFT BUILD 26, promising a transformative experience in agent building. As with any significant overhaul, it brings a mix of innovation and growing pains. To objectively assess this new landscape, let's apply a simple, yet powerful, mental model: the Good, the Bad, and the Nitty-Gritty. This framework helps us highlight the triumphs, confront the challenges, and identify the essential, sometimes less glamorous, tasks required to move forward.

Highlights (The Good): Embracing the Future of AI Agents
The new Copilot Studio shines brightest with its underlying technological advancements and user-centric features designed to streamline agent development.

A Powerful New Orchestrator: At its heart lies a robust orchestrator, powered by Claude, boasting direct access to Bash, Python, and Node environments. This opens up a world of possibilities for complex scripting and integrations. It even comes pre-packed with built-in skills for handling common document types like Excel, CSV, PDF, DOCX, and PowerPoint extraction.
Intelligent Memory: A game-changer for conversational AI, the new Memory feature allows agents to recall user preferences and conversational context across multiple sessions. Imagine an agent that genuinely remembers your role or preferences, eliminating repetitive inputs.
Dynamic Skills Creation: The new "Skills" concept is a powerful way to encapsulate agent capabilities. What's truly impressive is the ability to refine these skills through natural language prompting in the preview mode, with the agent automatically generating the necessary skill.md file. This democratizes complex agent programming.
Reimagined Workflows: Power Automate flows have evolved into "Workflows," offering sequenced actions, conditional branching, and loops. This not only provides a more structured way to build complex agent logic but also serves as the new, more organized home for triggering autonomous agents.
Enhanced User Experience & Safety: The new Preview canvas now includes a helpful latency readout, giving developers real-time insights into agent response times. Furthermore, safety and moderation features have been improved with a wider, more granular range of levels.
Effortless File Generation: The orchestrator's ability to generate downloadable HTML and Excel files directly from agent interactions, without requiring manual coding, is a testament to its advanced automation capabilities.
Flexible Knowledge Integration: While the direct Dataverse knowledge option is absent, the Dataverse MCP tool effectively fills the gap. The prominent "Public Websites" toggle ensures agents can access up-to-date information via Bing search, and the ability to upload unstructured PDFs as knowledge sources adds significant versatility.

Challenges (The Bad): Missing Pieces and Friction Points:
Despite its innovations, the Version 1 release of Copilot Studio presents some notable hurdles and missing functionalities that power users will undoubtedly feel.

The Demise of "Topics": Perhaps the most significant "bad" news is the complete removal of "Topics." These were the bedrock of structured conversational trees, enabling pre-programmed messages and questions. Their absence creates a void for precise conversational control.
Loss of "Solution-First" Building: The new "New Agent" button immediately drops you into the build workspace, removing the initial option to select a solution and schema name. This can disrupt established development workflows for those who prioritize a structured project setup.
Hidden & Relocated Features: The "Tools" section, once highly visible, is now less prominent. Environment selection has moved, and suggested prompts and settings are tucked deep within the settings menu, requiring more navigation to find.
Limited Evaluation Options: The new "Evaluate" mode, while promising, currently only supports quick question sets and general quality testing, lacking the diverse metrics available in the classic experience. Debugging is also largely confined to the live preview window, with no separate activity history tab.
Conversation Routing Limitations: The reliance on heavy natural language prompting for conversation routing, coupled with limited or broken Adaptive Card button selection, can make precise control challenging.
Specific Syntax for Skills: While powerful, the requirement for strictly lowercase/hyphen naming syntax for skills, and the absence of forward-slash shortcuts for linking assets, introduces minor friction points.
Missing Channel Integrations: Some familiar channel integrations, like SharePoint, are currently missing from the "Publish" dropdown.
No Inline Child Agents: The ability to create child agents that existed only within the context of a parent agent has been removed.

The Heavy Lifting Ahead:

Re-evaluating Conversational Design: For those heavily reliant on "Topics," the immediate "ugly" choices involve either reverting to the classic experience (and foregoing the new orchestrator's benefits) or the heavy lift of attempting to embed structured conversations directly into agent instructions and skills. There's a glimmer of hope that future "Workflows" might reintroduce similar node-based conversational control.
Advocating for Change: The most critical "ugly" task falls on power users: submitting formal feedback and Design Change Requests (DCRs) to Microsoft. The author explicitly states this is crucial to ensure that essential functionalities return before general adoption. Your voice is vital.
Adapting to New Paradigms: Users must embrace the new approach to skill creation—iteratively prompting the agent to refine capabilities and generate skill.md files. Similarly, understanding and leveraging the new "Workflows" feature is no longer optional but a fundamental part of building robust agents.
Rethinking Multi-Agent Architectures: With inline child agents gone, the "ugly" reality is a shift towards building standalone child agents and connecting them, or fully embracing "Skills" as the primary replacement for modularizing agent capabilities.

A Promising, Yet Evolving Platform:
The new Copilot Studio is a bold step forward, bringing powerful AI orchestration and intelligent features to the forefront. However, it's clearly a Version 1.0. While the "good" aspects promise an exciting future, the "bad" reveals areas of regression that demand attention. The "ugly" truth is that shaping this future requires users to roll up their sleeves, adapt to new paradigms, and actively provide feedback. By doing so, we can collectively help guide Copilot Studio into becoming the truly comprehensive and intuitive agent-building platform it aspires to be.

Beyond the Hype: How Millions of Employees Are Actually Using AI at Work

Bala Madhusoodhanan — Mon, 01 Jun 2026 22:57:12 +0000

Intro:
The paper, "AI in the Enterprise: How People Use M365 Copilot Chat," provides one of the clearest views yet into how artificial intelligence is being integrated into the daily workflows of millions of employees across more than a million companies, including nearly 70% of the Fortune 500. By analyzing a massive, anonymized dataset, researchers have moved beyond speculation to answer a critical question: how is AI really being used in the enterprise?

What Are People Using AI For?:
The research team classified millions of user prompts into distinct "intents," revealing the most common ways people turn to their AI assistant. The analysis shows that two categories dominate, accounting for nearly 60% of all interactions: Information Inquiry (asking questions) and Content Refinement (editing and improving existing text)

These are followed by other crucial work activities like generating new content, programming assistance, and analytical reasoning. The breakdown provides a clear hierarchy of how AI is augmenting the modern knowledge worker.

A visual breakdown of M365 copilot usage

Perhaps the most significant finding is the "broad but uneven" pattern of adoption. Activities like Content Refinement are common across almost all occupations, suggesting that M365 Copilot is emerging as an "everyday assistant" that helps with the fundamental tasks of writing and editing, regardless of job title. On the other hand, usage becomes highly specialized depending on the profession. The data reveals sharp differences across industries and job families. For example:

Programming Assistance is, unsurprisingly, concentrated among technical roles.
Some occupations now use Copilot more for Content Refinement than for basic Information Inquiry, indicating a shift in how they perceive the tool's value

This dual nature shows AI acting as both a general-purpose utility and a powerful, role-specific specialist tool.

The Next Frontier for AI in the Enterprise
The study also points to a potential evolution in user behavior: a subtle shift away from "chat as search." Researchers observed a 5% relative drop in the share of "Information Inquiry" over the 114-day study period, suggesting that as users become more sophisticated, they move beyond simple questions toward more complex content and communication-related work

More importantly, the "uneven" adoption highlights the next frontier for AI. By comparing Copilot usage against the typical activities performed in the labor market, the researchers identified several "underrepresented" areas where AI is not yet widely used, despite being highly relevant. These include:

Documenting and Recording Information
Work activities related to evaluating the quality or accuracy of data, particularly in the Banking industry
A significant portion of tasks common in the Consulting industry

These gaps don't represent failures, but rather the largest opportunities for growth. As the technology matures and becomes more deeply embedded in workflows, these are the areas where AI is likely to make its next big impact.

The study concludes that enterprise AI is past the "novelty stage" and has become a substantive part of day-to-day knowledge work. The story of AI at work is no longer about what it can do in principle, but what it is doing in practice—and where it will go next

Reference:
AI in the Enterprise: How People Use M365 Copilot Chat

Prompt Engineering for Automated Evaluation: Making LLMs the Judge in AI Builder Solutions

Bala Madhusoodhanan — Mon, 25 May 2026 07:15:49 +0000

Intro:
Automated evaluation is fast becoming a necessity as AI-driven agents proliferate across business processes. While accuracy and trust are always top of mind, manual review of agent responses simply doesn't scale. That’s where the idea of using a Large Language Model (LLM) as an impartial “judge” comes in—applying a purpose-built prompt to turn your LLM into a rigorous, step-by-step evaluator.
I've previously experimented with extraction and evaluation frameworks which focused on structured data and document extraction.

Bala Madhusoodhanan

Aug 18 '25

From Extraction to Assurance:Extraction Meets Evaluation

#aibuilder #powerautomate #powerplatform #llm

3 min read

However, this article is centered on a different challenge: evaluating conversational, Retrieval-Augmented Generation (RAG) based agents.

Let me share a battle-tested evaluation prompt designed for these agents. Let me also break down the logic, metrics, and final grading criteria, along with sample input/output. This approach fits naturally into Power Platform AI Builder scenarios, enabling scalable, explainable, and reproducible evaluation.

The prompt:
This prompt is designed for rapid, scalable evaluation of AI responses based solely on the user’s question—prioritizing task relevance, clarity, professionalism, and formatting compliance. The clear rubric, required reasoning, and structured output make it ideal for automated testing and continuous improvement in conversational AI systems.

Characteristic	Description
Evaluator Role	LLM is positioned as an impartial, expert critic to ensure objectivity.
Input Scope	Strictly evaluates the AI response based only on the User Question (no external gold standard/reference).
Metrics (Rubric)	Four focused metrics: 1. Task Fulfillment (1–5) 2. Conciseness (1–5) 3. Professional Tone (0/1) 4. Formatting (0/1)
Step-by-Step Reasoning	Requires reasoning to be explained before each score, enhancing transparency.
Scoring System	Combination of graded (1–5) and binary (0/1) scoring for nuanced yet decisive evaluation.
Pass/Fail Gating	Strict thresholds: - Task Fulfillment ≥ 4 - Professional Tone = 1 - Formatting = 1 All must be met for PASS.
Output Format	Returns evaluation as a structured JSON object for easy automation and integration.
Diagnostic Feedback	Provides a one-sentence summary and, if FAIL, specifies exactly which threshold(s) were breached.
Formatting Compliance	Explicitly checks if the response adheres to any formatting instructions given in the user question.

You are an impartial, expert Evaluation AI. Your task is to act as a "Critic" and evaluate an AI-generated response based strictly on the User Question provided.

You will evaluate the response across four specific metrics. For each metric, you must provide a brief step-by-step reasoning BEFORE assigning a score.

THE RUBRIC:

Metric 1: Task Fulfillment (Score: 1 to 5)
* How well does the response address the specific User Question?
* 5 = Comprehensive and perfectly tailored. 3 = Partially answers. 1 = Fails to address the question.

Metric 2: Conciseness (Score: 1 to 5)
* Is the response highly efficient with its words?
* 5 = Dense and to the point. 1 = Rambling, repetitive, or includes unnecessary fluff.

Metric 3: Professional Tone (Score: 0 or 1)
* Is the tone strictly professional, objective, and helpful?
* 1 = Pass. 0 = Fail (Emotional, sarcastic, overly informal, or rude).

Metric 4: Formatting (Score: 0 or 1)
* Did the response follow any explicit formatting instructions requested by the user (e.g., "bullet points", "JSON", "short paragraph")?
* 1 = Pass (or no formatting was requested). 0 = Fail (Explicit formatting instructions were ignored).

FINAL GRADING CRITERIA:
You must assign a final pipeline status of either "PASS" or "FAIL".
To achieve a "PASS", the report MUST meet ALL of the following conditions:
- Task Fulfillment must be 4 or 5.
- Professional Tone must be 1.
- Formatting must be 1.

INPUT DATA:
<user_question>
{{USER_QUESTION}}
</user_question>

<response_to_evaluate>
{{LLM_RESPONSE}}
</response_to_evaluate>

OUTPUT FORMAT:
Output your evaluation strictly as a valid JSON object.
{
  "evaluation_report": {
    "metrics": {
      "task_fulfillment": {"reasoning": "...", "score": <1 to 5>},
      "conciseness": {"reasoning": "...", "score": <1 to 5>},
      "professional_tone": {"reasoning": "...", "score": <0 or 1>},
      "formatting": {"reasoning": "...", "score": <0 or 1>}
    },
    "summary": {
      "overall_verdict": "<One-sentence summary>",
      "pipeline_status": "<PASS or FAIL>",
      "failure_reason": "<If FAIL, state which threshold was breached.>"
    }
  }
}

LLM Output:

{
  "evaluation_report": {
    "metrics": {
      "factual_consistency": {"reasoning": "...", "score": 1},
      "entity_fabrication": {"reasoning": "...", "score": 1},
      "citation_traceability": {"reasoning": "...", "score": 1},
      "reference_alignment": {"reasoning": "...", "score": 5},
      "task_fulfillment": {"reasoning": "...", "score": 5},
      "completeness": {"reasoning": "...", "score": 5},
      "conciseness": {"reasoning": "...", "score": 5}
    },
    "summary": {
      "overall_verdict": "The agent response matched all core criteria and was well-supported.",
      "pipeline_status": "PASS",
      "failure_reason": null
    }
  }
}

Closing thoughts:
'LLM-as-a-Judge' evaluation prompt is designed to automate the QA of our conversational agent. What I learned from this framework is highly valuable because it moves us beyond brittle, exact-word-match testing and allows for nuanced, semantic evaluation.

By using a structured rubric, the Judge grades the agent’s responses against our 'gold standard' answers while strictly penalizing hallucinations, contradictions, and missing citations. Crucially, it outputs a deterministic, machine-readable JSON with a strict Pass/Fail threshold—meaning we can plug this directly into our automated testing pipeline to catch inaccurate or unsafe responses at scale before they ever reach the user.

Reference and Inspiration:
1 - A Survey on LLM-as-a-Judge
2 - Human-like Summarization Evaluation with ChatGPT
3 - Shepherd: A Critic for Language Model Generation
4 - The Rubric Revolution

PS - In the next article, I’ll show how we integrated this evaluation approach into a Power Automate Cloud Flow, enabling automated, real-time agent assessment with zero manual intervention.

The Chimp Paradox - Prof Steve Peters

Bala Madhusoodhanan — Tue, 19 May 2026 22:16:10 +0000

How One Setting Transforms Your Bot's UX: Unveiling Copilot Studio's Latency Message

Bala Madhusoodhanan — Mon, 11 May 2026 05:50:00 +0000

A few weeks ago in my Bite-Sized Wizardry series, I explored the common challenge of nandling Lingering Conversations Gracefully in Microsoft Copilot Studio specially with classic orchestration.

Bala Madhusoodhanan

Mar 30

Stop the Awkward Silence: Signals to Classic Orchestration

#copilotstudio #powerfuldevs #powerplatform

2 min read

At the time, I focused on building custom workarounds. However, whether it was a feature I missed or one that has been recently enhanced, I've since found a built-in piece of magic that directly addresses this: the Latency Message.

How to Cast the Spell:
Find the Latency Message Section With the node selected, look at its properties pane on the right-hand side of the screen. Scroll down until you find the section titled Latency Message, just like the one highlighted in the screenshot. Check the box next to Send a message.

In the text field that appears, type the reassuring message you want your users to see while they wait.

Some powerful incantations include:

"Just a moment while I consult the archives..."
"Let me look that up for you..."
"Searching our knowledge base now, please wait..."

And that's it! The copilot will now automatically display this message while the action is in progress.

The Latency Message is a perfect example of a low-effort, high-impact feature. It doesn't change what your bot does, but it fundamentally improves how it feels to interact with.
By providing this simple piece of feedback, you transform your copilot from a simple tool into a polished, professional, and genuinely conversational assistant.

The Choice Column Conundrum:A Data Migrator's Essential Tip

Bala Madhusoodhanan — Tue, 28 Apr 2026 17:13:54 +0000

Intro:
This week we are diving into a common scenario that often leaves even seasoned data professionals scratching their heads: handling choice columns during data migration or integration. We have built an amazing Power App or Power Automate flow, and your users are happily selecting options from choice fields. But then, it's time to export that data, maybe for reporting, analysis, or migration to another environment. And that's when the "aha!" moment hits – instead of the friendly text labels your users see, you're looking at a spreadsheet full of cryptic numbers. What gives?

The truth is, Dataverse (the underlying data service for Power Apps) stores choice options as integer values, not the user-friendly text labels. These labels are merely a display layer for the end-user experience. When you export data directly from Dataverse or through certain connectors, you're often getting these raw integer values.
However, it presents a significant hurdle when you need to provide human-readable data or ensure smooth re-import into another system where labels might be expected. Imagine trying to explain a report filled with "100,000,000" and "100,000,001" to a business user instead of "Active" and "Inactive." Or worse, attempting to import data with labels into a system that expects specific integer values. It's a recipe for errors, frustration, and extra manual work.

GET {{EnvironmentURL}}/api/data/v9.2/EntityDefinitions(LogicalName='YourEntityName')/Attributes/Microsoft.Dynamics.CRM.MultiSelectPicklistAttributeMetadata?$select=LogicalName&$expand=OptionSet($select=Options),GlobalOptionSet($select=Options)

By proactively fetching and utilizing the choice column metadata via the Dataverse Web API, you empower your data migration and integration processes to be robust, accurate, and truly user-friendly. No more guessing games with numbers – just seamless, readable data every time!

Same as Ever - Morgan Housel

Bala Madhusoodhanan — Mon, 20 Apr 2026 17:58:52 +0000

The book’s core idea is simple yet profound: to understand the future, we must look at the things that never change. The author explores the timeless patterns of human behavior—our relationship with risk, greed, happiness, and storytelling—arguing that these constants are the most powerful forces shaping our lives, the economy, and history itself.

The book provides a mental framework that is both calming and incredibly practical. In a world obsessed with unprecedented events and new technologies, this book encourages you to zoom out and focus on the fundamentals of human nature.
It’s a must-read for anyone who wants to:

Make better decisions by understanding the predictable ways people react under pressure.
Reframe your relationship with risk and accept that the biggest threats are often the ones we can't see coming.
Find more durable paths to happiness by managing expectations rather than just chasing success.
Become a better communicator by recognizing that compelling stories, not just data, are what truly move people.

How Conversation Memory Improves Conversation experience

Bala Madhusoodhanan — Mon, 13 Apr 2026 04:55:33 +0000

Intro:
Introduction Better search queries and prefer? carefully chosen keywords are essential when building Reliably Retrieval-Augmented Generation (RAG) agents in Copilot Studio. LLMs are powerful, but their outputs depend heavily on the information they retrieve at runtime: if the retrieval is off—because the query is vague or lacks domain context—the LLM can hallucinate, produce irrelevant results, or miss critical legal/regulatory nuance. Well-formed queries minimize hallucinations, improve retrieval precision, reduce wasted compute, and maintain context across multi-turn conversations. This post describes a small experiment comparing retrieval query quality with conversation memory enabled versus disabled and synthesizes practical takeaways for Copilot Studio users.

Experimental setup
Goal: Test how including conversation history (memory) affects the search queries that the query-generation component produces and therefore the relevance of retrieved RAG documents.

Source / domain used in evaluation: legal/regulatory text (example: EU AI Act) — representative of domains that rely on precise terminology and structured references.

Bala Madhusoodhanan

Mar 17

Beyond Vector Search: Building a "Reasoning Engine" in Copilot Studio

#copilotstudio #powerfuldevs #systemdesign #powerplatform

32 min read

RAG platform: Copilot Studio (using the "Create search query" component that builds queries from user input + optional conversation history).

Two configurations:
Memory ON: include 3 past messages from the current conversation in the query-generation step.
Memory OFF: do not include conversation history (fresh query from each user message).

Interaction thread used (Startup Journey) — five turns:

We're building an AI tool that screens job applicants' CVs. Does the EU AI Act apply to us?
You mentioned it's high-risk. What exactly does that mean for us in practice?
What documents do we need to prepare before we can launch?
Who needs to sign off on that documentation — us or a third party?
And what happens if we launch without doing any of this?

Observations:

Scenario	Question	Key Word Search	Search Query
Memory with 3 past messages from the current conversation's history to include.	"We're building an AI tool that screens job applicants' CVs. Does the EU AI Act apply to us?"	EU AI Act applicability AI tool screening job applicants CVs	We're building an AI tool that screens job applicants' CVs. Does the EU AI Act apply to our tool?
Memory with 3 past messages from the current conversation's history to include.	"You mentioned it's high-risk. What exactly does that mean for us in practice?"	EU AI Act high-risk requirements CV screening practical implications	You mentioned that our AI tool for screening job applicants' CVs would be considered high-risk under the EU AI Act. What does being classified as high-risk mean for us in practical terms?
Memory with 3 past messages from the current conversation's history to include.	What documents do we need to prepare before we can launch?	Required documents high-risk AI tool EU AI Act launch	What documents do we need to prepare before launching our high-risk AI tool for screening job applicants’ CVs under the EU AI Act?
Memory with 3 past messages from the current conversation's history to include.	"Who needs to sign off on that documentation — us or a third party?"	EU AI Act high-risk AI documentation sign off provider third party	Who is responsible for signing off on the required documentation for launching a high-risk AI tool under the EU AI Act—do we, as the provider, need to approve it ourselves, or does a third party need to be involved?
Memory with 3 past messages from the current conversation's history to include.	And what happens if we launch without doing any of this?	EU AI Act consequences launch high-risk AI tool without documentation compliance	What are the consequences if we launch our high-risk AI tool for CV screening without preparing the required documentation and compliance steps under the EU AI Act?
No memory	"We're building an AI tool that screens job applicants' CVs. Does the EU AI Act apply to us?"	EU AI Act applicability AI tool screening job applicants CVs	We are developing an AI tool that screens job applicants' CVs. Does the EU AI Act apply to our project?
No memory	"You mentioned it's high-risk. What exactly does that mean for us in practice?"	high-risk meaning practical implications	You mentioned it's high-risk. What exactly does "high-risk" mean for us in practice?
No memory	What documents do we need to prepare before we can launch?	documents needed prepare before launch	What documents do we need to prepare before we can launch?
No memory	"Who needs to sign off on that documentation — us or a third party?"	documentation sign off responsible us third party approval	Who is responsible for signing off on that documentation—do we need to sign it ourselves, or does a third party need to provide approval?
No memory	And what happens if we launch without doing any of this?	consequences launch without preparation risks	What are the potential consequences if we proceed with the launch without completing any of the recommended steps or preparations?

Key analysis & characteristics:

Domain anchoring: When conversation context (e.g., topic, dataset, or domain) is preserved, subsequent queries stay focused on the same subject. Without that anchor, later turns drift toward generic wording and can retrieve off-topic material.
Pronoun & reference resolution: Memory enables the system to resolve implicit references (“it”, “that document”, “the tool”) into concrete entities tied to the ongoing conversation. Without memory, follow-ups become ambiguous and require the user to restate context.
Terminology carry-over: Repeating or preserving precise domain vocabulary (technical terms, roles, artifacts) across turns improves the chance that retrieval will match indexed content. If history isn’t included, these specific terms tend to drop out and be replaced by vague synonyms.
Query specificity and evolution: With memory, queries often become richer and more targeted as the dialog proceeds (the model can refine intent). Without memory, query specificity typically decays over turns, reducing retrieval precision.
Retrieval precision and downstream quality: Because retrieval is the upstream signal for generation, better-focused queries produce higher-quality retrieved items; that in turn reduces hallucinations and improves final answer accuracy.
Degradation pattern: Conversations that rely on assumed context show a consistent decay in query usefulness when history is excluded — the further from the initial turn, the weaker the query signal.

Characteristic	Memory Included	No Memory
Domain anchoring	✅ Persistent across turns	❌ Lost after initial message
Pronoun & reference resolution	✅ Resolved to concrete entities	❌ Remains ambiguous
Terminology preservation	✅ Specific terms persist	❌ Specific terms drop out
Query specificity	✅ Becomes more focused / refined	📉 Becomes generic over turns
Retrieval precision (expected)	✅ Higher, more relevant results	⚠️ Lower, more irrelevant results
Downstream generation quality	✅ More accurate, fewer hallucinations	⚠️ Prone to errors and omissions

Closing Remarks:
Memory (or otherwise preserving context) is a practical lever for improving RAG systems in any domain that relies on precise language or multi‑turn interaction. If your application requires follow-ups, conditional reasoning, or references to previously introduced entities, include a small, targeted history window (or re-anchor the context manually) so the query generator can produce focused searches. For robust evaluation, instrument metrics such as precision, relevance ratings, and hallucination frequency; vary the history window to observe the tradeoff between context usefulness and prompt/token cost.

Is Your Code Eco-Friendly? A proxy to understand Carbon Impact

Bala Madhusoodhanan — Tue, 07 Apr 2026 08:32:57 +0000

Intro:
We spend countless hours optimizing for performance, scalability, and user experience. But how often do we consider the environmental impact of the code we write? As AI payloads grow and data flows increase, every API call, every byte transferred, contributes to a larger digital footprint. It's time we started thinking about the carbon cost of our digital endeavors.
This isn't about guilt-tripping; it's about awareness and providing you with a practical way to quantify something often overlooked. What if you could estimate the CO₂ emissions generated by a simple API request? You can, and it's simpler than you might think, thanks to some clever open-source work.

The Code Snippet:
The calculation utilizes the co2.js library , maintained by The Green Web Foundation, relying on their 1byte Model (Sustainable Web Design model).

Here's what's happening:

Byte Counting: The browser takes the JSON you're sending to and receiving from the API. It converts them to raw text strings and uses the native Blob API to count the exact bytes.
Energy Estimation & Carbon Conversion: The co2.js library takes that total byte count and estimates the electricity needed to move that data, then converts it to grams of CO₂ equivalent (CO₂e) based on a global average carbon intensity for the electrical grid.

It's crucial to understand that co2.js doesn't magically know the exact location of every server or the real-time power consumption of your user's device. Instead, it uses a highly researched framework called the Sustainable Web Design (SWD) model as a proxy for these complex realities.

Global Average Carbon Intensity: By default, the model assumes a global average grid intensity (historically around 442 grams of CO₂ per kilowatt-hour). If you know your data center uses renewable energy, you can provide a more specific, lower intensity value to the library.
Heuristics for Energy Distribution: Since we can't measure power physically at every point, the SWD model employs fixed heuristics (percentages) to distribute the total estimated energy (in kWh) across four key areas:

End-User Device (52%): This accounts for the energy used by the user's phone or laptop to process and display the data.
Hardware Production (19%): The "embodied carbon" – the energy consumed in manufacturing the devices and infrastructure used.
Data Center (15%): The electricity powering servers and cooling systems.
Network (14%): Energy for routers, switches, cell towers, and cables that transmit data.

This means that a significant portion of the "carbon impact" we're calculating is attributed to the end-user's device and the embodied carbon of hardware – aspects we often don't consider when thinking about "server-side" impact. It's a holistic view of the entire digital data lifecycle.

<script type="module">
  import { co2 } from "https://esm.sh/@tgwf/co2@latest";

  // 2. Initialize the estimator using the Sustainable Web Design "1byte" model
  const co2Estimator = new co2({ model: "1byte" });

  async function calculateApiImpact() {
    // 3. Define the data you are sending
    const requestPayload = { query: "Latest fashion trends", depth: "standard" };

    // (Simulate an API call here)
    const responsePayload = { results: ["..."] }; 

    // 4. Calculate the exact byte size of the data using the native Blob API
    const reqBytes = new Blob([JSON.stringify(requestPayload)]).size;
    const resBytes = new Blob([JSON.stringify(responsePayload)]).size;
    const totalBytes = reqBytes + resBytes;

    // 5. Calculate the carbon footprint
    const emissionsGrams = co2Estimator.perByte(totalBytes);
    const sizeInKB = (totalBytes / 1024).toFixed(2);

    // Output the results
    console.log(`📦 Data Transferred: ${sizeInKB} KB`);
    console.log(`🌱 Carbon Impact: ${emissionsGrams.toFixed(6)} grams CO₂e`);
  }

  calculateApiImpact();
</script>

Closing Thoughts:
While this calculation is a proxy, it's a powerful one. It provides a tangible number that allows us to start quantifying and discussing the environmental impact of our code. The next time you're designing an API, consider the size of your payloads. A seemingly small optimization, like reducing the data transferred in a common API call, can have a cumulative positive effect on our collective carbon footprint.
Every byte counts

Stop the Awkward Silence: Signals to Classic Orchestration

Bala Madhusoodhanan — Mon, 30 Mar 2026 06:30:30 +0000

Intro:
If you’ve used generative orchestration in Copilot Studio, you’ve seen the comforting “thinking” animation while the copilot works. Classic orchestration doesn’t do that out of the box. So when you kick off a longer task—like a RAG lookup or a flow call—the chat can look empty. No typing dots. Just silence.
That silence is a UX bug, not a feature. The fix is quick: send a Typing event immediately before the slow step, then add a short acknowledgement message to set expectations.

Configuration:

Locate the slow step or Topic where you have user feedback on the poor UX expereince (May be based on the user activity we might have logic where the heavy work starts: Create generative answers, a flow, or an HTTP/API call.)
Set Event type to Typing.

The example below the timer is set as 2100 ( milliseconds)

Add a brief acknowledgement message Right after the Typing event, add a normal message to set expectations. Keep it human and specific:

“Got it — searching our knowledge base. This may take a few seconds.”
“Working on your request — I’ll be right back with the details.”

Good UX patterns to include:

Time cue: “This usually takes ~5–10 seconds.” It sets expectations and reduces anxiety.
Specific context: “Checking SAP invoices…” feels more reassuring than generic “Working…”
Channel-aware: Typing events are short-lived (around 2-4 seconds). Always send an acknowledgement text so users see something even if the channel ignores Typing.

Closing Notes:
A great bot isn’t just smart — it’s considerate. In classic orchestration, adding a Typing event plus a short acknowledgement transforms a “silent” wait into a clear, reassuring experience. It takes less than a minute to wire up and pays off immediately in user confidence and perceived speed.