AI Agents in Practice: Empowering Collaboration Through Data

AI Agentic to Share Reports in Microsoft Fabric

Introduction

Microsoft Fabric unifies data engineering, data science, real-time analytics, and BI under one roof (OneLake, Lakehouses, Warehouses, Notebooks, Dataflows Gen2, Semantic Models, and Power BI). That consolidation makes it a natural home for AI agents that help teams find, trust, and share insights. This article shows how to design report-aware agents that live alongside Fabric assets, govern access with precision, and turn day-to-day collaboration into a repeatable, auditable workflow.

Why Fabric is an ideal home for agentic collaboration

Fabric’s OneLake provides a single logical data lake, so agents don’t juggle scattered storage silos. Semantic Models standardize definitions (measures, KPIs, role-based perspectives), letting agents reason over certified business terms rather than raw tables. Because Power BI sits natively in Fabric, sharing and conversation around reports—subscriptions, comments, scorecards—are first-class events your agents can read and act on. Finally, Domains and endorsements (promoted/certified) give agents a governance compass, preventing them from amplifying untrusted content.

Reference architecture: Agent + Fabric primitives

Data plane: Lakehouse/Warehouse + Dataflows Gen2 populate a Semantic Model.
Insight plane: Power BI reports/dashboards connect to that model.
Agent plane:

Retrieval: the agent uses catalog metadata (workspace, dataset ID, lineage, endorsements) and the semantic model schema (tables, measures, RLS roles).
Actions: the agent can (a) create a personal or shared view, (b) pin tiles to a hub dashboard, (c) generate a shareable link aligned to policy, (d) schedule refresh/subscriptions, (e) attach commentary with context, and (f) open a handoff task in Planner or Azure DevOps.

Policy plane: Purview + Fabric governance (RLS/OLS, sensitivity labels, tenant settings) define what the agent may show or share.
Eventing: Power BI activity events and Fabric item events trigger the agent to summarize changes, notify owners, and recommend share targets.

Core agent skills for report sharing

Find: Identify the “best” report for a question using endorsements, usage metrics, last-refresh freshness, and lineage health.
Explain: Generate a one-paragraph narrative with minimal-span citations to the underlying measures and filters (e.g., “RevenueYTD, filtered Region = EMEA, Currency = USD”).
Validate: Check RLS role membership and sensitivity labels before producing a link or attachment.
Share: Create scoped links (people, groups, external B2B), set expiration, and attach guardrails (no resharing, watermark, export disabled).
Follow-through: Subscribe recipients, create refresh alerts, and open a “data-to-decision” task with acceptance criteria.

Governance patterns that keep sharing safe

RLS/OLS first, prompts second: Agents should never summarize rows the user cannot query. The agent queries as the recipient’s effective role or refuses.
Sensitivity inheritance: When the agent composes a narrative across visuals, the highest sensitivity label must flow to the output.
Certified-only defaults: Default the agent to certified/owner-approved reports; allow overrides only with a reason code that lands in the audit log.
Least-privilege links: Prefer people-specific links with expiry over workspace-wide access, and default export to off.

A day in the life: sales ops collaboration

A regional lead types: “Share this quarter’s pipeline slippage with the EMEA managers.”
The agent finds the Certified ‘Revenue & Pipeline’ report, verifies that the EMEA managers’ group has a matching RLS role, applies the “Current Quarter” bookmark, and pins a KPI tile to the Sales Ops Hub dashboard.
The agent generates a link with 30-day expiry, attaches a two-paragraph explainer that cites the measures used, and schedules a Monday 08:00 subscription.
It opens a Planner task “Review EMEA slippage drivers,” auto-attaches the report link and the exact filter state, and sets acceptance: “Manager comment + mitigation plan per top 3 deals.”

Practical implementation guide

1) Model and metadata hygiene

Treat the Semantic Model as the contract: name measures clearly (RevenueYTD, PipelineSlippagePct), document them in descriptions, and expose Perspectives for agent-friendly surface area.
Use Endorsements (certified) and lineage fixed signals; your agent should rank results by (certified → promoted → none) and by usage freshness.

2) Policy checks before share

Query the recipient’s AAD group memberships; verify RLS roles exist.
Inspect sensitivity labels on the dataset, report, and workspace; if any label ≥ Confidential, enforce watermarked view links and block CSV export.
Confirm tenant/tenant-to-tenant sharing settings; if cross-tenant is off, propose a workspace guest invite instead of a link.

3) Repeatable sharing actions

Create or update a Power BI shareable link with scope = People/Group, expiry, reshare = false, export = false.
Add a subscription (HTML snapshot is safer than attachment for sensitive labels).
Pin a tile to a team hub dashboard with the exact filter/bookmark state.
Post a comment with a one-paragraph narrative that names measures, filters, and last refresh.

4) Traceability and audit

Log: who asked, which asset was shared, endorsement level, sensitivity, RLS role, link scope, expiry, and whether export was disabled.
Capture the semantic fingerprint (dataset ID, measure names, filters) in the audit note so recipients can reproduce results.

Example: agent prompt contract (Fabric-aware)

role: "FabricReportSharingAgent"
scope: >
  Recommend, validate, and share Power BI reports from Microsoft Fabric.
  Prefer certified assets; enforce RLS and sensitivity labels; never reveal data beyond the recipient’s role.
output:
  type: object
  required: [summary, choice, validation, share_plan, receipts]
  properties:
    summary: {type: string, maxWords: 80}
    choice:
      type: object
      required: [report_name, dataset_id, endorsement, last_refresh]
    validation:
      type: object
      required: [rls_role_ok, sensitivity_label, tenant_policy_ok]
    share_plan:
      type: object
      required: [link_type, scope, expires_on, export_disabled, watermark, subscriptions[]]
    receipts:
      type: array  # link id, comment id, subscription id
policy: "Use certified assets by default. If not certified, require reason and owner mention."
citation_rule: "Cite measure names and filters used in the preview summary."

Why this helps: The contract decouples selection, validation, and sharing, making it easy to test and to enforce governance in CI (golden traces for “should/shouldn’t share” scenarios).

Minimal Python sketch (Fabric/Power BI REST concepts)

# conceptual example (pseudocode-ish)
from datetime import datetime, timedelta

def choose_report(query, fabric_catalog):
    candidates = search_catalog(query, fabric_catalog)  # returns list with endorsement, usage, freshness
    ranked = sorted(candidates, key=lambda c: (c['endorsement_rank'], c['usage_rank'], -c['staleness_minutes']))
    return ranked[0]

def validate_policies(report, recipient):
    rls_ok = check_rls_role(report['dataset_id'], recipient['aad_groups'])
    label = get_sensitivity_label(report['id'])
    tenant_ok = check_tenant_settings(recipient['tenant'])
    return {"rls_role_ok": rls_ok, "sensitivity_label": label, "tenant_policy_ok": tenant_ok}

def share_report(report, recipients, watermark=True):
    expires = (datetime.utcnow() + timedelta(days=30)).date().isoformat()
    link = create_share_link(report_id=report['id'], scope=recipients, expires_on=expires,
                             export_disabled=True, resharing_disabled=True, watermark=watermark)
    sub_ids = [create_subscription(report['id'], r, schedule="Mon 08:00") for r in recipients]
    comment_id = post_comment(report['id'], "Summary: RevenueYTD (Region=EMEA). Last refresh: {}".format(report['last_refresh']))
    return {"link": link, "subscriptions": sub_ids, "comment_id": comment_id}

(Wire these to official APIs/SDKs; enforce idempotency via clientRequestId.)

Collaboration patterns that actually stick

Narratives first, links second: People adopt what they understand. Agents should attach a short explanation of what changed and why it matters, not only a URL.
Bookmarks as contracts: Share with named bookmarks so every recipient opens the same filtered state.
“Ask-to-Share” loop: If validation fails (e.g., no RLS role), the agent proposes an access request to the dataset owner with the exact justification.
Scorecards: When a KPI is shared repeatedly, promote it into a Metrics/Scorecard and subscribe the audience there—fewer links, more context.
Comment → task: Agent turns comment threads into Planner/Azure DevOps tasks with the report link and acceptance criteria.

Measuring success

Track adoption and trust: (a) certified vs. non-certified share rate, (b) shares with expired links, (c) export-disabled share percent, (d) time-to-first-view, (e) refresh recency at view time, (f) “question answered without analyst” rate. Use these to tune agent ranking and default behaviors.

Common pitfalls (and fixes)

Agents that bypass RLS → Always impersonate as the recipient during previews; otherwise output a redaction notice.
Ambiguous report selection → Demand at least one of: dataset ID, workspace, or certified tag; or return top-3 with governance scores.
Narratives that drift from definitions → Force the agent to cite measure names and their descriptions from the semantic model every time it explains a visual.
Over-sharing → Default to 30-day expiring, person-scoped links; create group access only after an explicit “convert to group” step that pings the owner.

Conclusion

Fabric gives you a governed backbone—OneLake, Semantic Models, Power BI, and Purview—on which report-sharing agents can thrive. By coupling selection → validation → sharing with policy-aware prompts and auditable actions, you turn ad-hoc sharing into a safe, scalable collaboration loop. Start with certified models, enforce RLS and labels automatically, and let the agent narrate the “so what.” The payoff is faster decisions, fewer bottlenecks, and a durable culture of data-driven teamwork.