What is agentic infrastructure?

By Codata IO team Last updated 5 Nov 2026 9 min read
Animation: the two meanings of agentic infrastructure appear, with "operated by agents" highlighted. A coding agent sends "Ship this app" over MCP to a card titled The cloud for agentic coding. Three groups tick on in order: Govern (plan reviewed, self-tests passed, restore ready), Run (database and REST APIs, file storage and jobs, AI gateway) and Go live (free Codata address, sign-in and email, your own domain). The app is marked live.
TL;DR

Agentic infrastructure is the stack that lets AI agents do multi-step work: plan, call tools, read data and change live systems. The term covers infrastructure that runs agents and infrastructure that agents operate. Both need tools, memory, identity, policy and an audit trail. The goal is governed action, not unrestricted autonomy.

A chatbot answers a prompt. An agent takes a goal, breaks it into steps, calls APIs, checks the results and tries again. That loop needs more than a model behind it.

Codata IO is the cloud for agentic coding: where agents deploy safely and apps run and go live.

Agentic infrastructure, defined

Agentic infrastructure is the technical foundation that lets AI agents reason through a task, use tools, access data and take actions in other systems. Lenovo calls it the foundation used to build, run, connect, monitor and manage agentic AI systems.

The term is used in two ways. Vendors often mean one and imply the other.

MeaningWhat it coversExample
Infrastructure for agentsCompute, orchestration, model serving, memory, tool access, security and observability that run agents in productionA support agent pulls a customer record, calls a refund API, checks the refund policy and escalates to a person when the amount is too high
Infrastructure operated by agentsCloud systems built so agents can provision, deploy, monitor and fix them through governed interfacesAn agent proposes a configuration change, checks it against policy and opens a pull request for a person to approve

Sources: Mirantis, Pulumi, checked 4 Nov 2026.

What is MCP in agentic AI?

MCP, the Model Context Protocol, is an open-source standard for connecting AI applications to external systems. In agentic AI, it is the common way an agent discovers and calls tools, instead of a custom integration per service.

The MCP architecture docs define three participants. The host is the AI application, such as Claude Code. It opens one client per connection, and each server exposes context and actions.

A server offers three primitives. Tools are functions the agent can call, such as a database query. Resources are data the agent can read, such as a schema. Prompts are reusable templates.

Messages use JSON-RPC 2.0. A client lists tools with tools/list, then runs one with tools/call and gets structured content back.

Stdio connects local processes on one machine. Streamable HTTP serves remote clients, and MCP recommends OAuth for its tokens.

Animation on a dark background: five steps light up in order. Request: you ask the agent to add a priority to each task, and the agent sends it over MCP. Plan: a diff adds a priority field with low, medium and high. Review: nothing is live until you press Deploy. Deploy: the backend moves from v1 to v2. Check: four task endpoints are ticked one by one against the live API.
How an agent changes a backend over MCP: request, plan, review, deploy, check. Illustration, not a real screenshot.

Codata's MCP connector installs from one prompt and signs in with OAuth, so there are no tokens to paste. It works with Claude, Cursor, Copilot, Codex, Lovable and Replit. For a hands-on version, see how to give your AI agent a database through MCP.

Core components of agentic infrastructure

A production agent depends on six components. Mirantis notes that the limit in these deployments is rarely the model itself.

ComponentWhat it doesWhat goes wrong without it
Runtime and orchestrationHolds the goal, plans steps, keeps state, retries failed callsThe agent loses its place after one error and repeats or abandons work
Model servingRoutes calls to models, with fallbacks and cost trackingOne provider outage or price change stops every agent
Tools and APIsGives the agent typed actions with clear inputsThe agent guesses endpoints and parameters, and calls fail
Memory and retrievalStores session history and fetches relevant documentsThe agent forgets earlier steps or answers from stale data
Identity, permissions and policyDefines what each agent may touch and which actions need approvalAn agent with broad credentials can delete or expose data
Observability and auditRecords decisions, tool calls, outputs, cost and failuresNobody can explain what the agent did or why it cost so much

Sources: Mirantis, Lenovo, checked 4 Nov 2026.

Take one task: "find out why checkout is failing". Tools pull logs and recent deploys, and the model ties the errors to a deploy from an hour ago. Policy lets the agent propose a rollback; a person approves it, and the audit log records each step.

For the products that fill each slot, see the AI agent infrastructure stack.

Platforms that run background coding agents in the cloud

Cursor, GitHub Copilot, Claude Code, Devin and OpenAI Codex all run coding agents in the cloud. Most can be started from your own app over an API.

Background agents ship while nobody is watching. So the real question is not where they run, but what they are allowed to change.

PlatformWhere the agent runsHow your app triggers it
Cursor Cloud AgentsCursor's cloudREST API (POST /v1/agents, public beta)
GitHub Copilot cloud agentGitHub Actions or a cloud sandboxREST API, or a GitHub issue or event
Claude CodeGitHub Actions runners, or your own processClaude Agent SDK call, or any GitHub event
OpenAI Codex cloudOpenAI's cloudNo documented app API; start it from ChatGPT or the Codex CLI
DevinDevin's cloudREST API (create a session)

Sources: Cursor Cloud Agents API, GitHub Copilot sessions, Claude Code GitHub Actions, Codex cloud, Devin API, checked 5 Nov 2026.

Those platforms are the "infrastructure for agents" meaning: they host the runtime, the sandbox and the repository checkout. What the agent changes in production is the other half, and that is where Codata IO, the cloud for agentic coding, comes in.

Connected to Codata over MCP, a background agent's backend changes come back as explained plans that wait for your approval in your coding agent. The agent cannot pass a plan through on its own.

Unsafe migrations are refused, every endpoint is re-tested after each deploy, and each version is tagged with the agent that shipped it. Restore takes about 45 seconds, but data in removed fields does not come back.

Agentic infrastructure vs traditional automation and IaC

Scripts, pipelines and runbooks execute procedures someone wrote in advance, as Pulumi puts it. Infrastructure as code (IaC) declares a desired state, but a person still writes and updates that declaration.

Scripts and pipelinesInfrastructure as codeAgentic infrastructure
InputA triggerA file a person editsA goal in plain language
Who writes the changeA person, ahead of timeA person, per changeThe agent, per change
New situationsFail or need a new scriptNeed a new editThe agent drafts a new plan
Review pointCode review of the scriptPlan or preview before applyPlan or diff before apply

How agents are kept from making unsafe changes

Agents are kept safe by limiting what they can do directly, not by trusting the model. The working rule is that agents propose or execute through governed interfaces, while people set policy and approve high-risk changes.

Five controls do most of the work:

  • Plan before apply. Every change becomes a diff that can be reviewed and rejected.
  • Policy at the boundary. Rules run on every change, whoever proposed it. Qovery describes governance enforced at the interface agents use.
  • Least privilege. In Pulumi's model, an agent acts only within the permissions of the person who started the task.
  • Audit. Each action is logged with who started it and what changed.
  • Rollback. A bad change can be reversed, with its effect on data stated up front.

What is a schema migration?

A schema migration is a versioned change to a database's structure: tables, columns, types, indexes or constraints. Additive changes, such as a new table or a nullable column, are backward compatible.

Destructive changes are the risky case: dropping or renaming a column, narrowing a type, or adding a required field with no default. They break code that still expects the old shape, or delete data outright.

The safe pattern is expand and contract, which martinfowler.com calls parallel change. Add the new shape beside the old one, backfill the data and move every reader and writer. Remove the old shape in a later release. An agent that jumps straight to the contract step is the failure to guard against.

Where Codata IO fits: the cloud for agentic coding

Codata IO is the cloud for agentic coding: where agents deploy safely and apps run and go live. It is the "operated by agents" meaning, applied to whole web apps.

It replaces the stack you would otherwise assemble: usually Vercel or Netlify, Supabase, SendGrid and Auth0.

Govern

  • Plan review. The change arrives as a diff of every table, endpoint and relationship. Nothing deploys until you approve it, in your coding agent or with Deploy on "Review changes v1 → v2".
  • Hash-pinned plans. Apply is rejected if the backend changed after the plan was made.
  • Guardrails. Every schema change is checked against existing data. Codata blocks unsafe migrations, such as one that would have exposed or hidden every row, and explains safe options.
  • Self-tests. Every endpoint gets create, read, update and delete checks against the live API: "All 51 endpoint checks passed". This covers the backend, not your frontend code.
  • Who shipped what. Version history tags agent deploys with their source, such as "Claude Code". Manual dashboard changes are not tagged yet.
Animation on a dark background: a version timeline grows from v1, a tasks table, to v2, which adds a displayName field. A rollback to v1 is added as v3, marked from v1, while v1 and v2 stay in the history. A note appears: rollback restores the structure, not deleted data, so export first.
Restore adds a version and keeps the history. Illustration, not a real screenshot.

Restore to any version takes about 45 seconds, keeps full history, costs no credits and re-runs the endpoint checks. Data in removed fields does not come back, and the restore dialog does not warn about that yet, so export first.

The database enforces row ownership, with private, shared or public data. "View as user" shows what any real user can do, and why.

Run

The agent gets a database with REST APIs, file storage and scheduled jobs. The AI gateway gives your app one key for OpenAI and Anthropic models. In-app AI agents add a model fallback chain, a budget limit per agent and PII guardrails, on paid plans only.

Go live

Apps go live on a free Codata address, with hosting managed for you on Vercel's edge. You can buy or connect your own domain in the console. Sign-in covers email, Google and guest accounts.

Email sends from your own domain: auth, transactional and batch, with deliverability checks and an activity log. That is email without a SendGrid or Resend account.

One bill and a way out

One meter covers hosting, data, sign-in, email and AI. What your agent does over MCP costs nothing, unit prices are shown upfront, and spend limits send alerts at 75% and 90%. Export gives you all data and users in one archive, with bcrypt password hashes, so accounts move without a reset.

Enterprise backend for vibe-coded apps: what Codata covers

An enterprise reviewer asks two things: who can change production, and what happens when it fails. Codata answers the first well today and the second only in part.

Change control is covered by the Govern controls above, plus write-only secrets, expiring keys and signed webhooks. Codata does not yet offer SSO, MFA, enforced roles, a published SLA, uptime, backup or region commitments, or a compliance certification.

How to choose an agentic cloud platform

Judge it by what happens when the agent is wrong, not by how fast it ships. Check that it:

  1. Runs a remote MCP server with OAuth and supports your agent by name.
  2. Turns every change into a reviewable plan and refuses ones that would damage data.
  3. Keeps credentials out of the agent's hands and records which agent shipped what.
  4. Documents what rollback does to data.
  5. Lets you export everything and host the front end elsewhere.
  6. Publishes unit prices and supports spend limits with alerts.
See the plan before your agent ships it.Connect Claude Code, Codex or Cursor in one prompt. Every backend change arrives as a diff, and nothing deploys until you approve it.
Connect your agent

FAQ

Is agentic infrastructure the same as AI infrastructure?

No. AI infrastructure usually means GPUs, model training and inference servers. Agentic infrastructure sits on top: tool access, identity, policy and audit for agents that act. GPUs don't make an agent safe in production. Codata IO adds that layer for web apps: every backend change your agent makes is a plan you approve.

How is agentic infrastructure different from infrastructure as code?

Infrastructure as code declares a desired state that a person writes. In agentic infrastructure, the agent writes each change from a goal, so the review point matters more. On Codata IO, each agent change arrives as a hash-pinned plan with a diff, is checked against existing data and waits for your approval.

Can my AI agent deploy to production safely?

Yes, if every change is reviewable, checked and reversible. On Codata IO, every backend change comes back to your agent as a plan, and nothing deploys until you approve it. Endpoints are re-tested after each deploy, and restore takes under a minute. Data in removed fields does not come back.

What is MCP in agentic AI?

MCP, the Model Context Protocol, is an open standard for connecting AI applications to external systems. Servers expose tools, resources and prompts over JSON-RPC 2.0, locally or remotely with OAuth. Codata IO's MCP connector installs from one prompt, so Claude Code, Cursor or Codex can build the backend and take the app live.

A cloud your coding agent can deploy to, safely.

Codata IO is the cloud for agentic coding: where agents deploy safely and apps run and go live. Every backend change your agent makes is planned, versioned and reversible.

Start free
Related reading
Blog MCP database: how to give your AI agent a real database