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.
| Meaning | What it covers | Example |
|---|---|---|
| Infrastructure for agents | Compute, orchestration, model serving, memory, tool access, security and observability that run agents in production | A 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 agents | Cloud systems built so agents can provision, deploy, monitor and fix them through governed interfaces | An 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.
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.
| Component | What it does | What goes wrong without it |
|---|---|---|
| Runtime and orchestration | Holds the goal, plans steps, keeps state, retries failed calls | The agent loses its place after one error and repeats or abandons work |
| Model serving | Routes calls to models, with fallbacks and cost tracking | One provider outage or price change stops every agent |
| Tools and APIs | Gives the agent typed actions with clear inputs | The agent guesses endpoints and parameters, and calls fail |
| Memory and retrieval | Stores session history and fetches relevant documents | The agent forgets earlier steps or answers from stale data |
| Identity, permissions and policy | Defines what each agent may touch and which actions need approval | An agent with broad credentials can delete or expose data |
| Observability and audit | Records decisions, tool calls, outputs, cost and failures | Nobody 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.
| Platform | Where the agent runs | How your app triggers it |
|---|---|---|
| Cursor Cloud Agents | Cursor's cloud | REST API (POST /v1/agents, public beta) |
| GitHub Copilot cloud agent | GitHub Actions or a cloud sandbox | REST API, or a GitHub issue or event |
| Claude Code | GitHub Actions runners, or your own process | Claude Agent SDK call, or any GitHub event |
| OpenAI Codex cloud | OpenAI's cloud | No documented app API; start it from ChatGPT or the Codex CLI |
| Devin | Devin's cloud | REST 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 pipelines | Infrastructure as code | Agentic infrastructure | |
|---|---|---|---|
| Input | A trigger | A file a person edits | A goal in plain language |
| Who writes the change | A person, ahead of time | A person, per change | The agent, per change |
| New situations | Fail or need a new script | Need a new edit | The agent drafts a new plan |
| Review point | Code review of the script | Plan or preview before apply | Plan 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.
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:
- Runs a remote MCP server with OAuth and supports your agent by name.
- Turns every change into a reviewable plan and refuses ones that would damage data.
- Keeps credentials out of the agent's hands and records which agent shipped what.
- Documents what rollback does to data.
- Lets you export everything and host the front end elsewhere.
- Publishes unit prices and supports spend limits with alerts.
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.