<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: RevOS.ai</title>
    <description>The latest articles on DEV Community by RevOS.ai (revos).</description>
    <link>https://dev.to/revos</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F15122%2F9651c7e6-30fa-4b81-893a-e2cc856a1d48.png</url>
      <title>DEV Community: RevOS.ai</title>
      <link>https://dev.to/revos</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/revos"/>
    <language>en</language>
    <item>
      <title>Enterprise AI Agents in 2026: Platforms, Deployment Services, and Why Most Projects Fail</title>
      <dc:creator>RevOS</dc:creator>
      <pubDate>Wed, 04 Nov 2026 11:46:24 +0000</pubDate>
      <link>https://dev.to/revos/enterprise-ai-agents-in-2026-platforms-deployment-services-and-why-most-projects-fail-4da2</link>
      <guid>https://dev.to/revos/enterprise-ai-agents-in-2026-platforms-deployment-services-and-why-most-projects-fail-4da2</guid>
      <description>&lt;p&gt;&lt;strong&gt;Key takeaways&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Gartner predicts 40% of enterprise apps will feature AI agents by 2026, up from under 5% in 2025, while over 40% of agentic AI projects will be canceled by the end of 2027.&lt;/li&gt;
&lt;li&gt;The platform landscape splits into three tiers: cloud-native suites (Salesforce Agentforce, Microsoft Copilot, ServiceNow), vertical specialists (Sierra AI), and open-source frameworks (LangGraph, CrewAI).&lt;/li&gt;
&lt;li&gt;GSI deployments cost $500K to $5M+; boutique AI firms start around $150K/yr and move faster.&lt;/li&gt;
&lt;li&gt;The leading failure mode is agents guessing at metric definitions, returning confident answers that don't match your official reports.&lt;/li&gt;
&lt;li&gt;A semantic layer connected via an MCP server is the fix: agents query governed definitions rather than computing metrics on the fly from raw tables.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://www.gartner.com/en/newsroom/press-releases/2025-08-26-gartner-predicts-40-percent-of-enterprise-apps-will-feature-task-specific-ai-agents-by-2026-up-from-less-than-5-percent-in-2025" rel="noopener noreferrer"&gt;Gartner predicts&lt;/a&gt; 40% of enterprise applications will feature task-specific AI agents by 2026, up from under 5% in 2025. In the same window, &lt;a href="https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027" rel="noopener noreferrer"&gt;over 40% of agentic AI projects&lt;/a&gt; will be canceled before they deliver value. Rapid adoption and widespread failure are happening simultaneously.&lt;/p&gt;

&lt;p&gt;The failure rate is the more important number. Enterprise AI agents are not failing because the models are bad. They are failing because the data infrastructure underneath them was never designed to support autonomous reasoning at scale.&lt;/p&gt;

&lt;p&gt;This guide covers the enterprise AI agent landscape: the platforms, the rollout services, realistic pricing, and the data prerequisites most deployment guides skip entirely.&lt;/p&gt;

&lt;h2&gt;
  
  
  What are enterprise AI agents?
&lt;/h2&gt;

&lt;p&gt;An enterprise AI agent is an autonomous software program that perceives data from business systems, reasons toward a goal, and takes multi-step actions without a human approving each step.&lt;/p&gt;

&lt;p&gt;That last part is what separates agents from chatbots. A chatbot responds to a prompt. An agent pursues a goal: it breaks the goal into steps, calls the right tools in the right order, handles errors, and reports back when the work is done.&lt;/p&gt;

&lt;p&gt;As an example: an agent monitoring &lt;a href="https://www.revos.ai/blog/customer-health-score" rel="noopener noreferrer"&gt;customer health scores&lt;/a&gt; might detect that a customer's product usage has dropped below a threshold, check the AE assigned to the account, find an open slot in their calendar, and schedule a follow-up call, all without human intervention. At scale, that loop turns lagging indicators into proactive interventions before churn happens.&lt;/p&gt;

&lt;p&gt;Enterprise AI agents generally fall into four types:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Type&lt;/th&gt;
&lt;th&gt;What it does&lt;/th&gt;
&lt;th&gt;Common examples&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Task agents&lt;/td&gt;
&lt;td&gt;Complete a single, bounded task end-to-end&lt;/td&gt;
&lt;td&gt;Auto-generate a quote, file an expense, triage a ticket&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Orchestrator agents&lt;/td&gt;
&lt;td&gt;Coordinate multiple sub-agents toward a larger goal&lt;/td&gt;
&lt;td&gt;Sales pipeline review, onboarding workflow&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Data agents&lt;/td&gt;
&lt;td&gt;Query, synthesize, and report on structured data&lt;/td&gt;
&lt;td&gt;Revenue attribution, cohort analysis, forecast&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Process agents&lt;/td&gt;
&lt;td&gt;Monitor systems and trigger actions on events&lt;/td&gt;
&lt;td&gt;Churn detection, SLA breach escalation&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Most enterprise deployments start with task agents (lowest risk, fastest ROI) and layer in orchestrators as confidence builds.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is agentic AI?
&lt;/h2&gt;

&lt;p&gt;Agentic AI is AI that acts over multiple steps toward a goal, rather than just generating a response to a single prompt.&lt;/p&gt;

&lt;p&gt;The three defining properties:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Planning:&lt;/strong&gt; the agent breaks a goal into a sequence of steps and decides the order.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tool use:&lt;/strong&gt; the agent calls external services: APIs, databases, search engines, internal systems.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Memory:&lt;/strong&gt; the agent tracks what happened in prior steps and adjusts its next action accordingly.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The shift from generative AI (produce text) to agentic AI (take action) is why enterprises are investing heavily, and why the failure rate is high. Generating a draft proposal is low stakes; you can review it before it goes anywhere. Booking 200 follow-up calls based on a miscalculated health score is not.&lt;/p&gt;

&lt;h2&gt;
  
  
  The enterprise AI agent platform landscape
&lt;/h2&gt;

&lt;p&gt;The platform market is consolidating around three tiers.&lt;/p&gt;

&lt;h3&gt;
  
  
  Tier 1: Cloud-native suites
&lt;/h3&gt;

&lt;p&gt;These platforms live inside tools enterprises already use and fit existing procurement contracts.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Salesforce Agentforce&lt;/strong&gt; is the clearest signal of where Tier 1 is heading. &lt;a href="https://www.stocktitan.net/news/CRM/introducing-agentforce-2-0-the-digital-labor-platform-for-building-a-o7pqlb9af9zz.html" rel="noopener noreferrer"&gt;Agentforce 2.0 achieved 83% autonomous resolution&lt;/a&gt; of customer service queries. Salesforce reported &lt;a href="https://www.salesforce.com/news/press-releases/2026/02/25/fy26-q4-earnings/" rel="noopener noreferrer"&gt;$800M ARR from Agentforce in its FY2026 Q4 results&lt;/a&gt;, with &lt;a href="https://www.cxtoday.com/customer-analytics-intelligence/salesforce-hits-8000-agentforce-deals-opens-up-on-its-informatica-acquisition/" rel="noopener noreferrer"&gt;8,000 Agentforce deals&lt;/a&gt; closed. Pricing is Flex Credits at $0.10/action, dramatically cheaper than early per-conversation models.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Microsoft Copilot Studio&lt;/strong&gt; and &lt;strong&gt;Azure AI Foundry&lt;/strong&gt; give enterprises an agent builder inside the Microsoft 365 stack. If your data is already in Azure, the integration lift is low. If it isn't, you are building custom connectors.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;ServiceNow&lt;/strong&gt; embeds agents into ITSM and HR workflows. Strong for internal operations; weaker for customer-facing or revenue use cases.&lt;/p&gt;

&lt;h3&gt;
  
  
  Tier 2: Vertical specialists
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Sierra AI&lt;/strong&gt; builds agents purpose-built for enterprise customer experience. The &lt;a href="https://techcrunch.com/2026/05/04/sierra-raises-950m-as-the-race-to-own-enterprise-ai-gets-serious/" rel="noopener noreferrer"&gt;company's $950M raise at a $15B+ valuation in May 2026&lt;/a&gt; signals that vertical depth (knowing the domain, edge cases, and compliance requirements) beats horizontal platforms for high-stakes interactions. Sierra's pricing starts around $150K/year.&lt;/p&gt;

&lt;h3&gt;
  
  
  Tier 3: Open-source frameworks
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;LangGraph&lt;/strong&gt;, &lt;strong&gt;CrewAI&lt;/strong&gt;, &lt;strong&gt;AutoGen&lt;/strong&gt;, and &lt;strong&gt;Semantic Kernel&lt;/strong&gt; give engineering teams full control over agent architecture: orchestration logic, tool integrations, memory systems. No license cost. High engineering cost. Best for teams that need something Tier 1/2 platforms don't offer, or that want to avoid vendor lock-in.&lt;/p&gt;

&lt;p&gt;Two self-hosted frameworks worth naming inside this tier: &lt;strong&gt;OpenClaw&lt;/strong&gt;, a community-driven, edge-deployed agent gateway built for omni-channel use cases (Telegram, WhatsApp, Discord); and &lt;strong&gt;Hermes Agent&lt;/strong&gt;, a terminal-native orchestrator built for engineering pipelines, with persistent memory, real Bash execution, and hierarchical sub-agent delegation. Both are fully self-hosted with no license fee, and both can connect to a governed data source over MCP rather than each requiring its own custom integration. If you plan to run Hermes in production, we wrote up &lt;a href="https://www.revos.ai/blog/hermes-agent-kubernetes" rel="noopener noreferrer"&gt;what breaks when you run Hermes Agent on Kubernetes&lt;/a&gt; and a setup that survives it.&lt;/p&gt;

&lt;p&gt;The practical tradeoff: Tier 1 is faster to pilot and easier to govern; Tier 3 is more flexible and cheaper at scale if you have the engineering team. Most enterprises start at Tier 1 and build Tier 3 agents for custom use cases. Anthropic's own first-party surfaces (Claude Code, Claude Cowork, Claude Tag, and its several scheduled-automation "Routines") sit alongside this landscape rather than inside any one tier; see our &lt;a href="https://www.revos.ai/blog/claude-code-cowork-tag-routines" rel="noopener noreferrer"&gt;guide to navigating the Claude ecosystem&lt;/a&gt; if that's the specific stack you're evaluating.&lt;/p&gt;

&lt;h2&gt;
  
  
  Enterprise AI agent rollout service providers
&lt;/h2&gt;

&lt;p&gt;Buying a platform is not the same as deploying it. Most enterprises engaging seriously with AI agents are also engaging a services partner for the integration work, change management, and ongoing model tuning.&lt;/p&gt;

&lt;h3&gt;
  
  
  Global SIs: Accenture, IBM, Deloitte, Capgemini
&lt;/h3&gt;

&lt;p&gt;The large system integrators bring a reliable playbook: stakeholder alignment, risk assessment, integration with legacy ERP and CRM, a globally distributed delivery team, and governance frameworks for regulated industries.&lt;/p&gt;

&lt;p&gt;The cost matches the scale. A full GSI-led deployment runs $500K to $5M+ depending on scope, with timelines of 6 to 18 months. That pricing reflects the overhead of the engagement model: senior partner time, change management documentation, compliance reviews, and global delivery coordination.&lt;/p&gt;

&lt;p&gt;If your deployment involves deep SAP or Oracle integration, enterprise-wide change management across regions, or a regulated industry where you need a Big Four name in the liability chain, a GSI is the right fit.&lt;/p&gt;

&lt;h3&gt;
  
  
  When should you use a global SI versus a boutique AI firm?
&lt;/h3&gt;

&lt;p&gt;Boutique AI firms specialize in a vertical (GTM, finance, supply chain, HR) and deliver faster pilots at lower cost. A typical boutique engagement starts around $150K/year for a managed build-and-operate model.&lt;/p&gt;

&lt;p&gt;The tradeoff: boutiques move faster (6 to 8 weeks to a working pilot is common) and their domain expertise is often deeper within their vertical. The risk is capacity: a boutique that runs your pilot may not scale globally.&lt;/p&gt;

&lt;p&gt;For most B2B SaaS revenue operations use cases, a boutique specialist will deliver a better outcome faster than a GSI. GSIs earn their premium in global, multi-system, regulated deployments where brand liability and delivery footprint matter.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Factor&lt;/th&gt;
&lt;th&gt;Global SI&lt;/th&gt;
&lt;th&gt;Boutique AI firm&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Cost&lt;/td&gt;
&lt;td&gt;$500K to $5M+&lt;/td&gt;
&lt;td&gt;~$150K/yr+&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Speed to pilot&lt;/td&gt;
&lt;td&gt;6 to 18 months&lt;/td&gt;
&lt;td&gt;6 to 8 weeks&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Depth&lt;/td&gt;
&lt;td&gt;Multi-system, global&lt;/td&gt;
&lt;td&gt;Vertical domain focus&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Best for&lt;/td&gt;
&lt;td&gt;SAP/Oracle integration, regulated industries&lt;/td&gt;
&lt;td&gt;B2B SaaS, RevOps, customer experience&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Why enterprise AI agent projects fail
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.gartner.com/en/newsroom/press-releases/2025-09-30-gartner-survey-finds-just-15-percent-of-it-application-leaders-are-considering-piloting-or-deploying-fully-autonomous-ai-agents" rel="noopener noreferrer"&gt;Just 15% of IT application leaders are considering, piloting, or deploying fully autonomous AI agents&lt;/a&gt;, according to a September 2025 Gartner survey. Of those that do proceed, &lt;a href="https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027" rel="noopener noreferrer"&gt;Gartner predicts over 40% will be canceled by end of 2027&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The leading cause is not model quality. It is data.&lt;/p&gt;

&lt;h3&gt;
  
  
  The hallucinated-metric failure mode
&lt;/h3&gt;

&lt;p&gt;An enterprise AI agent is given access to raw tables: CRM records, warehouse data, support tickets. A stakeholder asks: "Which accounts are at risk this quarter?"&lt;/p&gt;

&lt;p&gt;Without a governed definition of "at risk," the agent computes one on the fly. It might derive churn probability from usage data using a formula it infers from the table schema. That formula will not match the formula your data team uses. The number will be fluent, confident, and wrong. The underlying mistake is letting a probabilistic model do deterministic work; &lt;a href="https://www.revos.ai/blog/probabilistic-vs-deterministic-ai" rel="noopener noreferrer"&gt;this post explains where to draw the line&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;When this happens at scale (and it does), the result is the worst possible outcome: stakeholders who received a confident wrong answer from an expensive agent deployment. That is the project that gets canceled.&lt;/p&gt;

&lt;p&gt;The fix is not a better model. It is a better &lt;a href="https://www.revos.ai/blog/modern-data-strategy-age-of-ai" rel="noopener noreferrer"&gt;modern data strategy for the AI age&lt;/a&gt;: specifically, one that includes semantically governed data, with metric definitions and business logic that live in a shared layer agents can query, rather than locked inside individual dashboards or analyst notebooks.&lt;/p&gt;

&lt;h2&gt;
  
  
  What data infrastructure do enterprise AI agents need?
&lt;/h2&gt;

&lt;p&gt;Three components are non-negotiable.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. A governed data warehouse
&lt;/h3&gt;

&lt;p&gt;Your agents need a structured, queryable source of truth. Schema documentation, access controls, and a version-controlled transformation layer (dbt or equivalent) are the baseline. Without this, you have nowhere stable for agents to query.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. A semantic layer
&lt;/h3&gt;

&lt;p&gt;A &lt;a href="https://www.revos.ai/blog/what-is-a-semantic-layer" rel="noopener noreferrer"&gt;semantic layer&lt;/a&gt; is a governed translation layer between raw data and business meaning. It defines your metrics (ARR, churn rate, customer health score) once, in one place, so every system (reports, dashboards, agents) uses the same formula. It's the right structure for governed metrics specifically; see our &lt;a href="https://www.revos.ai/blog/structuring-data-for-ai-agents" rel="noopener noreferrer"&gt;comparison of semantic models, knowledge graphs, RAG, and other ways to structure data for AI agents&lt;/a&gt; for the cases where a different approach fits better.&lt;/p&gt;

&lt;p&gt;Without a semantic layer, agents make up metric definitions. With one, they query a verified library and return numbers that match your board deck. This is the single highest-leverage infrastructure investment for any enterprise AI agent deployment. It's also the governed "numbers half" of what many teams now call a &lt;a href="https://www.revos.ai/blog/company-brain" rel="noopener noreferrer"&gt;company brain&lt;/a&gt;: a shared context layer every agent draws on.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. An MCP server
&lt;/h3&gt;

&lt;p&gt;The Model Context Protocol (MCP) is an open standard that lets AI agents connect to data sources through a single interface. Instead of building a custom connector for every agent-data pair, you run one MCP server, and every compliant agent can query it.&lt;/p&gt;

&lt;p&gt;The architecture:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Agent (any compliant client: GPT-4o, Claude, Gemini)&lt;/li&gt;
&lt;li&gt;MCP server&lt;/li&gt;
&lt;li&gt;Semantic layer (Cube, RevOS, or equivalent)&lt;/li&gt;
&lt;li&gt;Data warehouse (BigQuery, Snowflake, Redshift)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In this stack, agents always query governed definitions rather than raw tables. The hallucinated-metric problem is structurally eliminated.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to evaluate your enterprise AI agent stack
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Step 1: Audit your data readiness
&lt;/h3&gt;

&lt;p&gt;Before evaluating platforms, assess whether your data can support an agent. Can you produce a reliable &lt;a href="https://www.revos.ai/blog/customer-health-score" rel="noopener noreferrer"&gt;customer health score&lt;/a&gt; programmatically, not from a dashboard but from a query? If not, agents will fail at that task regardless of which platform you buy.&lt;/p&gt;

&lt;p&gt;If the answer is no, the path forward is getting &lt;a href="https://www.revos.ai/blog/data-readiness-for-machine-learning" rel="noopener noreferrer"&gt;AI-ready data&lt;/a&gt; in place first: clean schemas, governed metric definitions, and a semantic layer to expose them.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 2: Map your use cases by risk tier
&lt;/h3&gt;

&lt;p&gt;Low-risk tasks (draft an email, summarize a call transcript) can run on any LLM with minimal infrastructure. High-risk tasks (update the CRM, trigger a customer communication, close a renewal) require strict semantic grounding and audit logging.&lt;/p&gt;

&lt;p&gt;Start with low-risk tasks. Build confidence in your data infrastructure before putting agents on high-stakes workflows.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 3: Evaluate platform fit, not features
&lt;/h3&gt;

&lt;p&gt;The feature set of Tier 1 platforms is roughly equivalent. The differentiator is fit: which platform connects cleanly to your existing stack, and which integrates with the semantic layer you need to govern agent outputs?&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 4: Choose a services model that matches your internal capacity
&lt;/h3&gt;

&lt;p&gt;If you have a data team that can own the semantic layer, a boutique AI firm running the agent deployment typically delivers better ROI than a full GSI engagement. If you don't have that internal capacity, choose a services partner who will build and operate the semantic layer for you.&lt;/p&gt;

&lt;p&gt;RevOS agents are built on this model: the &lt;a href="https://www.revos.ai/product/semantic-model" rel="noopener noreferrer"&gt;semantic layer&lt;/a&gt; and MCP server are included in the platform, so agents return governed answers from day one. The RevOS semantic model handles the definition layer, so your agents don't have to guess.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 5: Define success metrics before you deploy
&lt;/h3&gt;

&lt;p&gt;The most dangerous agent project is one with no failure criteria. Before deployment, define: what does a wrong answer look like, and how will you detect it? What is the acceptable error rate for autonomous actions?&lt;/p&gt;

&lt;p&gt;Without a clear success definition, a project that produces 30% wrong answers gets declared a success because it automated 70% of the manual work. That 30% erodes trust over time.&lt;/p&gt;

&lt;h2&gt;
  
  
  The bottom line
&lt;/h2&gt;

&lt;p&gt;Enterprise AI agents are real, they work, and the market is moving fast. The platforms are maturing, the services ecosystem is established, and pricing is more accessible than it was 18 months ago.&lt;/p&gt;

&lt;p&gt;The variable that determines whether your deployment succeeds is not which LLM you pick or which platform you license. It is whether your data infrastructure can support autonomous reasoning: specifically, whether your agents can access governed metric definitions through a standard interface rather than guessing at business logic from raw tables.&lt;/p&gt;

&lt;p&gt;The semantic layer plus MCP server is the architecture that makes agents trustworthy. Without it, you are building on sand.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;This article was originally published on the &lt;a href="https://www.revos.ai/blog/enterprise-ai-agents?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=enterprise-ai-agents" rel="noopener noreferrer"&gt;RevOS blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Most agent projects fail on the data, not the platform. RevOS gives your agents one governed commercial context across CRM, billing, product usage and support, with every action permissioned and audit logged. &lt;a href="https://try.revos.ai/meetings/renat/revos-demo?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=enterprise-ai-agents" rel="noopener noreferrer"&gt;Book a RevOS demo&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>mcp</category>
      <category>dataengineering</category>
    </item>
    <item>
      <title>What Is a Company Brain? 6 Approaches Compared</title>
      <dc:creator>RevOS</dc:creator>
      <pubDate>Wed, 28 Oct 2026 12:39:52 +0000</pubDate>
      <link>https://dev.to/revos/what-is-a-company-brain-6-approaches-compared-lm8</link>
      <guid>https://dev.to/revos/what-is-a-company-brain-6-approaches-compared-lm8</guid>
      <description>&lt;p&gt;&lt;strong&gt;Key takeaways&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A company brain is a shared context layer that holds what your company knows, so any AI agent or teammate can use it. That includes documents, decisions, definitions, and live business data.&lt;/li&gt;
&lt;li&gt;Every company brain has two halves: a knowledge half (docs, conversations, decisions) and a numbers half (metrics, entities, and records from your business systems). Most tools cover only one.&lt;/li&gt;
&lt;li&gt;There are six common approaches: enterprise search, AI wikis, DIY RAG on a vector database, knowledge graphs with an ontology, AI memory layers, and a data platform with a semantic layer and MCP.&lt;/li&gt;
&lt;li&gt;Search, wikis, RAG, and memory layers are built for the knowledge half. Knowledge graphs, ontologies, and semantic layers add the structure the numbers half needs to answer metric questions consistently.&lt;/li&gt;
&lt;li&gt;MCP (Model Context Protocol) is becoming the common way to plug any of these approaches into Claude, ChatGPT, Copilot, or your own agents.&lt;/li&gt;
&lt;li&gt;The hard part is upkeep, not setup: stale content, drifting permissions, and conflicting definitions are what make a company brain fail.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A &lt;strong&gt;company brain&lt;/strong&gt; is a shared context layer that holds what your company knows, so any AI agent or teammate can use it. That covers documents, conversations, decisions, definitions, and live business data. The underlying problem is an old one. In a 2023 Gartner survey, &lt;a href="https://www.gartner.com/en/newsroom/press-releases/2023-05-10-gartner-survey-reveals-47-percent-of-digital-workers-struggle-to-find-the-information-needed-to-effectively-perform-their-jobs" rel="noopener noreferrer"&gt;47% of digital workers said they struggle to find the information or data they need to do their jobs&lt;/a&gt;. AI agents have the same problem, and unlike a new hire they rarely know when to ask. As we argued in our guide to &lt;a href="https://www.revos.ai/blog/enterprise-ai-agents" rel="noopener noreferrer"&gt;enterprise AI agents&lt;/a&gt;, an agent without shared company context will guess, and guesses do not scale.&lt;/p&gt;

&lt;p&gt;The term itself is new. In US search-volume data we pulled from Google Ads for this article, searches for "company brain" went from about 10 a month in January 2026 to about 590 a month by summer. Vendors now define it to fit what they sell: &lt;a href="https://slite.com/learn/company-brain" rel="noopener noreferrer"&gt;Slite calls it a context layer&lt;/a&gt;, &lt;a href="https://www.sentra.app/articles/what-is-a-company-brain" rel="noopener noreferrer"&gt;Sentra calls it governed memory&lt;/a&gt;, and &lt;a href="https://colrows.com/blogs/company-brain-for-enterprise-ai/" rel="noopener noreferrer"&gt;Colrows says the data layer decides everything&lt;/a&gt;. Each of them describes a real part of the problem, though none describes all of it.&lt;/p&gt;

&lt;p&gt;So which kind of company brain do you actually need? This guide compares the six main ways to build one, with the same strengths-and-limits treatment for each. It also defines the related terms you will run into: context layer, knowledge graph, ontology, semantic layer, and MCP.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is a company brain?
&lt;/h2&gt;

&lt;p&gt;A company brain is a shared context layer that holds what your company knows, so any AI agent or teammate can use it. It answers two kinds of questions:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"What do we know?" For example: what our refund policy is, why we chose this vendor, how we onboard enterprise customers.&lt;/li&gt;
&lt;li&gt;"What is true right now?" For example: last quarter's net revenue retention (revenue kept from existing customers, including upgrades and churn), which accounts are at risk, how many active users a customer has.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A company brain is &lt;strong&gt;not&lt;/strong&gt; the same as:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A wiki.&lt;/strong&gt; A wiki stores pages people write. A company brain makes those pages, and much more, usable by an AI agent.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;An AI knowledge base.&lt;/strong&gt; A help-center or FAQ store that an AI answers from. It is one source for the knowledge half, not the whole brain.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A search index.&lt;/strong&gt; Search finds relevant documents. A company brain also has to know what your terms mean and which number is the right one.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A data catalog.&lt;/strong&gt; A catalog lists your tables and who owns them. A company brain has to answer the question, not point to where the answer might live.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A personal "second brain".&lt;/strong&gt; A second brain is one person's notes app (Obsidian, Notion). A company brain is shared, governed, and permission-aware. "Governed" here means each definition has an owner, there is one agreed version, and access follows your rules.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two things changed recently. Companies have learned that AI fails without good context. In 2025, Gartner predicted that &lt;a href="https://www.gartner.com/en/newsroom/press-releases/2025-02-26-lack-of-ai-ready-data-puts-ai-projects-at-risk" rel="noopener noreferrer"&gt;organizations will abandon 60% of AI projects unsupported by AI-ready data&lt;/a&gt; through 2026. A shared interface also exists now. The Model Context Protocol (MCP) lets one context layer serve Claude, ChatGPT, Copilot, and custom agents at the same time. (If MCP is new to you, start with &lt;a href="https://www.revos.ai/blog/what-is-an-mcp-server" rel="noopener noreferrer"&gt;what an MCP server is&lt;/a&gt;.)&lt;/p&gt;

&lt;h2&gt;
  
  
  Company brain vs context layer, knowledge graph, and ontology
&lt;/h2&gt;

&lt;p&gt;These terms overlap, and vendors use them loosely. The table shows how they relate.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Term&lt;/th&gt;
&lt;th&gt;What it is&lt;/th&gt;
&lt;th&gt;Role in a company brain&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Context layer&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Everything an AI model needs to know about your business to answer correctly&lt;/td&gt;
&lt;td&gt;Another name for the company brain itself, usually used by technical teams&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Knowledge graph&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Your business stored as connected entities: customers, contracts, products, people, and the links between them&lt;/td&gt;
&lt;td&gt;A structured way to store the brain's facts and relationships&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Ontology&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;The schema behind a knowledge graph: which types of things exist and how they may relate&lt;/td&gt;
&lt;td&gt;The rulebook that keeps the graph consistent&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Semantic layer&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Business metrics and entities (revenue, churn, active customer) defined once on top of your data warehouse, the central database that stores your business records&lt;/td&gt;
&lt;td&gt;The governed "numbers half" of the brain&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;RAG&lt;/strong&gt; (retrieval-augmented generation)&lt;/td&gt;
&lt;td&gt;Fetching text passages that match a question and handing them to the model&lt;/td&gt;
&lt;td&gt;The most common way to serve the "knowledge half"&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;MCP&lt;/strong&gt; (Model Context Protocol)&lt;/td&gt;
&lt;td&gt;An open standard for connecting AI assistants to tools and data&lt;/td&gt;
&lt;td&gt;The plug that lets agents read the brain&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Put simply, the context layer is the goal and MCP is how agents reach it. Knowledge graphs, ontologies, semantic layers, and RAG are different ways to build it.&lt;/p&gt;

&lt;p&gt;An ontology and a semantic layer solve a similar problem from different directions. An ontology defines what things &lt;em&gt;are&lt;/em&gt; ("a customer is an organization with at least one active contract"). A &lt;a href="https://www.revos.ai/blog/what-is-a-semantic-layer" rel="noopener noreferrer"&gt;semantic layer&lt;/a&gt; defines how things are &lt;em&gt;measured&lt;/em&gt; ("net revenue retention is this calculation over these tables"). Both stop an AI model from inventing its own definitions.&lt;/p&gt;

&lt;h2&gt;
  
  
  The two halves of a company brain
&lt;/h2&gt;

&lt;p&gt;Most company-brain guides focus on documents, Slack threads, and meeting notes, which covers only half the job.&lt;/p&gt;

&lt;p&gt;Picture two questions a sales leader might ask an AI agent on the same morning:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;"What did we promise Acme in the renewal call?"&lt;/li&gt;
&lt;li&gt;"What was net revenue retention for mid-market last quarter?"&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The first is a &lt;strong&gt;knowledge&lt;/strong&gt; question. The answer lives in text: a call transcript, an email, a CRM note. Finding the right passage and summarizing it works well.&lt;/p&gt;

&lt;p&gt;The second is a &lt;strong&gt;numbers&lt;/strong&gt; question. The answer is a calculation over records in your CRM, billing system, and product data. There is no paragraph to retrieve. Say the agent writes its own database query against raw tables. It has to guess which table holds revenue, how to treat downgrades, and what "mid-market" means. It may get a different answer every time.&lt;/p&gt;

&lt;p&gt;So a working company brain has two halves:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The knowledge half:&lt;/strong&gt; docs, conversations, decisions, policies. Best served by search, wikis, RAG, and memory.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The numbers half:&lt;/strong&gt; metrics, entities, records. Best served by structured models: knowledge graphs, ontologies, and semantic layers over governed data.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Most of the trade-offs between the six approaches below come down to which half each one serves.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7xn3etlavdvnen20nixk.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7xn3etlavdvnen20nixk.webp" alt="The two halves of a company brain: documents, chat threads, and meeting notes on one side, charts, data tables, and records on the other, both feeding one central node that AI agents read from." width="800" height="447"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Six approaches to building a company brain
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Approach&lt;/th&gt;
&lt;th&gt;Example tools&lt;/th&gt;
&lt;th&gt;Covers&lt;/th&gt;
&lt;th&gt;Freshness&lt;/th&gt;
&lt;th&gt;Governance&lt;/th&gt;
&lt;th&gt;Build effort&lt;/th&gt;
&lt;th&gt;MCP access&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1. Enterprise search&lt;/td&gt;
&lt;td&gt;Glean, Microsoft 365 Copilot search&lt;/td&gt;
&lt;td&gt;Knowledge half&lt;/td&gt;
&lt;td&gt;Live connectors&lt;/td&gt;
&lt;td&gt;Inherits app permissions&lt;/td&gt;
&lt;td&gt;Low (buy)&lt;/td&gt;
&lt;td&gt;Available in leading products&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2. AI wiki / knowledge management&lt;/td&gt;
&lt;td&gt;Notion AI, Confluence with Rovo, Slite&lt;/td&gt;
&lt;td&gt;Knowledge half&lt;/td&gt;
&lt;td&gt;As fresh as people keep pages&lt;/td&gt;
&lt;td&gt;Page-level&lt;/td&gt;
&lt;td&gt;Low (buy)&lt;/td&gt;
&lt;td&gt;Available in leading products&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3. DIY RAG on a vector database&lt;/td&gt;
&lt;td&gt;Vector DB + embeddings + your own pipeline&lt;/td&gt;
&lt;td&gt;Knowledge half&lt;/td&gt;
&lt;td&gt;Depends on your sync jobs&lt;/td&gt;
&lt;td&gt;You build it&lt;/td&gt;
&lt;td&gt;High&lt;/td&gt;
&lt;td&gt;You build it&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4. Knowledge graph + ontology&lt;/td&gt;
&lt;td&gt;Graph databases, Palantir Foundry Ontology&lt;/td&gt;
&lt;td&gt;Both halves, if modeled&lt;/td&gt;
&lt;td&gt;Depends on your pipelines&lt;/td&gt;
&lt;td&gt;Strong, by design&lt;/td&gt;
&lt;td&gt;High&lt;/td&gt;
&lt;td&gt;Varies&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5. AI memory layer&lt;/td&gt;
&lt;td&gt;Sentra, Supermemory, cognee&lt;/td&gt;
&lt;td&gt;Knowledge half, learned over time&lt;/td&gt;
&lt;td&gt;Updates as agents work&lt;/td&gt;
&lt;td&gt;Varies by product&lt;/td&gt;
&lt;td&gt;Medium&lt;/td&gt;
&lt;td&gt;Common&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6. Data platform + semantic layer + MCP&lt;/td&gt;
&lt;td&gt;dbt Semantic Layer, Cube, RevOS&lt;/td&gt;
&lt;td&gt;Numbers half&lt;/td&gt;
&lt;td&gt;Scheduled data syncs&lt;/td&gt;
&lt;td&gt;Strong: governed metrics&lt;/td&gt;
&lt;td&gt;Medium (needs data pipelines in shape)&lt;/td&gt;
&lt;td&gt;Built into some products, plan-dependent in others&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  1. Enterprise search (Glean and similar)
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;What it is.&lt;/strong&gt; Enterprise search connects to your apps (Google Drive, Slack, Jira, Salesforce, Confluence) and builds one index across them. An AI assistant on top answers questions by retrieving the most relevant documents and messages. &lt;a href="https://www.glean.com/" rel="noopener noreferrer"&gt;Glean&lt;/a&gt; is one of the best-known products in this category.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strengths.&lt;/strong&gt; Fast to roll out, because it uses content you already have. Respects the permissions of each source app. Good at "where is the doc about X?" and "summarize what we know about Y."&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where it breaks.&lt;/strong&gt; Search finds text. It does not define your business terms or calculate metrics. If three dashboards show three different revenue numbers, search will happily find all three.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Best fit.&lt;/strong&gt; Large companies with knowledge scattered across dozens of tools, where the main pain is finding things.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. AI wiki and knowledge management (Notion AI, Confluence with Rovo)
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;What it is.&lt;/strong&gt; Your wiki or docs tool adds an AI assistant that answers questions from the pages you have written. Notion AI, Atlassian's Rovo on top of Confluence, and Slite all take this approach. This is the core of the "AI knowledge management" category.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strengths.&lt;/strong&gt; The content is curated. People wrote these pages on purpose, so quality is often higher than raw chat history. Easy to adopt if your team already lives in the wiki.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where it breaks.&lt;/strong&gt; It only knows what someone wrote down, and pages go stale. Atlassian's own research found that &lt;a href="https://www.atlassian.com/blog/state-of-teams-2025" rel="noopener noreferrer"&gt;leaders and teams waste 25% of their time just searching for answers&lt;/a&gt;. That is a reminder that a wiki alone does not fix findability. (Atlassian sells Confluence, so read that figure as a vendor's survey.) Wikis also hold few live numbers.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Best fit.&lt;/strong&gt; Teams with a strong documentation habit who want AI answers over their existing pages.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. DIY RAG on a vector database
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;What it is.&lt;/strong&gt; You build the pipeline yourself. Documents are split into chunks and turned into embeddings, which are numeric representations of meaning. The embeddings go into a vector database. When a question comes in, the closest chunks are retrieved and the model answers from them.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strengths.&lt;/strong&gt; Full control over sources, models, cost, and where data lives. No vendor lock-in.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where it breaks.&lt;/strong&gt; Everything a product would handle is now yours: connectors, permissions, refresh jobs, chunking strategy, and evaluation. Retrieval by similarity is weak on numbers and on questions that span records. Many DIY efforts stall. Slite surveyed 149 teams, and &lt;a href="https://slite.com/learn/company-brain-survey-findings" rel="noopener noreferrer"&gt;of the teams that had tried to build their own company brain, 55% gave up&lt;/a&gt;. (Slite sells a competing product, and only part of that sample had tried a DIY build, so treat this as a signal.)&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Best fit.&lt;/strong&gt; Engineering-heavy teams with unusual data, strict hosting needs, or a product that needs RAG anyway.&lt;/p&gt;

&lt;p&gt;For a deeper technical comparison of RAG with other ways to structure data, see our guide to &lt;a href="https://www.revos.ai/blog/structuring-data-for-ai-agents" rel="noopener noreferrer"&gt;how semantic models, knowledge graphs, and RAG compare as ways to structure data for agents&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Knowledge graph with an ontology
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;What it is.&lt;/strong&gt; You model your business as entities (customers, contracts, products, people) and the relationships between them. The &lt;strong&gt;ontology&lt;/strong&gt; defines which entities and relationships are allowed. The &lt;strong&gt;knowledge graph&lt;/strong&gt; stores the actual data. Palantir's Foundry, for example, is built around what it calls the &lt;a href="https://www.palantir.com/docs/foundry/ontology/overview/" rel="noopener noreferrer"&gt;Ontology&lt;/a&gt;, a model of an organization's objects and links.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strengths.&lt;/strong&gt; Structure helps AI accuracy on business questions. In 2023, researchers at data.world, a data catalog vendor built on knowledge graphs, tested GPT-4 on business questions. It answered &lt;a href="https://arxiv.org/abs/2311.07509" rel="noopener noreferrer"&gt;16% correctly when querying SQL tables directly, and 54% when the same data was modeled as a knowledge graph&lt;/a&gt;. The study is small, uses older models, and comes from a vendor that sells knowledge-graph tools. Still, it suggests that explicit structure helps more than asking a model to infer it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Knowledge graph vs RAG.&lt;/strong&gt; RAG retrieves text that looks similar to the question. A knowledge graph follows explicit links between records. So RAG suits "what does this document say?", while a graph suits "how does this customer connect to that contract and that support ticket?" Many teams use RAG for documents and a graph or semantic layer for connected records.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where it breaks.&lt;/strong&gt; Graphs are expensive to build and maintain. Someone has to design the ontology and keep it accurate as the business changes. That is a real ongoing cost, and it is overkill for simple lookups.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Best fit.&lt;/strong&gt; Large organizations with complex, connected domains (supply chains, regulated industries) and the team to maintain an ontology.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. AI memory layer
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;What it is.&lt;/strong&gt; Instead of indexing everything up front, a memory layer learns as agents and people work. It stores facts, preferences, and decisions from conversations and tasks, then feeds them back as context. Sentra, Supermemory, and the open-source cognee are examples.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strengths.&lt;/strong&gt; Memory layers target a gap that MIT NANDA's July 2025 report on enterprise AI, &lt;em&gt;The GenAI Divide&lt;/em&gt;, described directly: &lt;a href="https://mlq.ai/media/quarterly_decks/v0.1_State_of_AI_in_Business_2025_Report.pdf" rel="noopener noreferrer"&gt;"most GenAI systems do not retain feedback, adapt to context, or improve over time"&lt;/a&gt;. (The report calls its findings preliminary.)&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where it breaks.&lt;/strong&gt; Memory is only as good as what it captures, and it is hard to audit. When two conversations disagree, who decides which remembered "fact" is correct? Governance and permissions differ widely between products. Memory also does not calculate metrics.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Best fit.&lt;/strong&gt; Teams running many agents on ongoing work, where carrying context between sessions matters most.&lt;/p&gt;

&lt;h3&gt;
  
  
  6. Data platform with a semantic layer and MCP
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;What it is.&lt;/strong&gt; This approach builds the numbers half. Data from your CRM, billing, and product systems flows into a warehouse. A semantic layer defines your metrics and entities once (revenue, churn, active customer), so every AI agent uses the same definitions. An MCP server exposes those governed definitions to any agent. When an agent asks for net revenue retention, it picks a defined metric. It does not write its own query from scratch. Tools in this space include the dbt Semantic Layer, Cube, and RevOS.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strengths.&lt;/strong&gt; Answers to numbers questions stay consistent. In 2026, dbt Labs compared its semantic layer with text-to-SQL, where the AI writes its own database query. With Claude Sonnet 4.6 and some light modeling, accuracy rose &lt;a href="https://docs.getdbt.com/blog/semantic-layer-vs-text-to-sql-2026" rel="noopener noreferrer"&gt;from 90.0% with text-to-SQL to 98.2% with the semantic layer&lt;/a&gt;. The authors noted a more useful difference: "With text-to-SQL, failure looks like a plausible but incorrect answer. With the Semantic Layer, failure looks like an error message." (dbt sells a semantic layer, and the test set is small.) For a company brain that difference matters, because an error gets noticed and a plausible wrong number usually doesn't.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where it breaks.&lt;/strong&gt; It does not read your docs, Slack, or meeting notes. It answers "what is true in our data?", not "what did we decide and why?" It also needs your data pipelines to be in shape. In a Harvard Business Review Analytic Services survey sponsored by Cloudera, &lt;a href="https://cloudera.com/about/news-and-blogs/press-releases/2026-03-05-only-7-percent-of-enterprises-say-their-data-is-completely-ready-for-ai-according-to-new-report-from-cloudera-and-harvard-business-review-analytic-services-reveals.html" rel="noopener noreferrer"&gt;only 7% of respondents said their organization's data was completely ready for AI&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where RevOS fits.&lt;/strong&gt; RevOS bundles this half into one managed platform. It syncs data from tools like HubSpot, Salesforce, and Stripe into a managed warehouse. It defines metrics once in a &lt;a href="https://www.revos.ai/product/semantic-model?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=company-brain" rel="noopener noreferrer"&gt;semantic layer (RevOS calls it the semantic model)&lt;/a&gt;. A built-in &lt;a href="https://www.revos.ai/blog/what-is-an-mcp-server-for-data" rel="noopener noreferrer"&gt;MCP server for data&lt;/a&gt; then serves those metrics to Claude, ChatGPT, or Copilot, and to &lt;a href="https://www.revos.ai/product/agents" rel="noopener noreferrer"&gt;RevOS's own agents&lt;/a&gt;, which run natively in your Microsoft Teams or Slack. It sits next to enterprise search or your wiki rather than replacing them.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Best fit.&lt;/strong&gt; B2B companies whose most important AI questions are about revenue, customers, and product usage, and who want those answers to match across every agent and dashboard.&lt;/p&gt;

&lt;h2&gt;
  
  
  What breaks in a company brain
&lt;/h2&gt;

&lt;p&gt;Keeping a company brain accurate after launch is harder than setting it up. In Slite's survey, only &lt;a href="https://slite.com/learn/company-brain-survey-findings" rel="noopener noreferrer"&gt;19.6% of respondents said they have a company brain that works flawlessly&lt;/a&gt;. Slite itself calls that figure a ceiling. The survey also pointed to upkeep, not technology, as the main reason DIY builds were abandoned. The same failure modes show up in every approach:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Stale content.&lt;/strong&gt; Pages, embeddings, and memories age. Without owners and refresh jobs, the brain confidently repeats last year's pricing.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Permissions that drift.&lt;/strong&gt; An agent must not show salary data to someone who could not open the source file. Every approach needs to inherit or enforce source-system permissions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Conflicting definitions.&lt;/strong&gt; If "active customer" means three things in three places, no amount of retrieval fixes it. Define it once, in an ontology or a semantic layer, and make every tool use that definition.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No evaluation.&lt;/strong&gt; Few teams test whether answers are correct. Keep a set of real questions with known answers and rerun them after every change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Siloed sources.&lt;/strong&gt; Data that never reaches the brain cannot inform it. In the same HBR Analytic Services survey, the &lt;a href="https://cloudera.com/about/news-and-blogs/press-releases/2026-03-05-only-7-percent-of-enterprises-say-their-data-is-completely-ready-for-ai-according-to-new-report-from-cloudera-and-harvard-business-review-analytic-services-reveals.html" rel="noopener noreferrer"&gt;top obstacle to AI readiness, cited by 56% of respondents, was siloed data and difficulty integrating sources&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How to build a company brain: a practical setup
&lt;/h2&gt;

&lt;p&gt;To build a company brain, list the questions it must answer. Then pick one tool for documents and decisions and one governed layer for business metrics. Define key terms once, and expose both through MCP so every agent reads the same context. Few products cover both halves well today, so most teams combine two.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpjbt6lnnabdin7mnmfw5.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpjbt6lnnabdin7mnmfw5.webp" alt="A document store and a governed data-and-metrics store both plugging into one central MCP connector hub, which feeds context to several AI agents." width="800" height="447"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;List the questions.&lt;/strong&gt; Write down 30 real questions your teams and agents need answered. Sort them into knowledge questions and numbers questions. This tells you which half matters more.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pick a knowledge-half tool.&lt;/strong&gt; If your content is spread across many apps, start with enterprise search such as Glean. If your team already writes good docs, use your wiki's AI, such as Notion AI or Rovo. Build RAG yourself only if you have a strong reason.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pick a numbers-half tool.&lt;/strong&gt; Put your business data in one governed place and define key metrics and entities once, in a semantic layer or ontology. Options include the dbt Semantic Layer, Cube, or a bundled platform such as RevOS.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agree on definitions.&lt;/strong&gt; Write down what "customer", "active", "churn", and "pipeline" mean. Use the same definitions in both halves.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Connect everything through MCP.&lt;/strong&gt; Expose both halves as MCP servers so Claude, ChatGPT, Copilot, and your own agents all read the same context.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Set owners and tests.&lt;/strong&gt; Give each source an owner. Rerun your question set on a schedule and after every change.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Start with one team and its questions, cover both halves for that team, and expand once the answers hold up.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which company brain approach should you choose?
&lt;/h2&gt;

&lt;p&gt;Most teams will combine approaches rather than pick one. Search, wikis, RAG, and memory serve the knowledge half of a company brain. Knowledge graphs, ontologies, and semantic layers give the numbers half the structure it needs, and MCP connects both to the agents you run.&lt;/p&gt;

&lt;p&gt;If your most important AI questions are about revenue, customers, and product usage, the numbers half is where to start. &lt;a href="https://www.revos.ai/product/semantic-model?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=company-brain" rel="noopener noreferrer"&gt;See how the RevOS semantic model gives every agent one governed view of your business data&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is a company brain?&lt;/strong&gt;&lt;br&gt;
A company brain is a shared context layer that holds what your company knows, so any AI agent or teammate can use it. It covers documents, conversations, decisions, definitions, and business data. Instead of each AI tool guessing from scratch, every agent draws on the same agreed context about how the business works.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do you build a company brain?&lt;/strong&gt;&lt;br&gt;
List the questions it must answer. Use enterprise search, a wiki, or RAG for documents and decisions. Use a semantic layer or ontology over your business data for metrics. Define key terms once, enforce the same permissions as your source systems, and expose both halves to your AI agents through MCP. Then assign owners so the content stays current.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is the difference between a company brain and enterprise search?&lt;/strong&gt;&lt;br&gt;
Enterprise search (for example Glean) indexes your existing apps and returns the most relevant documents and messages for a query. A company brain is broader. It is the full context layer an AI agent relies on, which can include a search index but also definitions, decisions, memory, and governed business metrics. Search is one way to build part of a company brain, not the whole thing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is a company brain the same as a wiki or AI knowledge base?&lt;/strong&gt;&lt;br&gt;
No. A wiki or AI knowledge base stores pages that people write, and an AI answers from those pages. A company brain uses that content as one source, but it also needs live business data, agreed definitions of terms, and permissions that follow your source systems. A wiki is one input to a company brain, not the whole brain.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is a company brain the same as a data catalog or semantic layer?&lt;/strong&gt;&lt;br&gt;
No. A data catalog lists your tables and who owns them, but it does not answer business questions. A semantic layer defines business metrics such as revenue and churn once, so every tool calculates them the same way. A semantic layer is one part of a company brain, the part that covers numbers. The brain also needs the knowledge half: documents, conversations, and decisions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is the difference between a company brain and RAG?&lt;/strong&gt;&lt;br&gt;
RAG (retrieval-augmented generation) is a technique: it finds text passages that match a question and hands them to an AI model. A company brain is the whole context layer. Many company brains use RAG to serve documents, but RAG alone does not define business terms, calculate metrics, or manage permissions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is a context layer?&lt;/strong&gt;&lt;br&gt;
A context layer supplies the business context an AI model needs to give correct, company-specific answers. That includes what terms mean, how metrics are calculated, who can see what, and what was decided. Context layer and company brain describe the same idea. Context layer is the more technical name.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is the difference between a knowledge graph and an ontology?&lt;/strong&gt;&lt;br&gt;
An ontology is the schema. It defines the types of things in your business (customer, contract, product), their properties, and how they may relate. A knowledge graph is the data: the actual customers, contracts, and products stored as connected nodes that follow that schema. The ontology keeps the graph consistent as it grows.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Knowledge graph vs RAG: which is better for a company brain?&lt;/strong&gt;&lt;br&gt;
RAG retrieves text passages that look similar to a question. It is quick to set up and works well for documents. A knowledge graph stores explicit entities and relationships, so it handles questions that follow connections across records. Many teams use RAG for documents and structured models for data.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How does a company brain connect to Claude or ChatGPT?&lt;/strong&gt;&lt;br&gt;
Through MCP (Model Context Protocol), the open standard for connecting AI assistants to external tools and data. Glean, Notion, Atlassian Rovo, and several memory and data platforms now offer MCP servers. Once your company brain runs one, Claude, ChatGPT, Copilot, or a custom agent can query it without a custom integration for each tool.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;This article was originally published on the &lt;a href="https://www.revos.ai/blog/company-brain?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=company-brain" rel="noopener noreferrer"&gt;RevOS blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Want to see this on your own revenue data? &lt;a href="https://try.revos.ai/meetings/renat/revos-demo?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=company-brain" rel="noopener noreferrer"&gt;Book a RevOS demo&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>rag</category>
      <category>mcp</category>
      <category>dataengineering</category>
    </item>
    <item>
      <title>What Is an MCP Server? A Complete Guide to Model Context Protocol</title>
      <dc:creator>RevOS</dc:creator>
      <pubDate>Fri, 23 Oct 2026 11:57:56 +0000</pubDate>
      <link>https://dev.to/revos/what-is-an-mcp-server-a-complete-guide-to-model-context-protocol-5g1a</link>
      <guid>https://dev.to/revos/what-is-an-mcp-server-a-complete-guide-to-model-context-protocol-5g1a</guid>
      <description>&lt;p&gt;&lt;strong&gt;Key takeaways&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;An MCP server is a standardized connector that lets any AI agent access live data, tools, and services through the Model Context Protocol: a single open standard rather than a custom integration per tool.&lt;/li&gt;
&lt;li&gt;MCP stands for Model Context Protocol, an open specification originally developed by Anthropic. It lets AI models request context, run tools, and read resources in a consistent, structured way.&lt;/li&gt;
&lt;li&gt;Unlike a REST API, an MCP server speaks AI natively: it exposes tools (actions), resources (data), and prompts (reusable templates), not raw HTTP endpoints the model has to interpret.&lt;/li&gt;
&lt;li&gt;For data teams, an MCP server is how you give an AI agent governed access to your warehouse, semantic model, and business metrics without writing a custom integration for every AI tool in your stack.&lt;/li&gt;
&lt;li&gt;RevOS ships an MCP server as its consumption layer, so Claude, Cursor, or any MCP-compatible agent can query your certified revenue metrics by name, without building the integration yourself.&lt;/li&gt;
&lt;li&gt;An MCP server acts on behalf of the user. Its access is established with either a shared secret token or a user-friendly OAuth flow, so the agent inherits the user's own permissions and can only reach data that person could already see.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Your AI assistant sounds confident. It answers in complete sentences, cites figures, and explains its reasoning. The only problem: those figures came from data you pasted into the chat ten minutes ago, or from the model's training data, which ended months before your most recent quarter.&lt;/p&gt;

&lt;p&gt;An MCP server is what changes that. It is the connection between an AI agent and live data: the layer that lets Claude, Cursor, or any AI tool reach into your database, query your business metrics, or trigger an action in an external system, on demand, without you lifting a clipboard.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is an MCP server?
&lt;/h2&gt;

&lt;p&gt;An MCP server is a program that exposes data, tools, and actions to AI agents through the Model Context Protocol. The AI agent connects to it, discovers what it can access, and issues requests. The server handles the rest: querying the underlying system, enforcing permissions, and returning results in a format the model can use.&lt;/p&gt;

&lt;p&gt;In practice it works like this. An AI agent running in Claude or Cursor wants to know your pipeline coverage for Q3. Without an MCP server, it cannot look that up; it only knows what is already in its context window. With an MCP server connected to your data warehouse, it sends a request to the server, which runs the query and returns the answer directly into the agent's working memory.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;💡 &lt;strong&gt;In one sentence:&lt;/strong&gt; an MCP server is the standardized interface that lets an AI agent reach beyond its context window and interact with live data, tools, and services, on its own, without a human copy-pasting or writing custom integration code.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The protocol was designed specifically for AI agents, not for humans or traditional software. That distinction matters: an MCP server does not expose raw HTTP endpoints for a developer to call in code. It exposes things an AI model can discover and use autonomously.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does "MCP" stand for?
&lt;/h2&gt;

&lt;p&gt;MCP stands for &lt;strong&gt;Model Context Protocol&lt;/strong&gt;. It is an open specification originally developed by Anthropic, released in late 2024, and now supported across the broader AI ecosystem, including Cursor, Windsurf, Microsoft Copilot, and dozens of open-source agent frameworks.&lt;/p&gt;

&lt;p&gt;"Model context" describes exactly what it provides: context for the model. An AI model's intelligence is bounded by what is in its context window: the text, documents, and conversation history it can see. The protocol is the mechanism for expanding that window dynamically, by fetching exactly the information the agent needs at the moment it needs it.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does an MCP server work?
&lt;/h2&gt;

&lt;p&gt;The architecture has three components: a &lt;strong&gt;host&lt;/strong&gt;, a &lt;strong&gt;client&lt;/strong&gt;, and a &lt;strong&gt;server&lt;/strong&gt;.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The &lt;strong&gt;host&lt;/strong&gt; is the AI application the user interacts with: Claude Desktop, Cursor, or a custom agent you built. It manages one or more client connections.&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;client&lt;/strong&gt; runs inside the host and maintains a one-to-one connection to a specific MCP server. Each tool or data source you connect gets its own client.&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;server&lt;/strong&gt; is the program that exposes the actual capabilities: the tools, resources, and prompts an AI agent can use.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;When you start a session, the client and server negotiate capabilities (each announces what it can offer), and the agent can begin using whatever is available. The transport layer for local servers is typically standard I/O, a subprocess the host spawns. Remote servers communicate over HTTP, which allows for streaming responses.&lt;/p&gt;

&lt;h3&gt;
  
  
  The three things an MCP server can expose
&lt;/h3&gt;

&lt;p&gt;Every MCP server exposes capabilities through one or more of three primitives:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Tools&lt;/strong&gt; are actions the agent can invoke: running a query, calling an API, submitting a form. A tool has a name, a description, and a schema for its inputs and outputs. The agent reads the description and decides whether to call the tool. For example: a &lt;code&gt;run_metric_query&lt;/code&gt; tool that accepts a metric name and a date range and returns the result.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Resources&lt;/strong&gt; are data the agent can read: documents, files, database records, live feeds. Unlike tools, resources are meant to be retrieved and placed into context, not acted on. For example: a configuration file, a record from a CRM, or a page from a knowledge base.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Prompts&lt;/strong&gt; are reusable templates: predefined instructions or question formats the user or agent can invoke to trigger a specific behavior. For example: a "summarize this quarter's revenue trends" prompt that the agent knows how to fill in and execute against the data.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP server vs. API: what is the difference?
&lt;/h2&gt;

&lt;p&gt;The comparison comes up constantly because both connect software to external systems. They are genuinely different things, and the difference is worth understanding clearly.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;REST API&lt;/th&gt;
&lt;th&gt;MCP server&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Designed for&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Developers calling it from code&lt;/td&gt;
&lt;td&gt;AI agents using it autonomously&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Discovery&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;API docs you read; no self-description at runtime&lt;/td&gt;
&lt;td&gt;Agent queries the server for its capability schema at runtime&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Interaction model&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Request-response, stateless per call&lt;/td&gt;
&lt;td&gt;Stateful session with capability negotiation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;What it exposes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;HTTP endpoints (GET /users, POST /orders)&lt;/td&gt;
&lt;td&gt;Tools, resources, and prompts&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Who decides what to call&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;The developer writing the code&lt;/td&gt;
&lt;td&gt;The agent, based on the task&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The practical consequence: connecting an AI agent to a REST API requires a developer to write integration code (parsing the response, deciding which endpoint to call for which question, handling errors). Connecting an agent to an MCP server requires configuring the server once. After that, the agent figures out what to call on its own.&lt;/p&gt;

&lt;p&gt;This is why "MCP server vs. API" is slightly a false framing. Many MCP servers are thin wrappers around existing REST APIs or databases. The MCP layer is what makes those systems usable by an AI agent without custom integration work per tool.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why AI agents need MCP servers
&lt;/h2&gt;

&lt;p&gt;An AI agent without external connections is like a brilliant analyst in a locked room. They can reason, synthesize, and explain, but only from the materials already in the room. Every question that requires live data forces you to carry that data in from outside: by pasting, uploading, or writing custom code to fetch it.&lt;/p&gt;

&lt;p&gt;MCP removes that constraint. When an agent has access to an MCP server, it can:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ask a question that requires live data and retrieve it on the spot&lt;/li&gt;
&lt;li&gt;Chain multiple tool calls across a task: look up a number, compare it to last quarter, then check which segment drove the change&lt;/li&gt;
&lt;li&gt;Take actions in external systems, not just read from them&lt;/li&gt;
&lt;li&gt;Operate over time, with memory of what it retrieved earlier in the session&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The reason MCP matters more than ad-hoc custom integrations is standardization. Without a common protocol, every AI agent needs a custom integration for every tool it might use, and every tool needs to know about every agent format. With MCP, any server that speaks the protocol works with any client that speaks it. One integration per tool; one client per agent.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP servers for business data: the use case most guides miss
&lt;/h2&gt;

&lt;p&gt;Most writing about MCP servers focuses on developer tools: GitHub repositories, code files, terminal commands, Slack messages. That is the first wave of adoption, and it is real. But it is not where the highest-value use case lives for most B2B SaaS companies.&lt;/p&gt;

&lt;p&gt;The highest-value use case is &lt;strong&gt;giving an AI agent access to business data&lt;/strong&gt;: revenue metrics, pipeline health, customer retention signals, product usage patterns. This is the data that drives decisions, and it lives in places an AI agent currently cannot reach: your data warehouse, your CRM, your billing system.&lt;/p&gt;

&lt;p&gt;The problem with connecting an AI agent directly to a database is not the connection; MCP makes that technically straightforward. The problem is the layer above it.&lt;/p&gt;

&lt;p&gt;If your AI agent can query your data warehouse directly, it will write its own SQL to answer your questions. Sometimes it guesses correctly. More often, it misses a filter, joins the wrong table, or defines "churn" differently than your finance team does, and returns a confident, specific, wrong answer. You have no way to tell which kind of answer you received.&lt;/p&gt;

&lt;p&gt;This is where the &lt;a href="https://www.revos.ai/blog/what-is-a-semantic-layer" rel="noopener noreferrer"&gt;semantic layer&lt;/a&gt; comes in. A semantic layer defines your business metrics once (the exact SQL, the correct joins, the approved filters) and serves them to whatever is reading your data. When your MCP server sits on top of a semantic layer instead of raw database tables, the AI agent does not write SQL. It requests a certified metric by name: "net revenue retention, last quarter, EMEA segment." The semantic layer returns the one correct calculation. The agent cannot hallucinate a definition it never had to invent.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;📊 &lt;strong&gt;The pattern that works:&lt;/strong&gt; raw warehouse tables feed a governed &lt;a href="https://www.revos.ai/product/semantic-model" rel="noopener noreferrer"&gt;semantic model&lt;/a&gt;, and an MCP server exposes that model to AI agents. The agent asks for metrics by name. The semantic layer enforces the definitions. The warehouse returns the data. No custom SQL, no invented business logic, no reconciliation meeting.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h3&gt;
  
  
  What you can actually ask an AI agent with a data MCP server
&lt;/h3&gt;

&lt;p&gt;With a well-structured data MCP server connected to a semantic layer, a RevOps analyst or data engineer can ask questions that previously required an analyst queue:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"What is pipeline coverage for Q4 by segment, compared to this time last year?"&lt;/li&gt;
&lt;li&gt;"Which accounts had a significant drop in product usage in the last 30 days?"&lt;/li&gt;
&lt;li&gt;"What drove the change in net revenue retention from last quarter to this quarter?"&lt;/li&gt;
&lt;li&gt;"Show me the top 20 accounts by expansion opportunity, using our current scoring model."&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Each of these questions requires multiple joins, specific metric definitions, and knowledge of your data model. A data MCP server with a semantic layer underneath handles that translation: the agent selects from defined metrics, not from raw columns.&lt;/p&gt;

&lt;p&gt;This is what &lt;a href="https://www.revos.ai/blog/modern-data-strategy-age-of-ai" rel="noopener noreferrer"&gt;a modern data strategy for the AI era&lt;/a&gt; looks like in practice: not a dashboard refresh cycle, but an AI agent that can answer these questions on demand, with the same definitions your best analyst would use, whenever someone needs to know.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP vs. RAG: a quick distinction
&lt;/h2&gt;

&lt;p&gt;These two come up in the same conversations, and they are genuinely different.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;RAG (Retrieval-Augmented Generation)&lt;/strong&gt; works by taking a question, searching a vector index of documents, pulling the most relevant text chunks, and loading them into the model's context window before it answers. It is a text-retrieval technique, best for unstructured content like documentation, support tickets, or contracts.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;MCP&lt;/strong&gt; is a protocol for tool use and live data access. The agent does not search a vector index; it calls a specific tool or reads a specific resource. For structured data, MCP with a semantic layer is more accurate than RAG because you are retrieving an exact metric definition, not approximating from text.&lt;/p&gt;

&lt;p&gt;In practice, many production systems use both: RAG for knowledge retrieval (documentation, policies, unstructured records) and MCP for live, structured data (metrics, operational data, actions). They are complementary, not competing.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to look for in a data MCP server
&lt;/h2&gt;

&lt;p&gt;Not all MCP servers for data are the same. When you are connecting an AI agent to business-critical metrics, a few things matter beyond "does it work."&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Governed metric definitions.&lt;/strong&gt; If the MCP server exposes raw SQL access, every agent call is a potential metric definition problem. Look for servers that sit on top of a semantic layer, so the agent picks from certified metrics, not from tables.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Row-level and column-level access control.&lt;/strong&gt; An AI agent inherits the permissions of the person using it. If access control is not enforced at the data layer, a user can ask the agent for data they should not see. Access rules defined on the semantic model propagate to every tool that queries through it, including the agent.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Predictable, auditable behavior.&lt;/strong&gt; When an executive asks "where did this number come from?", you need an answer. A data MCP server that routes through a governed semantic model gives you one: the metric name, the definition version, the underlying query, all traceable. &lt;a href="https://www.revos.ai/blog/data-readiness-for-machine-learning" rel="noopener noreferrer"&gt;Getting your data ready for AI agents&lt;/a&gt; starts with that kind of auditability.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Transport and authentication.&lt;/strong&gt; For production deployments, remote MCP servers run over HTTP. Confirm the server supports proper authentication (OAuth, API keys, or session tokens) before connecting it to sensitive data.&lt;/p&gt;

&lt;h2&gt;
  
  
  How is an MCP server secured?
&lt;/h2&gt;

&lt;p&gt;Connecting an AI agent to your business data raises an obvious question: what can it actually see, and who said it could? The answer comes down to identity. A well-built MCP server never holds a blanket key to everything. It acts on behalf of a specific person, and it is bound by that person's existing permissions.&lt;/p&gt;

&lt;p&gt;There are two common ways that identity gets established: a shared secret token, or an OAuth flow.&lt;/p&gt;

&lt;h3&gt;
  
  
  Shared secret tokens
&lt;/h3&gt;

&lt;p&gt;The simplest approach is a static credential (an API key, a personal access token, or a bearer token) that you paste into your client's configuration. The agent presents that token on every request, and the server trusts it.&lt;/p&gt;

&lt;p&gt;This is the default for local MCP servers. The Model Context Protocol authorization spec expects local (stdio) servers to read credentials from the environment rather than run a login flow, so a token in a config file or environment variable is exactly the right tool. It is fast to set up, with no redirect screens or consent prompts.&lt;/p&gt;

&lt;p&gt;The tradeoff is bluntness. A shared secret identifies a connection, not a person. One key maps to one fixed set of permissions, it tends to be long-lived, and it sits in plaintext wherever you stored it. If it leaks, whoever holds it inherits whatever that key could do, with no per-user attribution and a manual rotation to clean up. For a single developer wiring up a local tool, that is fine. For a team querying sensitive revenue data, it is not enough.&lt;/p&gt;

&lt;h3&gt;
  
  
  OAuth: acting on behalf of the user
&lt;/h3&gt;

&lt;p&gt;The better pattern for remote, multi-user servers is OAuth. Instead of pasting a secret, you click "Connect," authenticate with your normal login, and approve a consent screen that spells out exactly what the agent is allowed to do. The MCP server receives a short-lived, scoped access token (no long-lived secret ever lands in your config), and that grant can be refreshed or revoked at any time.&lt;/p&gt;

&lt;p&gt;The MCP authorization spec is built on OAuth 2.1 for HTTP-based servers. The client requests access on behalf of the user, the server validates every token and confirms it was issued specifically for that server, and the flow uses PKCE so the authorization code cannot be intercepted and replayed. The upshot for you is simple: the agent inherits your identity. Every query it runs executes as you, so it can only ever reach data you were already allowed to see.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;🔒 This is why identity matters more than any network firewall here. If the agent runs as the user, your existing access controls (roles, row-level and column-level security defined on the data) do all the work automatically. The agent cannot become a backdoor to data the person behind it could never open themselves.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This is the model RevOS uses. Rather than handing every user a static key, the RevOS MCP server uses a user-friendly OAuth flow: each person connects with their own identity, and the governed semantic layer enforces exactly the permissions they already have. The agent answers questions, but it answers them as you.&lt;/p&gt;

&lt;h3&gt;
  
  
  Risks worth understanding
&lt;/h3&gt;

&lt;p&gt;Even with clean authentication, a handful of MCP-specific risks are worth knowing before you connect a server to sensitive data:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Token passthrough.&lt;/strong&gt; The spec explicitly forbids an MCP server from forwarding the caller's token to an upstream API. If the server needs to call another service, it must obtain its own token for that service. Passing tokens through blurs the trust boundary and invites the next problem.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The confused deputy.&lt;/strong&gt; A server that proxies requests to other systems can be tricked into using its own privileges on behalf of an attacker. Strict redirect-URI validation, per-client consent, and verifying that a token was issued for this server are the standard mitigations.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Prompt injection and tool poisoning.&lt;/strong&gt; Malicious instructions hidden in a tool's description or in the data it returns can hijack the model. This is an LLM-trust problem rather than an auth problem, and it is mitigated by sanitizing inputs and pinning tool definitions so they cannot silently change after you approve them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Over-broad scopes.&lt;/strong&gt; Request only the permissions the task needs. The principle of least privilege keeps the blast radius small if anything does go wrong.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Audit logging.&lt;/strong&gt; You need to know who asked the agent for what. A production MCP server should log authentication and every tool invocation to storage you can trust.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of this is exotic. It is the same identity-and-access discipline you already apply to dashboards and BI tools, extended to the agent that now queries on your behalf.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is the difference between an API and an MCP server?
&lt;/h3&gt;

&lt;p&gt;A REST API exposes HTTP endpoints designed for a developer to call from code. An MCP server exposes tools, resources, and prompts in a structure AI agents understand natively, so the model can discover what is available, decide what to call, and handle the result autonomously. APIs are for developers. MCP servers are for AI agents.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is an MCP server a real server?
&lt;/h3&gt;

&lt;p&gt;Yes. An MCP server is a real process running on a machine, locally or in the cloud, communicating over a transport layer (standard I/O for local processes, HTTP for remote ones). What makes it an MCP server is the protocol it speaks: the Model Context Protocol message format, capability negotiation, and the tools, resources, and prompts it exposes.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why would I need an MCP server?
&lt;/h3&gt;

&lt;p&gt;When you want an AI agent to access live data or perform actions autonomously. Without one, the agent only knows what is in its context window. With an MCP server connected to your data sources, it can query your database, pull your business metrics, or trigger actions on demand. For data teams, this is how you stop manually copying numbers into chat and let the agent retrieve them itself.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does ChatGPT use MCP?
&lt;/h3&gt;

&lt;p&gt;Yes. ChatGPT can connect to MCP servers as custom connectors, and Claude, Cursor, Windsurf, and many open-source agent frameworks support MCP natively too. The RevOS MCP server, for example, can be added in either Claude's or ChatGPT's connector settings.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is MCP in agentic AI?
&lt;/h3&gt;

&lt;p&gt;In agentic AI, MCP is the communication layer between an agent and the tools and data it operates on. Agentic systems plan and act across multiple steps; MCP standardizes how they access external capabilities at each step. The agent discovers what tools are available, calls them as needed, and acts on the results, all through one protocol, without needing a custom integration for every tool.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is an MCP server in simple terms?
&lt;/h3&gt;

&lt;p&gt;An MCP server is a plug-in slot for AI agents. Just as a USB port lets you plug multiple devices into a computer through one standard interface, an MCP server lets an AI agent connect to multiple data sources and tools through one standardized protocol. Instead of asking you to paste in a spreadsheet, the agent queries the server directly and gets the answer itself.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can you host your own MCP server?
&lt;/h3&gt;

&lt;p&gt;Yes. The Model Context Protocol is an open standard with official SDKs in Python, TypeScript, and Java. You can build and host an MCP server for any data source or tool you control. Local servers run as a subprocess over standard I/O. Production servers run as HTTP services. Many teams start with an open-source MCP server for a common tool and build custom ones for proprietary data.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the difference between MCP and RAG?
&lt;/h3&gt;

&lt;p&gt;RAG searches a vector index of documents and pulls relevant text into the model's context window. MCP is a protocol for live tool use and data access: the agent calls a specific tool or queries a specific resource. For unstructured content like documentation, RAG works well. For structured business data like metrics and operational records, MCP with a governed semantic layer is more accurate because the agent retrieves exact definitions instead of approximating from text.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is an MCP server secured?
&lt;/h3&gt;

&lt;p&gt;Through identity. An MCP server authenticates the caller, usually with one of two mechanisms: a shared secret token (an API key or bearer token you configure, the norm for local servers), or an OAuth flow (where you log in and approve scopes, the norm for remote, multi-user servers). With OAuth the server acts on behalf of you specifically, so the agent inherits your permissions and can only reach data you are already allowed to see. The Model Context Protocol authorization spec is built on OAuth 2.1 for HTTP-based servers.&lt;/p&gt;

&lt;h2&gt;
  
  
  The bottom line
&lt;/h2&gt;

&lt;p&gt;An MCP server is the layer that closes the gap between an AI agent's intelligence and the live data it needs to act on. For development teams, it unlocks code-aware agents. For data teams, it unlocks something more significant: an AI that can answer business questions from your actual data, with the same metric definitions your analysts use, without a custom integration per tool.&lt;/p&gt;

&lt;p&gt;The protocol is open, the ecosystem is growing fast, and the infrastructure already exists to build this, or to get it bundled. RevOS ships an MCP server as the top layer of its data platform, on top of a governed semantic model, so any MCP-compatible agent can connect and query your certified metrics by name from day one.&lt;/p&gt;

&lt;p&gt;If you are evaluating what it takes to give AI agents access to your business data, &lt;a href="https://www.revos.ai/blog/what-is-a-semantic-layer" rel="noopener noreferrer"&gt;start with the semantic layer&lt;/a&gt;: that is the governed layer your MCP server should expose. The MCP server is the interface. The semantic layer is what makes the answers trustworthy.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;This article was originally published on the &lt;a href="https://www.revos.ai/blog/what-is-an-mcp-server?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=what-is-an-mcp-server" rel="noopener noreferrer"&gt;RevOS blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Want to see this on your own data? &lt;a href="https://try.revos.ai/meetings/renat/revos-demo?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=what-is-an-mcp-server" rel="noopener noreferrer"&gt;Book a RevOS demo&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>mcp</category>
      <category>ai</category>
      <category>dataengineering</category>
      <category>agents</category>
    </item>
    <item>
      <title>Agentic Data Engineering: How AI Agents Build Data You Can Trust</title>
      <dc:creator>RevOS</dc:creator>
      <pubDate>Tue, 20 Oct 2026 10:21:36 +0000</pubDate>
      <link>https://dev.to/revos/agentic-data-engineering-how-ai-agents-build-data-you-can-trust-2mgh</link>
      <guid>https://dev.to/revos/agentic-data-engineering-how-ai-agents-build-data-you-can-trust-2mgh</guid>
      <description>&lt;p&gt;&lt;strong&gt;Key takeaways&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Agentic data engineering uses autonomous AI agents to build and maintain data pipelines from plain-English intent, not line-by-line code written by hand.&lt;/li&gt;
&lt;li&gt;The bottleneck isn't the model's intelligence. It's the control layer around it: the grounding that tells the agent which answer is right, and the controls that catch a wrong one before it ships.&lt;/li&gt;
&lt;li&gt;A governed semantic layer lifts text-to-SQL accuracy from about 51% to over 90%, proof that context, not capability, decides whether an agent's SQL is correct.&lt;/li&gt;
&lt;li&gt;Trust comes from the workflow: the agent ships changes as a pull request that passes tests and CI before a human merges it. It fails at review time, not in production.&lt;/li&gt;
&lt;li&gt;The data engineer's job shifts from writing every transformation to defining intent, reviewing diffs, and governing what the agent is allowed to do.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The project has been on the roadmap for two quarters. Cohort retention. Lead scoring. LTV by channel. Every week without it costs something concrete: a board question you can't answer, a campaign you can't attribute, a churn signal you caught too late.&lt;/p&gt;

&lt;p&gt;So you did what any technical operator would do in 2026: you opened ChatGPT, or Claude, and asked it to write the SQL. And it did. Beautifully. The queries ran, the numbers came back, the charts looked clean. Then someone asked whether the retention number was &lt;em&gt;actually&lt;/em&gt; right, and you couldn't say. No lineage, no tests, no agreed definition of what "active" even meant. Just fluent SQL nobody had verified. Looking great and being right, it turns out, are very different things.&lt;/p&gt;

&lt;p&gt;That gap, between an AI that can write data code and an AI you can trust to &lt;em&gt;ship&lt;/em&gt; it, is the whole story of &lt;strong&gt;agentic data engineering&lt;/strong&gt;. This guide explains what the term means, how the workflow actually works, the tools that make it possible, and the part most vendors skip: how you let an agent touch production data without getting burned.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is agentic data engineering?
&lt;/h2&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Agentic data engineering is the practice of using autonomous AI agents to design, build, and maintain data pipelines from natural-language intent, instead of an engineer writing every transformation by hand, with limited human oversight.&lt;/strong&gt; The agent plans the work, writes the code (ingestion, SQL, tests), runs it, checks the result, and corrects itself; a human reviews and approves the final change.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The key word is &lt;em&gt;agentic&lt;/em&gt;. A plain AI assistant answers a question and stops. An &lt;strong&gt;agent&lt;/strong&gt; works toward a goal across many steps on its own: it perceives the state of your data, reasons about what to do next, takes an action, reads the outcome, and loops until the goal is met. Researchers call this the &lt;strong&gt;perceive → reason → act → learn&lt;/strong&gt; loop. In data engineering, that loop looks like: explore the warehouse, write a transformation, run the tests, read the failures, fix them, and present the finished change for review.&lt;/p&gt;

&lt;p&gt;This is the shift from doing the &lt;strong&gt;"how"&lt;/strong&gt; by hand to specifying the &lt;strong&gt;"what"&lt;/strong&gt; and reviewing the result. You stop writing every line of SQL and start describing the metric you need, then the agent does the building. The promise is real, but so is the catch, which is the rest of this article.&lt;/p&gt;

&lt;h2&gt;
  
  
  Agentic vs. traditional data engineering, and vs. automation and copilots
&lt;/h2&gt;

&lt;p&gt;Three things get confused with agentic data engineering. They're not the same.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;What it does&lt;/th&gt;
&lt;th&gt;Who decides the steps&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;Static automation&lt;/strong&gt; (cron, Airflow DAGs)&lt;/td&gt;
&lt;td&gt;Runs a fixed sequence someone wrote in advance&lt;/td&gt;
&lt;td&gt;A human, ahead of time&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;AI copilot&lt;/strong&gt; (autocomplete in your editor)&lt;/td&gt;
&lt;td&gt;Suggests the next line or block while you drive&lt;/td&gt;
&lt;td&gt;A human, line by line&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;AI agent&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Pursues a goal across many steps, adapts to what it finds&lt;/td&gt;
&lt;td&gt;The agent, within your guardrails&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Traditional data engineering&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;A person hand-builds each pipeline, query, and test&lt;/td&gt;
&lt;td&gt;A human, step by step&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A scheduler repeats what you already decided. A copilot autocompletes while you stay in control. An &lt;strong&gt;agent&lt;/strong&gt; takes a goal ("build me a weekly cohort-retention model") and figures out the steps itself, including the ones you didn't anticipate. That autonomy is what makes it powerful, and exactly why the controls around it matter so much.&lt;/p&gt;

&lt;p&gt;One more term to untangle: &lt;strong&gt;agentic analytics&lt;/strong&gt;. The two are siblings, not synonyms. Agentic analytics works on the &lt;em&gt;serving&lt;/em&gt; side: it asks questions of data that already exists (the BI and query layer). Agentic data engineering works one layer down: it &lt;em&gt;builds and maintains the pipelines and models&lt;/em&gt; that produce that data in the first place. You need the engineering layer to be sound before the analytics layer can be trusted.&lt;/p&gt;

&lt;h2&gt;
  
  
  How agentic data engineering works
&lt;/h2&gt;

&lt;p&gt;Under the hood, an agentic workflow runs your raw data through the same stages a human data team would, building an AI data pipeline driven by intent instead of tickets:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Ingestion.&lt;/strong&gt; Source data lands in your warehouse from your apps, CRM, product database, and third-party tools. Connectors like Airbyte or Meltano handle the extract-and-load so the agent has raw tables to work from.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Transformation.&lt;/strong&gt; The agent writes the models that turn raw tables into clean, business-ready ones, typically as &lt;a href="https://www.getdbt.com/" rel="noopener noreferrer"&gt;dbt&lt;/a&gt; models in a layered (bronze → silver → gold) structure, with tests attached.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Semantic layer.&lt;/strong&gt; Cleaned tables still don't know what &lt;em&gt;your business&lt;/em&gt; means by "active user" or "qualified lead." A semantic layer encodes those definitions once, so every query, human or agent, uses the same math. (We go deep on this in &lt;a href="https://www.revos.ai/blog/what-is-a-semantic-layer" rel="noopener noreferrer"&gt;what a semantic layer is and why it matters&lt;/a&gt;, and on &lt;a href="https://www.revos.ai/blog/structuring-data-for-ai-agents" rel="noopener noreferrer"&gt;how it compares to knowledge graphs, RAG, and plain markdown + grep&lt;/a&gt; as ways to structure data for an agent.)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Serving.&lt;/strong&gt; The finished metrics are queried by dashboards, notebooks, or, increasingly, by other AI agents over a protocol like MCP (the Model Context Protocol), which lets an agent ask your data questions in a structured, governed way.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;You describe the metric; the agent explores the lakehouse, writes the dbt model, builds the semantic overlay, and runs the tests. That's the happy path. Now the part that decides whether any of it is trustworthy.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the model isn't the bottleneck: it's the control layer
&lt;/h2&gt;

&lt;p&gt;If you've already pointed an AI coding agent at a data problem and watched it produce confident garbage, you've met the real bottleneck. It isn't the model. It's the &lt;strong&gt;control layer&lt;/strong&gt; the model works against.&lt;/p&gt;

&lt;p&gt;So what is a control layer? &lt;strong&gt;A control layer is the software around an AI model that makes its output safe to ship in production: the &lt;em&gt;grounding&lt;/em&gt; that tells the agent which answer is right (your lineage, business semantics, and access policies) and the &lt;em&gt;controls&lt;/em&gt; that catch a wrong answer before it lands (validation loops, data contracts, CI/CD, and an audit trail).&lt;/strong&gt; A model writes code; the control layer decides whether that code is safe to merge.&lt;/p&gt;

&lt;p&gt;The intuition is simple: the model is only the engine. Impressive on a workbench, but useless until it's bolted into the rest of the car: a chassis, wheels, a steering wheel, pedals to control the power, and a dashboard that shows what's actually happening. The control layer is the rest of the car.&lt;/p&gt;

&lt;p&gt;Put a generic agent and an agent with a control layer side by side:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Generic AI agent&lt;/th&gt;
&lt;th&gt;Agent with a control layer&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Starts from&lt;/td&gt;
&lt;td&gt;A blank file: no schema, no definitions&lt;/td&gt;
&lt;td&gt;Your schema, dbt models, and business definitions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Picks the right answer by&lt;/td&gt;
&lt;td&gt;Guessing, fluently&lt;/td&gt;
&lt;td&gt;Grounding: your lineage, semantics, and access policies&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Catches a wrong answer with&lt;/td&gt;
&lt;td&gt;Nothing; it ships&lt;/td&gt;
&lt;td&gt;Validation loops, PK/unique checks, data contracts, CI/CD&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Mistakes surface&lt;/td&gt;
&lt;td&gt;In production, in a downstream dashboard&lt;/td&gt;
&lt;td&gt;At review time, as a pull-request diff&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;In production it acts&lt;/td&gt;
&lt;td&gt;Unsupervised&lt;/td&gt;
&lt;td&gt;Scoped, time-bound, human-in-the-loop, fully audit-logged&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;That gap is measurable. &lt;a href="https://www.snowflake.com/en/blog/engineering/cortex-analyst-text-to-sql-accuracy-bi/" rel="noopener noreferrer"&gt;Snowflake put a number on it&lt;/a&gt;: on text-to-SQL (natural language to SQL), a general-purpose model (GPT-4o) scored just &lt;strong&gt;51%&lt;/strong&gt; on their internal evaluation, while grounding the same task in a governed semantic model pushed accuracy past &lt;strong&gt;90%&lt;/strong&gt; on real-world queries, nearly 2× single-shot GPT-4o. The difference between a wrong query and a right one is almost entirely context, not capability. That's also why &lt;a href="https://www.revos.ai/blog/data-readiness-for-machine-learning" rel="noopener noreferrer"&gt;data readiness&lt;/a&gt; (clean, tested, well-defined inputs) matters more than which model you pick.&lt;/p&gt;

&lt;p&gt;The market already senses this. In &lt;a href="https://cleanlab.ai/ai-agents-in-production-2025/" rel="noopener noreferrer"&gt;Cleanlab's 2025 survey&lt;/a&gt; of 1,837 engineering leaders, only &lt;strong&gt;~5.2%&lt;/strong&gt; run AI agents in production. &lt;a href="https://www.getdbt.com/resources/state-of-analytics-engineering-2026" rel="noopener noreferrer"&gt;dbt's 2026 report&lt;/a&gt; found &lt;strong&gt;72%&lt;/strong&gt; of practitioners want AI-assisted coding but only &lt;strong&gt;24%&lt;/strong&gt; trust it to manage pipelines. &lt;a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/" rel="noopener noreferrer"&gt;METR's 2025 study&lt;/a&gt; even measured experienced developers running &lt;strong&gt;19% slower&lt;/strong&gt; with AI on familiar code while &lt;em&gt;feeling&lt;/em&gt; faster. The appetite is real; the reliability isn't, because the control layer isn't there.&lt;/p&gt;

&lt;p&gt;One principle decides everything downstream: &lt;strong&gt;the agent fails at review time, not in production.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What it looks like in practice
&lt;/h2&gt;

&lt;p&gt;Theory is cheap; here's a concrete worked example. At RevOS we built exactly this control layer, so the abstract pieces above have real names. What you install is a packaged offering: a set of APIs, a command-line interface, documentation, and curated agentic skills, wrapped in a dev container you open in your IDE (Visual Studio Code or similar) and drive with Claude Code (or a coding agent of your choice). There's no new UI to learn; it lives where you already write code.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcd1hj0k6gyjc0t1qfk7v.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcd1hj0k6gyjc0t1qfk7v.png" alt="The RevOS demo project open in a VS Code dev container: the dbt medallion models (bronze, silver, and gold staging and mart models) in the file explorer, with Claude Code describing the scaffolded sample datasets and data-quality stats." width="800" height="602"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;&lt;code&gt;revos init&lt;/code&gt; scaffolds a working project (medallion dbt models, semantic cubes, and sample data) that your agent can explore from minute one.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Under that surface, RevOS wires together a best-of-breed stack (automated data ingestion, dbt for transformation, Cube.dev for the semantic layer, Git for versioning, BigQuery as the warehouse), so your agent starts with your schema, your models, and your definitions instead of a blank file. You describe the metric you need; the agent explores your lakehouse, writes the dbt model, and builds the semantic overlay. (For the full product view, see how RevOS helps you &lt;a href="https://www.revos.ai/product/agentic-data-engineering" rel="noopener noreferrer"&gt;build a revenue or growth data layer without hiring a data engineer&lt;/a&gt;.)&lt;/p&gt;

&lt;p&gt;Then the part that earns trust: when the agent finishes a model, the control layer doesn't accept it on faith. Validation loops run. Primary-key and unique-constraint checks fire. YAML data-contract enforcement kicks in. The change moves through the &lt;strong&gt;same Git CI/CD pipeline as your application code&lt;/strong&gt; and lands on your desk as a pull request with a diff. When the agent gets it wrong (and it will), you catch it in the PR, not at 3 a.m. in a downstream dashboard.&lt;/p&gt;

&lt;h2&gt;
  
  
  The trust problem: governing an AI agent on production data
&lt;/h2&gt;

&lt;p&gt;The single hardest question in agentic data engineering is the one most marketing pages dodge: &lt;em&gt;how do you let an autonomous agent near production without it doing something irreversible?&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The answer is workflow, not faith. Three controls do the heavy lifting:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Changes ship as pull requests.&lt;/strong&gt; The agent never writes directly to production. It proposes a diff that runs through tests and CI; a human reads it and merges it. This is the concrete meaning of "fails at review time." A wrong model is a red check on a PR, not a corrupted table.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Permissions are scoped and time-bound.&lt;/strong&gt; The agent gets exactly the access a task needs, for as long as the task takes, not standing admin rights. Mutating actions in production (schema changes, deletions, permission grants) keep a human in the loop by design. Scoping is only half the job: the agent also needs an identity distinct from the authority it borrows, so that &lt;em&gt;who acted&lt;/em&gt; and &lt;em&gt;who permitted it&lt;/em&gt; stay separable after the fact. See &lt;a href="https://www.revos.ai/blog/ai-agent-identity" rel="noopener noreferrer"&gt;AI agent identity&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every action is audit-logged.&lt;/strong&gt; An immutable trail of what the agent did, when, and why means you can answer "what changed?" after the fact. That's the difference between a controlled system and a black box.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Why be this strict? Because verbal guardrails don't bind an agent; technical ones do. The widely reported case of an AI agent wiping a live production database during a code freeze is the cautionary tale: it had every capability to help and none of the controls to be safe. Autonomy should scale &lt;em&gt;as trust accrues&lt;/em&gt;, never the other way around.&lt;/p&gt;

&lt;h2&gt;
  
  
  Will AI agents replace data engineers?
&lt;/h2&gt;

&lt;p&gt;Short answer: no. They change the job. The "AI data engineer" worth imagining is a tooling shift, not a headcount replacement. The work that agents absorb is the repetitive build work: boilerplate models, test scaffolding, documentation, the tenth slightly-different staging table. What they don't absorb is judgment: deciding what a metric &lt;em&gt;should&lt;/em&gt; mean, whether a result is plausible, and what the agent is allowed to touch.&lt;/p&gt;

&lt;p&gt;So the role moves up the stack. Less time typing SQL; more time defining intent, reviewing the agent's pull requests, and owning the semantic layer and governance that keep the agent correct. The scarce, valuable skill becomes knowing what "right" looks like, which is exactly the skill a generic model lacks. Put simply, an AI data engineer doesn't replace the human one; it hands the human a faster, more reviewable way to work. (For the bigger picture of how AI reshapes data work, see our take on &lt;a href="https://www.revos.ai/blog/modern-data-strategy-age-of-ai" rel="noopener noreferrer"&gt;modern data strategy in the age of AI&lt;/a&gt;.)&lt;/p&gt;

&lt;p&gt;That same shift, from recognizing a familiar pattern to reasoning through an unfamiliar one, is why the scarce skill is so hard to fake or shortcut. One of our engineers hit this exact wall &lt;a href="https://www.revos.ai/blog/dp-700-exam-recognition-vs-retrieval" rel="noopener noreferrer"&gt;studying for a Microsoft Fabric certification&lt;/a&gt;: passing every practice test only taught him to recognize answers, and the real exam tested whether he could reason his way to new ones.&lt;/p&gt;

&lt;h2&gt;
  
  
  What tools power agentic data engineering
&lt;/h2&gt;

&lt;p&gt;There's no single product called "agentic data engineering." It's a stack, and you can assemble it from best-of-breed parts:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Ingestion:&lt;/strong&gt; Airbyte, Fivetran, or Meltano move raw data into the warehouse.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Transformation:&lt;/strong&gt; dbt is the de facto standard for version-controlled, tested SQL models.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Semantic layer:&lt;/strong&gt; Cube.dev (or dbt's own semantic layer) encodes business definitions so queries stay consistent.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Warehouse / lakehouse:&lt;/strong&gt; BigQuery, Snowflake, Databricks, or an open table format like Iceberg or Delta.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Version control + CI/CD:&lt;/strong&gt; Git plus a pipeline that runs tests on every change. This is what makes the PR-review safety model possible.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The agent:&lt;/strong&gt; a coding agent like Claude Code (a data engineering agent once it's pointed at your warehouse), connected to your data and tools through MCP, that actually writes and runs the work.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The agent is the smallest piece. The other five are the control layer, and they're what separate a fun demo from something you'd trust with a board number. Tools that bundle these into one governed workflow (RevOS pre-wires dbt, Cube.dev, BigQuery, and Git behind a Claude Code agent) save you from stitching them together yourself, but the architecture is the same whether you buy it or build it. Claude Code itself is only one surface in a growing family. If you're also weighing Claude Cowork, Claude Tag, or one of Anthropic's several "Routines" for scheduling this kind of work, see our &lt;a href="https://www.revos.ai/blog/claude-code-cowork-tag-routines" rel="noopener noreferrer"&gt;map of the Claude ecosystem&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where agentic data engineering is headed
&lt;/h2&gt;

&lt;p&gt;The category is young and moving fast, and the direction is clear: data engineering is going AI-native, with pipelines built around agents from the first commit rather than retrofitted onto a hand-built stack. A few specifics worth watching:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;More backends and open formats.&lt;/strong&gt; Iceberg and Delta are pulling the warehouse and the lake together, which gives agents one consistent surface to work against.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Broader warehouse support.&lt;/strong&gt; Today many agentic tools are warehouse-specific; expect coverage to widen across Snowflake, Databricks, and Microsoft Fabric.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open connectivity and semantic standards.&lt;/strong&gt; Frameworks like Meltano for ingestion, and competing semantic-model languages, are converging toward portability, so your definitions aren't locked to one vendor.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agents querying agents.&lt;/strong&gt; As MCP matures, the consumer of your data layer is increasingly another AI agent, not a human in a dashboard. That raises the bar on governance, because the semantic layer is now the contract between machines. Governance is only half the picture, though. The agent also has to stay reliably &lt;em&gt;running&lt;/em&gt;, and &lt;a href="https://www.revos.ai/blog/hermes-agent-kubernetes" rel="noopener noreferrer"&gt;what breaks when you deploy a self-improving agent like Hermes Agent to Kubernetes&lt;/a&gt; is its own reliability problem.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The throughline: the model gets cheaper and smarter every quarter, but the value keeps moving to the control layer around it. Whoever owns clean, governed, well-defined data wins, which is why we've argued the &lt;a href="https://www.revos.ai/blog/generative-ai-dilemma-opportunity-vs-monopoly" rel="noopener noreferrer"&gt;real AI advantage is your data, not the model&lt;/a&gt;, and why that data, once captured as decision traces in a governed semantic model, becomes what's now being called &lt;a href="https://www.revos.ai/blog/token-capital" rel="noopener noreferrer"&gt;token capital&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Getting started
&lt;/h2&gt;

&lt;p&gt;You don't need to adopt the whole category at once. The fastest way to feel the difference is to put an agent on a stack it already understands and ask for one real metric.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;The idea of giving Claude Code a structured dbt/Cube/BigQuery environment makes a lot of sense. The predefined context, conventions, and architecture should help generate more accurate and consistent results than a generic AI coding assistant.&lt;/p&gt;

&lt;p&gt;What stood out to me most was the focus on combining AI with a well-defined data framework rather than just code generation. That feels like a meaningful differentiator. For teams that need a revenue or growth data layer but don't yet have a dedicated data engineer, this could significantly accelerate implementation and reduce complexity while still allowing for human oversight where needed.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Vira Slipchenko, Data Analyst, Fin-Navi GmbH&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The reproducible version with RevOS: install the CLI and run &lt;code&gt;revos init&lt;/code&gt;. You land in a working project preloaded with sample datasets and models, so there's something real to point your agent at from minute one. Ask it to explore the sample lakehouse and build your first model. From install to a production-ready model is an afternoon, not a quarter. The full set of agent capabilities, skills, and interfaces is on the free plan (up to 1 GB of storage), so trying it costs you an afternoon and nothing more.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;npm i -g @revos/cli
revos init
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The zero-to-scheduled-action walkthrough lives at &lt;a href="https://cli.revos.dev" rel="noopener noreferrer"&gt;cli.revos.dev&lt;/a&gt;. Try it out today.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is agentic data engineering?
&lt;/h3&gt;

&lt;p&gt;Agentic data engineering is the practice of using autonomous AI agents to design, build, and maintain data pipelines from natural-language intent, instead of an engineer writing every transformation by hand. The agent plans the work, writes the code (ingestion, SQL, tests), runs it, checks the result, corrects itself, and a human approves the change.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is agentic data engineering different from traditional data engineering?
&lt;/h3&gt;

&lt;p&gt;Traditional data engineering is task-driven: a person writes each pipeline, query, and test step by step. Agentic data engineering is intent-driven and autonomous: you describe the outcome you want, an AI agent plans and executes the steps and validates its own work with limited human oversight, and you review the result. The shift is from doing the "how" by hand to specifying the "what" and approving the diff.&lt;/p&gt;

&lt;h3&gt;
  
  
  What's the difference between an AI copilot and an AI data agent?
&lt;/h3&gt;

&lt;p&gt;A copilot suggests code one line at a time while you stay in the driver's seat. An agent works toward a goal across many steps on its own: it explores your data, writes a model, runs tests, reads the errors, and fixes them in a loop. A copilot autocompletes; an agent completes a task.&lt;/p&gt;

&lt;h3&gt;
  
  
  Will AI agents replace data engineers?
&lt;/h3&gt;

&lt;p&gt;No. They change the job. Agents handle the repetitive build work (boilerplate models, tests, documentation), while engineers move up to defining metrics and intent, reviewing the agent's pull requests, and governing what it's allowed to touch. The scarce skill becomes judgment about what is correct, not typing SQL faster.&lt;/p&gt;

&lt;h3&gt;
  
  
  How accurate is AI at writing SQL?
&lt;/h3&gt;

&lt;p&gt;A general-purpose model writing SQL from a raw schema is unreliable: GPT-4o scored about 51% on Snowflake's internal text-to-SQL evaluation. Grounding the same task in a governed semantic model pushed accuracy past 90%. The difference between a wrong query and a right one is almost entirely context, not the model's raw capability.&lt;/p&gt;

&lt;h3&gt;
  
  
  What tools power agentic data engineering?
&lt;/h3&gt;

&lt;p&gt;A typical stack pairs automated ingestion (Airbyte, Meltano), a transformation framework (dbt), a semantic layer (Cube.dev), a warehouse (BigQuery, Snowflake, Databricks), version control and CI/CD (Git), and a coding agent (Claude Code) connected to your data through MCP. The agent writes and runs the transformations; the rest is the control layer that keeps its output correct and safe.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is it safe to let an AI agent work on production data?
&lt;/h3&gt;

&lt;p&gt;It is safe when autonomy is earned, not granted by default. Permissions should be scoped and time-bound, every action should land in an immutable audit log, and mutating actions in production (schema changes, deletions, permission grants) should keep a human in the loop. Changes arriving as a reviewable pull-request diff mean mistakes surface at review time, not in a live dashboard.&lt;/p&gt;

&lt;h3&gt;
  
  
  Do AI data agents need a semantic layer?
&lt;/h3&gt;

&lt;p&gt;They work far better with one. A semantic layer encodes your business definitions (what "active user", "revenue", or "churn" actually mean) so the agent doesn't have to guess them from raw column names. It's the single biggest lever on accuracy: the same model that guesses against a raw schema becomes reliable when it queries a governed semantic model.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do I get started with agentic data engineering?
&lt;/h3&gt;

&lt;p&gt;Start small on a stack the agent already understands. With RevOS you install the CLI, run &lt;code&gt;revos init&lt;/code&gt;, and land in a working project preloaded with sample data, dbt models, and a semantic layer, then point a coding agent at it and ask for your first metric. From install to a production-ready model is an afternoon, and the free plan (up to 1 GB) makes trying it cost nothing but time.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;This article was originally published on the &lt;a href="https://www.revos.ai/blog/agentic-data-engineering?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=agentic-data-engineering" rel="noopener noreferrer"&gt;RevOS blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Want to see this on your own data? &lt;a href="https://try.revos.ai/meetings/renat/revos-demo?utm_source=devto&amp;amp;utm_medium=syndication&amp;amp;utm_campaign=agentic-data-engineering" rel="noopener noreferrer"&gt;Book a RevOS demo&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>dataengineering</category>
      <category>ai</category>
      <category>dbt</category>
      <category>agents</category>
    </item>
    <item>
      <title>AI Trends 2026: Self-Service BI Is Becoming Agentic</title>
      <dc:creator>RevOS</dc:creator>
      <pubDate>Thu, 08 Oct 2026 11:16:44 +0000</pubDate>
      <link>https://dev.to/revos/ai-trends-2026-self-service-bi-is-becoming-agentic-2ngf</link>
      <guid>https://dev.to/revos/ai-trends-2026-self-service-bi-is-becoming-agentic-2ngf</guid>
      <description>&lt;p&gt;The way people get answers out of company data is changing faster than the data stacks underneath them. For twenty years the answer to "why did that number move?" was a dashboard someone built in advance. In 2026, increasingly, the answer is an agent that goes and finds out.&lt;/p&gt;

&lt;p&gt;Among the AI trends 2026 has surfaced, that is the one worth paying attention to. Not "companies are using more AI" (they are) but something more specific: &lt;strong&gt;self-service business intelligence is becoming agentic&lt;/strong&gt;, and the constraint on whether it works has moved from the model to the data foundation underneath it.&lt;/p&gt;

&lt;p&gt;The adoption numbers are already there. According to Google Cloud's ROI of AI Report, 52% of executives report their organizations are deploying AI agents in production, and 88% of agentic AI early adopters are already seeing positive ROI. What those numbers hide is how much of the work is data architecture rather than prompting. To build a trustworthy modern data strategy for the age of AI, you have to change how machines get meaning out of your warehouse, not just how they get access to it.&lt;/p&gt;

&lt;h2&gt;
  
  
  The four generations of self-service analytics
&lt;/h2&gt;

&lt;p&gt;It helps to see where agentic analytics sits in a longer arc. Self-service BI has been reinvented roughly every decade, and each generation moved the work around rather than eliminating it.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Generation&lt;/th&gt;
&lt;th&gt;Interface&lt;/th&gt;
&lt;th&gt;Who does the thinking&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;1. Dashboards&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Pre-built reports&lt;/td&gt;
&lt;td&gt;Humans anticipate the question and build the answer in advance&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;2. Self-service BI&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Filters, dimensions, drag-and-drop&lt;/td&gt;
&lt;td&gt;Business users slice pre-modelled data themselves&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;3. Natural-language analytics&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;A chat box over the warehouse&lt;/td&gt;
&lt;td&gt;An LLM turns a sentence into SQL; the user hopes it is right&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;4. Agentic analytics&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;An agent with tools and governed context&lt;/td&gt;
&lt;td&gt;The agent investigates, validates, and follows up on its own&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The fourth generation is not a nicer chat box. The difference is that an agent doesn't just answer the question you asked, it runs the next three queries a good analyst would have run, checks its own result, and tells you what it found.&lt;/p&gt;

&lt;p&gt;The infrastructure for that is already being built at scale. According to customer usage data compiled by Databricks, multi-agent workflows have grown by 327% year over year, and supervisor agents coordinating networks of specialized subagents now account for 37% of all agent usage.&lt;/p&gt;

&lt;h2&gt;
  
  
  The next generation of self-service BI isn't another dashboard
&lt;/h2&gt;

&lt;p&gt;The promise of self-service BI was always straightforward: let business users answer their own questions without waiting on the data team.&lt;/p&gt;

&lt;p&gt;The interface kept getting easier. The underlying limitation never moved. Someone still had to anticipate the question, model the data, build the dashboard, define the metrics, and teach the user where to look. "Self-service" in practice meant "self-service, within the boundaries of what a data engineer already imagined you'd ask."&lt;/p&gt;

&lt;p&gt;Agents change that equation. Instead of navigating dashboards, a sales leader can ask:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Why did expansion ARR drop in DACH this quarter? Which accounts caused it? What changed in their product usage in the months before the contraction?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;No dashboard answers that question, because it isn't one question, it's an investigation. An agent can run that investigation dynamically: pull the metric, decompose it by account, join in product usage, look at the period before the drop, and come back with a narrative.&lt;/p&gt;

&lt;p&gt;But only if it understands what "expansion ARR," "DACH," "account," and "product usage" mean inside &lt;em&gt;your&lt;/em&gt; business. That is the whole problem.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why raw text-to-SQL breaks agentic analytics
&lt;/h2&gt;

&lt;p&gt;When teams build their first internal analytics agent, the instinct is to connect it straight to the warehouse: hand the model database credentials, write a prompt, and let it generate SQL.&lt;/p&gt;

&lt;p&gt;This is where most projects stall. Direct text-to-SQL has three systemic weaknesses:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Schema complexity.&lt;/strong&gt; A typical enterprise warehouse has hundreds of tables, column names like &lt;code&gt;usr_act_v2&lt;/code&gt;, and three fields that all look like they might be revenue. A model guessing at what those mean will guess wrong often enough to matter.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No metric governance.&lt;/strong&gt; If three agents query raw tables for "Monthly Recurring Revenue," you get three SQL statements and three different numbers, with no way to tell which one leadership should act on.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No safety boundary.&lt;/strong&gt; Raw SQL access exposes every table the credential can reach, including the ones nobody intended an agent to see.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Databricks' customer data points the same direction: a lack of structural control is the single biggest bottleneck to shipping AI. Teams that implement governance and security tooling ship 12x more production deployments, and standardized evaluation tooling yields 6x more.&lt;/p&gt;

&lt;p&gt;The failure mode isn't that the agent can't write SQL. Modern models write excellent SQL. The failure mode is that it doesn't know what your business means.&lt;/p&gt;

&lt;h2&gt;
  
  
  Anthropic reached the same conclusion in production
&lt;/h2&gt;

&lt;p&gt;The strongest evidence for this isn't a vendor benchmark, it's Anthropic publishing its own internal architecture.&lt;/p&gt;

&lt;p&gt;In &lt;em&gt;How Anthropic enables self-service data analytics with Claude&lt;/em&gt; (June 3, 2026), Anthropic's data team reports that &lt;strong&gt;95% of business analytics queries are now automated through Claude, at roughly 95% aggregate accuracy&lt;/strong&gt;, and close to 99% in some domains. The headline result is impressive. The explanation is the useful part.&lt;/p&gt;

&lt;p&gt;Anthropic is explicit that this is not a model story. Analytics accuracy, in their framing, is a &lt;strong&gt;context and verification problem, not a code-generation problem&lt;/strong&gt;. The same Claude that reaches 95% with the right scaffolding never got above &lt;strong&gt;21%&lt;/strong&gt; on their internal evals without it.&lt;/p&gt;

&lt;p&gt;Their agents don't start by improvising SQL. The stack they describe has four layers:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Data foundations:&lt;/strong&gt; the warehouse itself: models, transformations, tests, and the metadata that describes them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sources of truth:&lt;/strong&gt; a human-curated semantic layer of metric and dimension definitions, plus lineage graphs and business-context knowledge. Notably, they found that auto-generating metric definitions from raw tables and query logs &lt;em&gt;didn't&lt;/em&gt; work: it reproduced the ambiguity instead of removing it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Skills:&lt;/strong&gt; procedural knowledge in markdown telling the agent which sources to consult, in what order, and what a finished answer looks like. That skill set is synced to multiple surfaces and served as resources over MCP.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Validation:&lt;/strong&gt; offline evals, ablation testing, and online monitoring with adversarial review.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two details matter most for anyone building this. First, the semantic layer is the &lt;strong&gt;required first path&lt;/strong&gt;: when a question maps to a defined metric, the agent calls that definition and gets the same number every other surface in the company produces. Raw table access is the fallback, not the default. Second, the same governed context is exposed &lt;strong&gt;across agent surfaces&lt;/strong&gt;, so the answer doesn't change depending on whether someone asks in Slack, in an IDE, or in a chat window.&lt;/p&gt;

&lt;p&gt;And they are honest about the limits. This architecture reduces failures; it doesn't eliminate them. Anthropic keeps adversarial review running precisely because silent failures still happen, and reports that without active maintenance accuracy drifts from 95% back toward 65%.&lt;/p&gt;

&lt;p&gt;Better models help. Better context architecture is what makes self-service analytics trustworthy.&lt;/p&gt;

&lt;h2&gt;
  
  
  A governed semantic layer gives agents shared meaning
&lt;/h2&gt;

&lt;p&gt;A semantic layer is the translation between how data is stored and how the business talks. It maps raw tables to defined business concepts: instead of querying &lt;code&gt;billing_ledgers_final&lt;/code&gt;, the agent queries an entity called &lt;code&gt;Revenue&lt;/code&gt; and asks for &lt;code&gt;MRR&lt;/code&gt; broken down by &lt;code&gt;acquisition_channel&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Combining that with agent access gives agents something raw warehouse credentials cannot: a shared definition of customers, revenue, churn, pipeline, and every other concept they need in order to reason correctly.&lt;/p&gt;

&lt;p&gt;The measurable effect is large. A general-purpose model writing SQL against an unmapped schema fails roughly half the time, Snowflake's internal benchmarks put GPT-4o at about &lt;strong&gt;51% text-to-SQL accuracy&lt;/strong&gt; on raw schemas. Grounding the same model in a governed semantic model lifts accuracy past 90%.&lt;/p&gt;

&lt;p&gt;That is the same conclusion Anthropic reached, arrived at from a different direction: the governed definition is what turns a plausible answer into a correct one.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP is becoming the interface between agents and business data
&lt;/h2&gt;

&lt;p&gt;Dashboards were the interface between people and business data. &lt;strong&gt;MCP is becoming the interface between agents and business data.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The Model Context Protocol (MCP), released as an open standard by Anthropic, is the emerging connection layer of the AI ecosystem, the USB-C port for agent tooling. Rather than writing bespoke integration code for every model and every tool, you run a reusable MCP server. The agent connects, discovers what's available (metrics, schemas, reports) and calls it. The same server works for Claude, for IDEs like Cursor, and for custom orchestrators.&lt;/p&gt;

&lt;p&gt;Standardizing that interface pays off quickly. In its 2026 Business Trends Report, Google Cloud describes how pulp manufacturer Suzano cut query times by 95% for 50,000 employees by deploying standardized semantic data interfaces.&lt;/p&gt;

&lt;p&gt;But MCP on its own doesn't make data trustworthy. &lt;strong&gt;It solves connectivity, not meaning.&lt;/strong&gt; An MCP server pointed at raw tables is a faster route to the same wrong answers. The quality of what comes back still depends entirely on the governed context sitting behind it, which is exactly where the interesting engineering is.&lt;/p&gt;

&lt;h2&gt;
  
  
  People and agents working from the same definitions
&lt;/h2&gt;

&lt;p&gt;None of this makes dashboards, analysts, or data teams disappear. It changes the collaboration model.&lt;/p&gt;

&lt;p&gt;People define and govern what the business means, what counts as an account, how expansion ARR is calculated, which source system wins when two disagree. Agents perform the continuous investigation humans don't have time for. Both work from the same underlying definitions, and the semantic layer becomes the contract between them.&lt;/p&gt;

&lt;p&gt;This matters more than it sounds, because of something Anthropic observes directly: once agents become the consumers of the data model, the person asking the question often can't validate the answer themselves. The reader of a dashboard could sanity-check a number against the chart next to it. The reader of an agent's paragraph cannot. Governance stops being a compliance concern and becomes the thing that makes the output usable at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  From a modern data stack to an agent-ready data foundation
&lt;/h2&gt;

&lt;p&gt;The usual framing of this problem is vendor sprawl, ingestion here, warehouse there, transformation, semantics, and a custom API on top. That framing misses the point.&lt;/p&gt;

&lt;p&gt;The problem isn't that there are too many vendors. It's that traditional data stacks were designed for &lt;strong&gt;humans consuming dashboards&lt;/strong&gt;, not for &lt;strong&gt;agents consuming context&lt;/strong&gt;. A human reading a report brings their own business knowledge to it. An agent has to be given that knowledge explicitly, in a form it can navigate, which is a requirement almost no stack was built to satisfy.&lt;/p&gt;

&lt;p&gt;An agent-ready data foundation comes together in four moves:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Connect&lt;/strong&gt; your data. Managed ingestion from many sources into a warehouse you control.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Govern&lt;/strong&gt; what it means. Define metrics, entities, and relationships once, version-controlled like code.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Serve&lt;/strong&gt; it to agents. Expose the governed model through a secure MCP server, so Claude, your IDE, and your own agents all read the same definitions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Learn&lt;/strong&gt; continuously. Definitions, lineage, and skills evolve with the business instead of drifting away from it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The practical difference at query time: agents don't guess against raw schemas. They work from the same governed definitions your business already trusts, rather than inventing their own interpretation of the underlying tables, which removes one of the largest sources of analytics hallucination.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;This article was originally published on the &lt;a href="https://www.revos.ai/blog/ai-trends" rel="noopener noreferrer"&gt;RevOS blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>dataengineering</category>
      <category>llm</category>
      <category>mcp</category>
    </item>
    <item>
      <title>Running Hermes Agent on Kubernetes: What Breaks, What Doesn't, and a Production-Safe Setup</title>
      <dc:creator>RevOS</dc:creator>
      <pubDate>Tue, 06 Oct 2026 10:07:05 +0000</pubDate>
      <link>https://dev.to/revos/running-hermes-agent-on-kubernetes-what-breaks-what-doesnt-and-a-production-safe-setup-3bbm</link>
      <guid>https://dev.to/revos/running-hermes-agent-on-kubernetes-what-breaks-what-doesnt-and-a-production-safe-setup-3bbm</guid>
      <description>&lt;p&gt;Hermes Agent is Nous Research's self-improving AI agent. It builds skills from experience, keeps persistent memory across sessions, and connects to Telegram, Discord, Slack, WhatsApp, and Signal out of the box. With 230k+ GitHub stars, plenty of teams now want to run it somewhere more durable than a laptop.&lt;/p&gt;

&lt;p&gt;Kubernetes is the obvious destination and the least documented one. There's no official Helm chart. The container image's init sequence needs root in a way that collides with a standard restricted pod security context. Its state model assumes a single writer. And the reload story that works fine in a terminal has no equivalent your GitOps controller can call.&lt;/p&gt;

&lt;p&gt;None of that is a reason to avoid Hermes on Kubernetes. It's a reason to know the constraints before you write the manifest. Below: what genuinely breaks, what only looks like it breaks, and a reference deployment to start from.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Tested against:&lt;/strong&gt; Hermes Agent &lt;code&gt;v2026.8.27&lt;/code&gt; · official image &lt;code&gt;nousresearch/hermes-agent&lt;/code&gt; · Kubernetes 1.31+ · containerd 2.x. Hermes ships releases every few days. Before you copy anything below, check it against the version you're actually deploying, and pin that version.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Is there an official Helm chart for Hermes Agent?
&lt;/h2&gt;

&lt;p&gt;No. Nous Research's own documentation covers &lt;code&gt;install.sh&lt;/code&gt;, Docker and Docker Compose, and Nix packages. Kubernetes never comes up as a deployment target. That gap is filled entirely by the community, and the three charts that fill it don't agree on much:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;ultraworkers/hermes-agent-helm-chart:&lt;/strong&gt; the most feature-complete option: renders a Deployment, PVC, Secret, Service, Ingress, and an Istio VirtualService, plus an "operator-ready" mode defining a &lt;code&gt;HermesTenant&lt;/code&gt; CRD. It's also the only one that encodes the single-writer rule as a hard constraint.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;jyje/hermes-agent:&lt;/strong&gt; listed on Artifact Hub as a verified publisher, distributed over an OCI registry, with multi-arch images and example ArgoCD manifests. It tracks upstream Hermes releases more closely than the other two.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;duyet/hermes-agent:&lt;/strong&gt; the simplest of the three, splitting persistence into separate data and workspace volumes, with an optional Prometheus &lt;code&gt;ServiceMonitor&lt;/code&gt;. Not a verified publisher, so read the templates before trusting the defaults.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of the three is backed by Nous Research. Read the templates end to end before you apply one, and expect to override the security context.&lt;/p&gt;

&lt;h2&gt;
  
  
  Hermes Agent is stateful: define your persistence boundary first
&lt;/h2&gt;

&lt;p&gt;This is the decision everything else hangs off, so make it before you pick a chart.&lt;/p&gt;

&lt;p&gt;Hermes keeps &lt;strong&gt;all&lt;/strong&gt; of its mutable state (configuration, &lt;code&gt;MEMORY.md&lt;/code&gt;, &lt;code&gt;USER.md&lt;/code&gt;, session history in a local SQLite database, and every learned skill) under &lt;code&gt;HERMES_HOME&lt;/code&gt;. In the official image that's the &lt;code&gt;/opt/data&lt;/code&gt; volume, which the Docker docs call "the single source of truth for all Hermes state."&lt;/p&gt;

&lt;p&gt;So the accurate invariant is not "Hermes can't scale." It's:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Treat each &lt;code&gt;HERMES_HOME&lt;/code&gt; as a single-writer state domain.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;You can run many Hermes instances in one cluster. What you must not do is put two active pods behind the same mutable state and assume Kubernetes has handed you horizontal scaling. Nothing arbitrates concurrent writes to that SQLite database and those Markdown files.&lt;/p&gt;

&lt;p&gt;In practice, for any deployment with persistence enabled:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;replicaCount&lt;/code&gt; stays at &lt;strong&gt;1&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;strategy.type&lt;/code&gt; must be &lt;strong&gt;&lt;code&gt;Recreate&lt;/code&gt;&lt;/strong&gt;, not &lt;code&gt;RollingUpdate&lt;/code&gt;, a rolling update deliberately runs the old and new pod together, which is exactly the two-writer window to avoid.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;ReadWriteOnce&lt;/code&gt; is the sensible guardrail on the PVC. RWX isn't automatically unsafe (the invariant is one &lt;em&gt;active writer&lt;/em&gt;, not one &lt;em&gt;mount&lt;/em&gt;) but RWO enforces it at the storage layer instead of trusting your deployment config.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Need Hermes for more than one team or tenant? One release per tenant, each with its own volume. Any chart that doesn't enforce this is a data-corruption risk waiting for a bad rollout.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the official image fights &lt;code&gt;runAsNonRoot&lt;/code&gt;
&lt;/h2&gt;

&lt;p&gt;The common shorthand, "Hermes has to run as root," is wrong, and the precise version matters when you're arguing with a platform team about a Pod Security Standard exemption.&lt;/p&gt;

&lt;p&gt;The official image uses &lt;strong&gt;s6-overlay&lt;/strong&gt; as its init system. s6-overlay's &lt;code&gt;/init&lt;/code&gt; runs as root so it can &lt;code&gt;chown&lt;/code&gt; the volume on first boot, then drops to the &lt;code&gt;hermes&lt;/code&gt; user via &lt;code&gt;s6-setuidgid&lt;/code&gt; for the main program and all supervised services.&lt;/p&gt;

&lt;p&gt;So the agent process itself does &lt;em&gt;not&lt;/em&gt; run as root. Only the bootstrap does. But that's still enough to break a restricted security context: a pod spec with &lt;code&gt;runAsNonRoot: true&lt;/code&gt; or a non-zero &lt;code&gt;runAsUser&lt;/code&gt; blocks the sequence before the agent ever starts, and you get something close to:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/package/admin/s6-overlay/libexec/preinit: fatal: /run belongs to uid 0 instead of 1000,
has insecure and/or unworkable permissions, and we're lacking the privileges to fix it.
s6-overlay-suexec: fatal: child failed with exit code 100
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;One detail worth getting right, because published examples routinely get it wrong: &lt;strong&gt;the &lt;code&gt;hermes&lt;/code&gt; user is UID 10000, not 1000.&lt;/strong&gt; Set &lt;code&gt;fsGroup: 1000&lt;/code&gt; and the volume ends up owned by the wrong group.&lt;/p&gt;

&lt;p&gt;A reasonable starting security context:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;podSecurityContext&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;runAsUser&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;0&lt;/span&gt;
  &lt;span class="na"&gt;runAsNonRoot&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
  &lt;span class="na"&gt;fsGroup&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;10000&lt;/span&gt;
  &lt;span class="na"&gt;fsGroupChangePolicy&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;OnRootMismatch&lt;/span&gt;
  &lt;span class="na"&gt;seccompProfile&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;RuntimeDefault&lt;/span&gt;
&lt;span class="na"&gt;securityContext&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;allowPrivilegeEscalation&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
  &lt;span class="na"&gt;readOnlyRootFilesystem&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
  &lt;span class="na"&gt;runAsNonRoot&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
  &lt;span class="na"&gt;capabilities&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;drop&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ALL"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
    &lt;span class="na"&gt;add&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;CHOWN"&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;SETUID"&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;SETGID"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That is meaningfully narrower than a privileged pod: every capability is dropped and only the ones the bootstrap needs come back. Treat the exact capability list as a &lt;strong&gt;starting point to verify against your image version&lt;/strong&gt;, not a universal recipe. Start from &lt;code&gt;drop: ["ALL"]&lt;/code&gt;, add back only what your logs prove necessary, and re-test on version bumps.&lt;/p&gt;

&lt;p&gt;If your cluster enforces the &lt;code&gt;restricted&lt;/code&gt; Pod Security Standard, this workload needs a namespace exemption. Forcing the official image to start non-root isn't a setting you've missed, it wasn't built for that.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Hermes can hot-reload, and what it can't
&lt;/h2&gt;

&lt;p&gt;The claim that Hermes has "no hot-reload" is false, and the real limitation is more interesting.&lt;/p&gt;

&lt;p&gt;Hermes documents three reload commands: &lt;code&gt;/reload-mcp&lt;/code&gt; (reload MCP servers from &lt;code&gt;config.yaml&lt;/code&gt;), &lt;code&gt;/reload-skills&lt;/code&gt; (re-scan for newly installed or removed skills), and &lt;code&gt;/reload&lt;/code&gt; (reload &lt;code&gt;.env&lt;/code&gt; variables into the running session).&lt;/p&gt;

&lt;p&gt;The runtime can absolutely pick up new MCP servers and skills without a restart. The gap is the &lt;em&gt;interface&lt;/em&gt;:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Hermes can hot-reload MCP servers and skills interactively, but doesn't expose the same lifecycle through its admin API.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;That's the actual Kubernetes problem:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;ConfigMap updated -&amp;gt; kubelet syncs file into the pod -&amp;gt; no reconciliation hook -&amp;gt; nothing happens
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The file changes on disk. Nothing tells the process. Your options:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Restart the workload.&lt;/strong&gt; &lt;code&gt;kubectl rollout restart deployment/hermes-agent&lt;/code&gt;. Blunt but declarative, and with &lt;code&gt;Recreate&lt;/code&gt; you're accepting a brief outage anyway. Wire a checksum annotation over the ConfigMap into the pod template so the rollout fires automatically on config change, the standard Helm &lt;code&gt;checksum/config&lt;/code&gt; pattern.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Drive the runtime reload path&lt;/strong&gt; from a sidecar or an operator with a channel into the agent. Workable, but you're building the missing hook yourself.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Until an HTTP reload endpoint exists upstream, option 1 with a config checksum is the pragmatic default.&lt;/p&gt;

&lt;h2&gt;
  
  
  Resources, probes, and graceful shutdown
&lt;/h2&gt;

&lt;p&gt;Three things almost every Hermes-on-Kubernetes writeup omits.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Resources.&lt;/strong&gt; Nous Research's Docker documentation recommends a minimum of 1 GB memory and 1 CPU core, with 2-4 GB memory and 2 cores recommended. Browser automation (Playwright/Chromium) is the most memory-hungry feature, so budget above that range if the agent drives a browser. Set a memory &lt;em&gt;limit&lt;/em&gt;, but consider leaving CPU unlimited, agent workloads are bursty, and CPU throttling shows up as mysteriously slow tool calls rather than a clean failure.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Probes.&lt;/strong&gt; The gateway listens on port &lt;strong&gt;8642&lt;/strong&gt;. The Dockerfile ships &lt;strong&gt;no &lt;code&gt;HEALTHCHECK&lt;/code&gt; and no &lt;code&gt;EXPOSE&lt;/code&gt;&lt;/strong&gt; instruction, so you're defining this yourself. A &lt;code&gt;tcpSocket&lt;/code&gt; probe against 8642 is the portable choice. The one that matters most is the &lt;code&gt;startupProbe&lt;/code&gt;: first boot does volume &lt;code&gt;chown&lt;/code&gt; work and profile reconciliation, and a liveness probe with a short threshold will kill the pod mid-bootstrap and loop forever.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Graceful shutdown.&lt;/strong&gt; Hermes is stateful, so SIGTERM handling isn't academic. Give it room with &lt;code&gt;terminationGracePeriodSeconds: 30&lt;/code&gt;, and test what actually happens to in-flight agent runs, SQLite session writes, and open gateway connections when a pod is evicted. Node upgrades and spot reclaims will do this to you eventually, and &lt;code&gt;Recreate&lt;/code&gt; means no second pod is covering the gap.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two security boundaries, not one
&lt;/h2&gt;

&lt;p&gt;Most Kubernetes writeups on agents cover pod security and stop. For an agent that executes code, that's half the problem.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Boundary 1, pod security.&lt;/strong&gt; Root init, capabilities, seccomp, filesystem, service account. Covered above.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Boundary 2, agent execution.&lt;/strong&gt; What the model can actually run, and what it can reach. This is the one that should worry you more, because the pod &lt;em&gt;is&lt;/em&gt; the blast radius.&lt;/p&gt;

&lt;p&gt;Hermes has real defences here:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Credential filtering.&lt;/strong&gt; &lt;code&gt;execute_code&lt;/code&gt; blocks environment variables whose names contain &lt;code&gt;KEY&lt;/code&gt;, &lt;code&gt;TOKEN&lt;/code&gt;, &lt;code&gt;SECRET&lt;/code&gt;, &lt;code&gt;PASSWORD&lt;/code&gt;, &lt;code&gt;CREDENTIAL&lt;/code&gt;, &lt;code&gt;PASSWD&lt;/code&gt;, or &lt;code&gt;AUTH&lt;/code&gt;. MCP stdio subprocesses receive only a short safe list of variables.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The bypass is explicit.&lt;/strong&gt; Variables declared by a skill or listed in &lt;code&gt;env_passthrough&lt;/code&gt; skip those filters. That's the mechanism to audit.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Approval checks are skipped in container backends.&lt;/strong&gt; Hermes skips dangerous-command approval in the &lt;code&gt;docker&lt;/code&gt;, &lt;code&gt;singularity&lt;/code&gt;, &lt;code&gt;modal&lt;/code&gt;, &lt;code&gt;daytona&lt;/code&gt;, and &lt;code&gt;vercel_sandbox&lt;/code&gt; backends, on the reasoning that "the container itself is the security boundary." In a Kubernetes pod that assumption is load-bearing: whatever your pod can reach, prompt-injected code can reach.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;SSRF protection exists, and is disableable.&lt;/strong&gt; Web tools block RFC 1918 ranges and loopback by default. In a cluster, RFC 1918 &lt;em&gt;is&lt;/em&gt; your service mesh, your databases, and the kubelet.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Which leads to the control most often missing: &lt;strong&gt;default-deny egress.&lt;/strong&gt; An agent that browses the web and calls tools is not a normal web app, and "what can this pod reach?" is a more consequential question than which Linux capabilities it holds. Start from deny-all and allow only what's needed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;apiVersion&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;networking.k8s.io/v1&lt;/span&gt;
&lt;span class="na"&gt;kind&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;NetworkPolicy&lt;/span&gt;
&lt;span class="na"&gt;metadata&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent-egress&lt;/span&gt;
&lt;span class="na"&gt;spec&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;podSelector&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;matchLabels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;app.kubernetes.io/name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
  &lt;span class="na"&gt;policyTypes&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Egress"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
  &lt;span class="na"&gt;egress&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="c1"&gt;# DNS&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;to&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;namespaceSelector&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;matchLabels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;kubernetes.io/metadata.name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;kube-system&lt;/span&gt;
          &lt;span class="na"&gt;podSelector&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;matchLabels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;k8s-app&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;kube-dns&lt;/span&gt;
      &lt;span class="na"&gt;ports&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;protocol&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;UDP&lt;/span&gt;
          &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;53&lt;/span&gt;
    &lt;span class="c1"&gt;# HTTPS to the internet, minus internal ranges&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;to&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;ipBlock&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;cidr&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;0.0.0.0/0&lt;/span&gt;
            &lt;span class="na"&gt;except&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;10.0.0.0/8&lt;/span&gt;
              &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;172.16.0.0/12&lt;/span&gt;
              &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;192.168.0.0/16&lt;/span&gt;
              &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;169.254.169.254/32&lt;/span&gt;   &lt;span class="c1"&gt;# cloud instance metadata&lt;/span&gt;
      &lt;span class="na"&gt;ports&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;protocol&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;TCP&lt;/span&gt;
          &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;443&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Blocking &lt;code&gt;169.254.169.254&lt;/code&gt; matters especially: on a node without IMDSv2 enforced, an agent that can reach instance metadata can often reach the node's IAM role.&lt;/p&gt;

&lt;p&gt;On credentials: because the agent has terminal access, anything in its environment is potentially readable by it. On EKS, use IRSA or EKS Pod Identity rather than static access keys in a Secret. Elsewhere, External Secrets Operator, Vault, or Sealed Secrets all keep plaintext keys out of Git. And scope the IAM role tightly: the agent's permissions are the agent's capabilities.&lt;/p&gt;

&lt;h2&gt;
  
  
  A minimal deployment that actually works
&lt;/h2&gt;

&lt;p&gt;Pinned, single-writer, probed, and resource-bounded. Adjust the storage class and image tag, and read it before you apply it.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;apiVersion&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;v1&lt;/span&gt;
&lt;span class="na"&gt;kind&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;PersistentVolumeClaim&lt;/span&gt;
&lt;span class="na"&gt;metadata&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent-data&lt;/span&gt;
&lt;span class="na"&gt;spec&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;accessModes&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ReadWriteOnce"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
  &lt;span class="na"&gt;resources&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;requests&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;storage&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;20Gi&lt;/span&gt;
&lt;span class="nn"&gt;---&lt;/span&gt;
&lt;span class="na"&gt;apiVersion&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;apps/v1&lt;/span&gt;
&lt;span class="na"&gt;kind&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Deployment&lt;/span&gt;
&lt;span class="na"&gt;metadata&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
  &lt;span class="na"&gt;labels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;app.kubernetes.io/name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
&lt;span class="na"&gt;spec&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;replicas&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;1&lt;/span&gt;
  &lt;span class="na"&gt;strategy&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Recreate&lt;/span&gt;          &lt;span class="c1"&gt;# never two writers on one HERMES_HOME&lt;/span&gt;
  &lt;span class="na"&gt;selector&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;matchLabels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;app.kubernetes.io/name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
  &lt;span class="na"&gt;template&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;metadata&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;labels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;app.kubernetes.io/name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
      &lt;span class="na"&gt;annotations&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;checksum/config&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;REPLACE_WITH_CONFIGMAP_CHECKSUM"&lt;/span&gt;
    &lt;span class="na"&gt;spec&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;serviceAccountName&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
      &lt;span class="na"&gt;terminationGracePeriodSeconds&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;30&lt;/span&gt;
      &lt;span class="na"&gt;securityContext&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;runAsUser&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;0&lt;/span&gt;
        &lt;span class="na"&gt;runAsNonRoot&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
        &lt;span class="na"&gt;fsGroup&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;10000&lt;/span&gt;
        &lt;span class="na"&gt;fsGroupChangePolicy&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;OnRootMismatch&lt;/span&gt;
        &lt;span class="na"&gt;seccompProfile&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;RuntimeDefault&lt;/span&gt;
      &lt;span class="na"&gt;containers&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
          &lt;span class="na"&gt;image&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;nousresearch/hermes-agent:v2026.8.27&lt;/span&gt;   &lt;span class="c1"&gt;# pin it; never :latest&lt;/span&gt;
          &lt;span class="na"&gt;args&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;gateway"&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;run"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
          &lt;span class="na"&gt;ports&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;gateway&lt;/span&gt;
              &lt;span class="na"&gt;containerPort&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;8642&lt;/span&gt;
          &lt;span class="na"&gt;envFrom&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;secretRef&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
                &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent-secrets&lt;/span&gt;
          &lt;span class="na"&gt;securityContext&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;allowPrivilegeEscalation&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
            &lt;span class="na"&gt;readOnlyRootFilesystem&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
            &lt;span class="na"&gt;runAsNonRoot&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
            &lt;span class="na"&gt;capabilities&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;drop&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ALL"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
              &lt;span class="na"&gt;add&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;CHOWN"&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;SETUID"&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;SETGID"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
          &lt;span class="na"&gt;resources&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;requests&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;cpu&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;500m"&lt;/span&gt;
              &lt;span class="na"&gt;memory&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;2Gi&lt;/span&gt;
            &lt;span class="na"&gt;limits&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;memory&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;4Gi&lt;/span&gt;
          &lt;span class="na"&gt;startupProbe&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;tcpSocket&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;gateway&lt;/span&gt;
            &lt;span class="na"&gt;periodSeconds&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;5&lt;/span&gt;
            &lt;span class="na"&gt;failureThreshold&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;60&lt;/span&gt;
          &lt;span class="na"&gt;readinessProbe&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;tcpSocket&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;gateway&lt;/span&gt;
            &lt;span class="na"&gt;periodSeconds&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;10&lt;/span&gt;
          &lt;span class="na"&gt;livenessProbe&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;tcpSocket&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;gateway&lt;/span&gt;
            &lt;span class="na"&gt;periodSeconds&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;20&lt;/span&gt;
            &lt;span class="na"&gt;failureThreshold&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;3&lt;/span&gt;
          &lt;span class="na"&gt;volumeMounts&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;data&lt;/span&gt;
              &lt;span class="na"&gt;mountPath&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;/opt/data&lt;/span&gt;
      &lt;span class="na"&gt;volumes&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;data&lt;/span&gt;
          &lt;span class="na"&gt;persistentVolumeClaim&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;claimName&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent-data&lt;/span&gt;
&lt;span class="nn"&gt;---&lt;/span&gt;
&lt;span class="na"&gt;apiVersion&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;v1&lt;/span&gt;
&lt;span class="na"&gt;kind&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Service&lt;/span&gt;
&lt;span class="na"&gt;metadata&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
&lt;span class="na"&gt;spec&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;selector&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;app.kubernetes.io/name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hermes-agent&lt;/span&gt;
  &lt;span class="na"&gt;ports&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;gateway&lt;/span&gt;
      &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;8642&lt;/span&gt;
      &lt;span class="na"&gt;targetPort&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;gateway&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Pair it with the NetworkPolicy above, a Secret (ideally rendered by External Secrets or Sealed Secrets rather than committed), and a ConfigMap for &lt;code&gt;config.yaml&lt;/code&gt; if you're managing MCP servers declaratively.&lt;/p&gt;

&lt;h2&gt;
  
  
  Production checklist
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Image tag pinned to a specific release, never &lt;code&gt;:latest&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;replicas: 1&lt;/code&gt; and &lt;code&gt;strategy.type: Recreate&lt;/code&gt;, with one &lt;code&gt;HERMES_HOME&lt;/code&gt; per instance&lt;/li&gt;
&lt;li&gt;PVC is &lt;code&gt;ReadWriteOnce&lt;/code&gt;, and the storage class supports that access mode&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;fsGroup: 10000&lt;/code&gt; matches the image's &lt;code&gt;hermes&lt;/code&gt; user&lt;/li&gt;
&lt;li&gt;Capabilities start from &lt;code&gt;drop: ["ALL"]&lt;/code&gt;, with additions verified against your image version&lt;/li&gt;
&lt;li&gt;Namespace exemption in place if you enforce the &lt;code&gt;restricted&lt;/code&gt; Pod Security Standard&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;startupProbe&lt;/code&gt; generous enough to survive first-boot volume work&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;terminationGracePeriodSeconds&lt;/code&gt; set, and eviction behaviour tested against in-flight runs&lt;/li&gt;
&lt;li&gt;Memory limit sized for browser automation if skills use it&lt;/li&gt;
&lt;li&gt;Default-deny egress NetworkPolicy, with instance metadata (&lt;code&gt;169.254.169.254&lt;/code&gt;) blocked&lt;/li&gt;
&lt;li&gt;No static cloud credentials in Secrets, use IRSA / Pod Identity / Vault / External Secrets&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;env_passthrough&lt;/code&gt; and skill-declared variables audited, they bypass credential filtering&lt;/li&gt;
&lt;li&gt;Config changes trigger a rollout (checksum annotation) or a deliberate reload path&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where this connects to governed data
&lt;/h2&gt;

&lt;p&gt;Everything above keeps Hermes Agent alive and contained. None of it says whether the answers it produces are correct, that depends on what it's allowed to read and how well-defined that data is. The same discipline that makes an agent's infrastructure trustworthy (scoped permissions, no unmanaged state, changes that go through review) reappears in agentic data engineering, where an agent's output earns trust through layered checks rather than raw model capability. Point an agent like this at real business data instead of chat platforms and a semantic layer is what stops it guessing at what "revenue" or "active customer" means.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;This article was originally published on the &lt;a href="https://www.revos.ai/blog/hermes-agent-kubernetes" rel="noopener noreferrer"&gt;RevOS blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>kubernetes</category>
      <category>devops</category>
      <category>ai</category>
      <category>agents</category>
    </item>
  </channel>
</rss>
