AI agents are moving beyond novelty — they're showing up in engineering teams, support operations, customer success workflows, and executive dashboards. But every agent has the same fundamental bottleneck: they only work as well as the memory beneath them.
That's why Microsoft recently introduced Foundry IQ, a new retrieval and grounding layer inside Azure AI Foundry. It promises to solve the memory problem with enterprise-grade RAG, deep Microsoft 365 integration, and agentic orchestration built in. For organizations already running their world on Azure and M365, it looks compelling.
But here's what the pitch doesn't reveal: Foundry IQ only sees what lives in Microsoft's ecosystem. No Slack monitoring. No Gmail intelligence. No GitHub issue tracking. No YouTube transcription. And critically, no escape from Azure-hosted models.
If you're evaluating Microsoft Foundry IQ vs. Graphlit, you need to understand where Azure-only RAG breaks down — and why Graphlit's multimodal, multi-source, model-agnostic semantic platform is built for agents that operate across your entire work surface, not just your Microsoft tenant.
Table of Contents
- TL;DR — Quick Feature Comparison
- Understanding the Platforms
- The Microsoft-Only Problem: Where Foundry IQ Can't See
- Ingestion: Azure Data vs. Wherever Work Happens
- Multimodal Support: Documents vs. the Real World
- Retrieval Architecture: Chunks vs. Knowledge Graphs
- Agentic RAG: Prescriptive vs. Programmable
- Model Flexibility: Azure Menu vs. True Freedom
- Developer Experience: Azure Complexity vs. API Simplicity
- Security and Deployment
- Pricing Reality Check
- Use Cases: When to Choose Which
- Final Verdict
TL;DR — Quick Feature Comparison
Understanding the Platforms
What is Microsoft Foundry IQ?
Microsoft Foundry IQ is Microsoft's new agentic retrieval layer inside Azure AI Foundry. It's designed to provide enterprise-grade knowledge grounding for Microsoft Copilot and custom agents, with deep integration into the Microsoft ecosystem.
Foundry IQ provides a unified knowledge base backed by Azure AI Search, with automatic chunking, embedding generation, and layout understanding for documents. It includes built-in agentic orchestration that plans multi-step retrieval queries, combines results from multiple sources, and returns grounded responses with citations. The platform leverages Entra ID for authentication, enforces document-level ACLs from SharePoint and OneDrive, and integrates with Azure Monitor for audit trails.
For organizations that have standardized on Microsoft 365 and Azure infrastructure, Foundry IQ offers an opinionated path to agentic RAG without building everything from scratch. The promise is simple: connect your Microsoft data sources, configure your agent, and let Azure handle the rest.
What is Graphlit?
Graphlit takes a fundamentally different approach to the agent memory problem. Rather than being tied to a single ecosystem, Graphlit is a multi-source, multimodal, knowledge-graph-powered semantic platform powered by the Model Context Protocol (MCP).
Graphlit provides live-sync connectors to 30+ tools and platforms: Slack, GitHub, Gmail, Notion, Jira, Linear, Confluence, Google Drive, OneDrive, SharePoint, Dropbox, Box, YouTube, RSS feeds, and more. When content flows in, Graphlit doesn't just chunk and embed it — it normalizes structure, extracts entities (people, organizations, places, events, decisions), builds a knowledge graph of relationships, and indexes everything with hybrid search combining vector similarity, keyword matching, and graph traversal.
The platform exposes fine-grained retrieval tools directly to LLMs through SDKs and MCP, allowing the model itself to orchestrate multi-step queries, follow entity relationships, filter by time and context, and synthesize information across sources. Graphlit supports any LLM provider (OpenAI, Anthropic, Google, Meta, custom models) and handles the full agent lifecycle: conversation management, tool calling, workflow automation, and continuous synchronization.
Where Foundry IQ is Azure-native RAG, Graphlit is universal agentic memory.
The Microsoft-Only Problem: Where Foundry IQ Can't See
Foundry IQ's ingestion capabilities are genuinely impressive — if your data lives in Microsoft's world. The platform has excellent support for SharePoint libraries, OneDrive folders, OneLake and Fabric data sources, Azure Blob Storage, Azure Data Lake Storage, and even public web pages. For organizations that have consolidated their knowledge into Microsoft 365, this coverage can feel complete.
But here's the uncomfortable truth: modern work doesn't happen in one ecosystem. Your team's real knowledge is fragmented across dozens of tools, each serving a specific purpose. Customer success conversations happen in Slack. Product roadmaps live in Notion. Engineering discussions unfold in GitHub issues and pull requests. Support tickets accumulate in Zendesk or Jira. Sales intelligence flows through Gmail and Outlook. Meeting recordings sit in Zoom. Industry intelligence comes through RSS feeds and YouTube channels.
Foundry IQ can't see any of this unless you manually export data, convert it to supported formats, and upload it to SharePoint or Azure Storage. This isn't just an inconvenience — it's an architectural dead end. By the time you've exported yesterday's Slack conversations and uploaded them to SharePoint, they're already stale. Your agent is answering questions based on outdated context, missing the latest decisions, the newest blockers, and the most recent customer feedback.
Graphlit's Ingestion Philosophy
Graphlit takes a fundamentally different approach: connect to information where it already lives. The platform provides 30+ live-sync connectors that monitor your actual work tools in real time, continuously ingesting new information as it's created.
When you connect Slack, Graphlit doesn't just download message history — it maintains an ongoing sync, capturing new threads, replies, and reactions as they happen. When you connect GitHub, it ingests issues, pull requests, commits, and comments with metadata about authors, timestamps, and relationships. When you connect Gmail or Outlook, it understands thread structure, sender context, and temporal sequences. RSS feeds are monitored continuously. YouTube channels are transcribed automatically. Web pages can be scraped on schedules.
Every piece of content is normalized into a structured, time-aware memory fabric with entity extraction running automatically. People mentioned in Slack threads become linked entities. Projects referenced in GitHub issues connect to documentation in Notion. Organizations mentioned in emails tie to customer data in your CRM. The knowledge graph grows organically as information flows in, creating a living memory that reflects what's actually happening across your team's entire work surface.
Foundry IQ narrows your agent's memory to Microsoft data. Graphlit expands it to wherever work actually happens.
Ingestion: Azure Data vs. Wherever Work Happens
The contrast between these approaches becomes stark when you consider a typical enterprise workflow. A product decision might start with a Slack discussion, evolve through GitHub issues and pull requests, get documented in Notion, generate email threads with customers, produce Zoom recordings of design reviews, and culminate in Jira tickets for implementation. Foundry IQ would see none of this unless someone manually exports each source and uploads it to SharePoint — by which point the information flow has moved on.
Graphlit sees all of it automatically, maintaining live connections to each tool, understanding the temporal sequence of events, and building entity relationships that connect people, projects, decisions, and outcomes across every source. This isn't just about convenience — it's about giving agents accurate, current, contextual memory that reflects the reality of how modern teams actually work.
Multimodal Support: Documents vs. the Real World
Foundry IQ's indexing pipeline is genuinely sophisticated when it comes to documents stored in Microsoft repositories. The platform excels at PDF parsing, Office document understanding, layout analysis, and intelligent chunking that preserves semantic structure. For organizations whose knowledge consists primarily of formal documentation — reports, presentations, spreadsheets, policy manuals — this capability is substantial.
But here's what Foundry IQ can't process: the vast majority of information that teams actually generate.
Your sales team doesn't document customer feedback in Word files — they have recorded Zoom calls with prospects discussing pain points and feature requests. Your engineering team doesn't write formal reports about architecture decisions — they have recorded design reviews with diagrams on shared screens. Your customer success team doesn't create PowerPoint decks — they have chat logs, support tickets with screenshots, and screen recordings demonstrating bugs.
Graphlit's multimodal processing handles all of this automatically. Audio files are transcribed with speaker diarization, timestamps, and searchable text. Video content is processed to extract both audio tracks (for transcription) and visual frames (for OCR on slides, diagrams, and screen captures). Images and screenshots run through OCR to extract embedded text. Source code is parsed with syntax understanding. HTML content is normalized and cleaned. Structured data from APIs and databases is ingested with relationship modeling.
When a sales rep asks your agent "What pricing concerns came up in the Acme Corp demo?", Graphlit can transcribe the actual demo recording, identify the speaker discussing pricing, extract the specific timestamp, and cite the exact quote with video playback context. Foundry IQ would require someone to manually transcribe the call, save it as a Word document, and upload it to SharePoint — by which time dozens of other calls have happened and the information is already outdated.
Foundry IQ thinks knowledge lives in documents. Graphlit understands that knowledge lives in conversations, recordings, images, code, and unstructured data that never becomes a formal document.
Retrieval Architecture: Chunks vs. Knowledge Graphs
Foundry IQ's retrieval engine leverages Azure AI Search to return relevant text chunks based on semantic similarity and keyword matching. When you ask a question, the system embeds your query, searches the vector store, ranks results, and returns passages with citations. For straightforward document QA — "What does our security policy say about data retention?" — this approach works well.
But the limitations become apparent when you need contextual, relational, or temporal understanding. Ask Foundry IQ: "What changed about our Q4 roadmap after the security incident?" and you'll get text passages that happen to mention both topics. The system won't resolve which security incident you mean if there were multiple. It won't understand that "Project Odyssey" and "the voice assistant rewrite" refer to the same initiative. It won't track which decisions were made before vs. after the incident. It won't connect the people who made the decisions to their roles in specific projects.
This is the fundamental limitation of chunk-based retrieval: it finds similar text, not semantic meaning.
Graphlit's Knowledge Graph Approach
Graphlit takes a different path. During ingestion, the platform doesn't just chunk and embed content — it extracts structured entities and builds a knowledge graph that models relationships across your entire information landscape. People become nodes with roles and team memberships. Projects connect to the people working on them. Decisions link to the discussions that led to them. Organizations tie to the people who work there. Events mark temporal boundaries. Tasks connect to their owners and dependencies.
This knowledge graph powers a retrieval approach that goes far beyond similarity matching. When you ask "What changed about our Q4 roadmap after the security incident?", Graphlit can:
Identify which security incident based on temporal context and entity resolution. Normalize references like "Project Odyssey" and "the voice assistant project" to the same entity. Track the timeline of roadmap discussions before and after the incident date. Connect decisions to the specific people who made them and the teams they represent. Merge information from Slack threads, GitHub issues, email chains, and meeting recordings into a coherent narrative.
This is GraphRAG: retrieval that understands entities, relationships, time, and context — not just text similarity.
Agentic RAG: Prescriptive vs. Programmable
This is where the architectural philosophies diverge most sharply — and where the long-term implications for agent development become clear.
Foundry IQ includes built-in agentic orchestration. When you submit a complex query, the system automatically plans a multi-step retrieval strategy, splits the question into subqueries, performs multiple searches across different time ranges or metadata filters, combines results with ranking fusion, and returns a grounded response with citations. This orchestration happens inside Microsoft's platform, following patterns that Azure engineers have pre-designed based on common RAG use cases.
For teams that want opinionated, batteries-included RAG, this approach has appeal. You don't need to implement query planning logic. You don't need to manage tool calling. You don't need to design multi-step workflows. Microsoft has made these decisions for you, and the orchestration runs reliably at scale.
But here's the constraint: you can't change how it works. The orchestration logic is sealed inside Foundry IQ's black box. If your agent needs a different retrieval strategy — perhaps filtering by entity relationships before performing semantic search, or traversing the knowledge graph to find connected concepts, or combining temporal reasoning with spatial filters — you're limited to whatever Foundry's orchestrator provides. If your use case doesn't match Microsoft's assumptions, you're stuck.
Graphlit's Programmable Agentic System
Graphlit takes the opposite approach: expose powerful retrieval tools and let the LLM orchestrate them. The platform provides fine-grained capabilities through SDKs (TypeScript, Python, .NET) and the Model Context Protocol (MCP Server), but the orchestration logic lives in your application code and the LLM's reasoning process.
When your agent receives a complex query, the model itself generates tool calls: searching by semantic similarity, filtering by entities, traversing graph relationships, narrowing by time ranges, retrieving specific content by ID, summarizing results, or extracting structured data. The LLM can perform iterative retrieval — using results from one query to inform the next. It can apply conditional logic — searching one way if certain entities are present, another way if they're not. It can combine multiple retrieval strategies dynamically based on what it learns during the conversation.
This is agentic RAG in the open. Zine demonstrates this pattern today: agents that reason about what information they need, call specific tools to retrieve it, synthesize across multiple sources, and adapt their strategy based on what they find. The orchestration isn't hidden behind Microsoft's API — it's explicit, debuggable, and fully customizable.
Graphlit gives you the tools; the model provides the orchestration. Foundry IQ gives you the orchestration; you can't change the tools.
Model Flexibility: Azure Menu vs. True Freedom
Microsoft recently expanded Azure AI Foundry's model support to include Anthropic's Claude models alongside Azure OpenAI and MAI/Phi. This is genuinely positive — more choice benefits developers. But it's important to understand what "support" means in this context: you can only use Microsoft-hosted versions of these models, running on Azure infrastructure, with Azure pricing and rate limits.
Foundry IQ doesn't work with Google's Gemini models. It doesn't support Mistral, Cohere, or other third-party providers unless Microsoft decides to host them on Azure. You can't use local models running on Ollama or vLLM. You can't connect to custom enterprise inference endpoints. You can't use model routers like LiteLLM or OpenRouter to dynamically select providers based on cost, performance, or availability. You're constrained to whatever Microsoft chooses to offer in their Azure model catalog.
This isn't just about choice for its own sake — it's about operational flexibility in a rapidly evolving LLM landscape. When a new model family like Llama 4 or Mistral Large 3 launches with breakthrough capabilities, you're dependent on Microsoft's roadmap to access it. When Azure OpenAI experiences regional outages or rate limiting (as it periodically does), you have no fallback. When pricing changes or model deprecations occur, you're locked into Microsoft's decisions.
Graphlit's Model-Agnostic Architecture
Graphlit is fundamentally model-agnostic through its implementation of the Model Context Protocol (MCP). The platform works with any LLM provider that supports standard APIs: OpenAI, Anthropic, Google, Mistral, Azure OpenAI, AWS Bedrock, and custom enterprise endpoints. You can run local models on Ollama or vLLM. You can use model routers to implement fallback strategies, cost optimization, or load balancing across providers.
This flexibility enables sophisticated model selection strategies. Use Claude Opus for complex reasoning over knowledge graphs. Switch to GPT-4o for multimodal processing. Deploy Mistral for cost-sensitive batch summarization. Run Llama locally for sensitive data that can't leave your infrastructure. Choose different models per conversation, per query, or even per tool call based on the specific requirements of each operation.
When the LLM landscape shifts — and it shifts constantly — you're not waiting for Azure's roadmap. You're not rearchitecting your agent infrastructure. You're just pointing to a new endpoint.
Graphlit gives you complete freedom. Foundry IQ gives you Azure's menu.
Developer Experience: Azure Complexity vs. API Simplicity
To build an agent with Foundry IQ, you need to navigate the full Azure ecosystem. Start in the Azure Portal to provision AI Foundry resources. Configure ARM templates or Bicep scripts for infrastructure as code. Set up Azure AI Search indexes with the right schema, partitioning, and replica count. Define agent service definitions specifying models, grounding data, and orchestration parameters. Configure Entra ID authentication with service principals and role assignments. Set up VNets and private endpoints if security requires it. Monitor through Azure Monitor with custom dashboards and log queries.
This is enterprise infrastructure — powerful, scalable, and deeply integrated with Microsoft's ecosystem. For organizations that already run Azure and have dedicated platform engineering teams, this complexity is manageable. But for startups, smaller teams, or developers who just want to build an agent without becoming Azure experts, it's a steep learning curve that delays time-to-value by weeks or months.
Graphlit's API-First Approach
Graphlit takes a radically different approach: make it simple enough that you can start building in minutes, not months. The entire platform is accessible through a unified GraphQL API with SDKs for TypeScript, Python, and .NET. Want to add a Slack connector? One API call. Need to ingest a document? Upload via the SDK. Ready to query your knowledge graph? Single query with filters. Want to create an agent conversation? Initialize with a model and specification.
No Azure portal. No ARM templates. No infrastructure provisioning. No VNet configuration. No AI Search index tuning. No service principal juggling. If you can make HTTP requests and understand basic API concepts, you can use Graphlit. The platform handles scaling, infrastructure, and operations automatically.
This simplicity isn't about dumbing down capabilities — it's about removing accidental complexity that has nothing to do with building intelligent agents. Graphlit gives you sophisticated retrieval, knowledge graphs, multimodal processing, and agentic orchestration without requiring you to become an Azure architect first.
Graphlit minimizes cognitive load. Foundry IQ assumes Azure fluency.
Security and Deployment
Microsoft's security and governance capabilities for Foundry IQ are genuinely enterprise-grade and represent decades of investment in compliance, identity management, and audit infrastructure. Entra ID provides comprehensive enterprise authentication with conditional access, multi-factor requirements, and integration with existing directory services. Document-level ACLs from SharePoint, OneDrive, and Fabric are enforced during retrieval, ensuring agents respect the same permissions as human users. Azure Monitor captures detailed audit trails for compliance reporting. Role-based access control (RBAC) spans all services with fine-grained permissions. VNet integration and private endpoints enable complete network isolation for regulated industries.
For large enterprises with complex governance requirements, security teams, and established Azure infrastructure, this level of integration is invaluable. If your organization operates in financial services, healthcare, government, or other heavily regulated sectors, Microsoft's compliance certifications (SOC 2, HIPAA, FedRAMP, etc.) and enterprise controls provide peace of mind that few SaaS platforms can match.
Graphlit's Modern SaaS Security
Graphlit provides strong modern SaaS security with tenant isolation, encryption in transit and at rest, connector-scoped permissions, and team/workspace-level access controls. The platform is secure today and continuously hardening, built for teams who need robust security without the full weight of enterprise governance infrastructure.
Graphlit intentionally avoids claiming enterprise certifications like SOC 2 before they're complete — transparency matters more than premature marketing. For startups, mid-market companies, and teams that don't operate under heavy regulatory constraints, Graphlit's security model provides the right balance of protection and operational simplicity.
Future: Private Graphlit Deployment in Your Azure
For enterprises that do require self-hosted isolation but want Graphlit's capabilities, the platform will soon support deployment inside your own Azure subscription. You'll bring your storage account, your Azure AI Search instance, your Key Vault, your VNet and private networking, and your model endpoints. Graphlit's ingestion, knowledge graph, and retrieval capabilities run in your environment, under your governance controls, with your compliance certifications.
This gives you the best of both worlds: Graphlit's multimodal, multi-source, knowledge-graph-powered platform — deployed inside Azure's security perimeter with full control over data residency, network topology, and compliance posture.
Pricing Reality Check
Graphlit pricing is straightforward: free tier for testing and small projects, then usage-based credits with flat plans (Starter, Professional, Enterprise). Everything is included — storage, processing, infrastructure, multimodal transcription, knowledge graph construction. No separate line items for compute, networking, or monitoring. No Azure subscription required. No hidden costs.
Foundry IQ's pricing is more complex because it's not actually a product you purchase — it's a capability that runs on top of multiple Azure services, each billed separately. Your actual costs include: Azure AI Search units (based on index size and query load), Azure OpenAI or MAI or Anthropic token consumption (per model and usage), Azure Storage (for documents and vector data), networking charges (for data transfer), Azure Monitor logs (for audit trails), and agent runtime compute resources.
This isn't necessarily more expensive in total cost of ownership — especially for organizations already running significant Azure infrastructure with negotiated discounts. But it's harder to predict, harder to optimize, and presents as eight different line items on your monthly Azure bill instead of one predictable subscription charge. For teams without dedicated FinOps resources and Azure cost management experience, this complexity can be challenging.
Use Cases: When to Choose Which
Foundry IQ makes most sense for organizations that have already standardized on Microsoft 365 and Azure infrastructure, where knowledge primarily resides in SharePoint libraries, OneDrive folders, and Microsoft Teams, and where strict governance requirements demand deep Entra ID integration, document-level ACL enforcement, and Azure Monitor audit trails. If you're building an internal agent that answers questions about company policies stored in SharePoint, or an HR assistant that retrieves information from OneDrive-stored employee handbooks, Foundry IQ provides an opinionated path with enterprise security built in. The standardized agentic orchestration handles common RAG patterns without custom implementation, and the deep Azure integration means your security and IT teams can govern it using familiar tools and processes.
Graphlit makes most sense for organizations where knowledge is fragmented across dozens of tools — Slack conversations, GitHub repositories, email threads, Jira tickets, Notion wikis, Zoom recordings, RSS feeds, and more. If you're building agents that need to understand customer conversations from support chat logs, analyze engineering discussions from GitHub issues, synthesize product decisions from meeting recordings, or track competitive intelligence from industry publications, Graphlit's live-sync connectors and multimodal processing capture all of it automatically. The knowledge graph provides entity-aware retrieval that goes beyond text similarity, understanding who said what, when, and how different pieces of information connect across sources and time. Model flexibility means you can choose the right LLM for each task without vendor lock-in. Programmable agentic RAG gives you complete control over retrieval orchestration. And API-first simplicity means you can start building in hours instead of configuring Azure infrastructure for weeks.
Final Verdict: Microsoft-First vs. Work-First
Both platforms represent sophisticated approaches to the agent memory problem, but they're solving for fundamentally different scenarios.
Foundry IQ is optimized for Microsoft-first organizations — enterprises that have consolidated their knowledge into the Microsoft 365 ecosystem, operate on Azure infrastructure, require Microsoft's enterprise governance and compliance certifications, and prefer opinionated, standardized solutions over customizable flexibility. If your world is SharePoint, OneDrive, Teams, and Azure, Foundry IQ provides a coherent path to agentic RAG with minimal deviation from your existing Microsoft stack.
Graphlit is optimized for work-first organizations — companies where knowledge lives wherever teams actually work, which means dozens of specialized tools serving different functions. Organizations that need multimodal processing because information comes as recordings, images, and unstructured data, not just formal documents. Teams that want model flexibility to use the best LLM for each task without betting everything on one vendor's roadmap. Developers who need programmable control over retrieval orchestration because their use cases don't fit standard RAG patterns. Companies building custom agents, vertical agents, or multi-tenant SaaS where agent infrastructure needs to be flexible, extensible, and independent of cloud provider lock-in.
The decision isn't really about which platform is "better" — it's about which problem you're solving. If you're building Microsoft-centric agents for enterprise knowledge management with strict governance requirements, Foundry IQ is purpose-built for that. If you're building intelligent agents that operate across your team's entire work surface with current, contextual, multimodal memory, Graphlit is built for that.
Microsoft-first agents → Foundry IQ.
Real agentic memory across your work surface → Graphlit.