AI Automation & Agents  

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

  1. Data plane: Lakehouse/Warehouse + Dataflows Gen2 populate a Semantic Model.

  2. Insight plane: Power BI reports/dashboards connect to that model.

  3. 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.

  1. Policy plane: Purview + Fabric governance (RLS/OLS, sensitivity labels, tenant settings) define what the agent may show or share.

  2. 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

  1. A regional lead types: “Share this quarter’s pipeline slippage with the EMEA managers.”

  2. 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.

  3. 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.

  4. 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.

Membership not found