What does a coding agent need from a platform?

A coding agent needs a platform that already holds what an enterprise app stands on, so the agent writes only the part that is new. They are data, a data model, sign in and permissions, tests on real records, deployment, an audit trail and docs the agent can read.

A platform is not the agent’s harness. The harness is the program that runs the model: its terminal, its sandbox and its permission prompts. It decides what the agent may do while it writes. The platform decides what the app may do once people use it. Nor is it a repository, which holds the code and none of the records the code reads.

Coding agents now read a code base, edit files, run commands and open pull requests, in a terminal, an IDE or a cloud environment. Writing an app’s screens and endpoints is the part they do well.

What an agent writes from scratch has not been reviewed the way a platform was. Veracode tested code from more than 100 language models and reported in July 2025 that 45% of the samples failed security tests. Newer models wrote code that worked more often, but not code that was more secure. In a user study by Perry and colleagues, people with an AI assistant wrote less secure code than people without one. They were also more likely to believe it was secure.

So the work moved. An app the agent builds from an empty folder needs its own connectors, login, access checks and server. Each is one more thing to review. Our paper The app is the easy part follows that into documented incidents.

• Data, connected and current. Records from the systems that own them, synced as they change, deletes included. An agent that copies an export into its app has a snapshot, not data.
• A data model. Types and the links between them, as files the agent reads before it writes a query. Without one, each app invents its own, and ten apps disagree about what a supplier is.
• Sign in and permissions. The company’s single sign on, and access checked by the platform on every record the app reads. Code checks access only where it remembers to. Anthropic’s advice for Claude Code says the same about the agent’s own rules: “If something has to happen every time, make it a hook, a deny rule, or a managed setting.” For an app, that place is below the code.
• A way to test on real records. A build against the real schema, and tests that run on the records the app will read. The same guide names the risk: “Claude stops when the work looks done.” A check that comes back pass or fail is what tells it otherwise.
• Deployment. Somewhere to run that is already inside your network, patched and backed up.
• An audit trail. Who asked for a change, who approved it, and what people did with the app afterwards.
• Documentation the agent can read. The platform’s API and house conventions, as files that match the version you run. AGENTS.md calls its own file “a dedicated, predictable place to provide the context and instructions to help AI coding agents work on your project.” A platform needs the same for its surface.

• A copy per app. Each app loads its own extract of the data. The extracts drift apart and outlive the records they came from.
• A forgotten access check. One endpoint without it is enough to show a record to someone who should not see it.
• Tests on invented data. The app passes on fixtures the agent wrote and fails on the first real part number.
• A package that does not exist. Spracklen and colleagues generated 576,000 code samples with 16 models. On average, at least 5.2% of the packages commercial models named did not exist, and 21.7% for open source models. An attacker can publish a package under such a name.
• The agent’s rights, not the user’s. An agent given a service account builds an app that reads as that account, for everyone.
• Changes that apply themselves. A deploy nobody read leaves an auditor nothing to look at.
• An API from memory. The agent writes against the version it was trained on, not the one you run.

Ask these of any platform an agent builds on, ours included:

• Which records can the app read on its first day, and how do they stay current?
• Can the agent read the data model as files before it writes?
• Who checks access on each read: the platform, or the code the agent wrote?
• Does the agent work with its own rights or the user’s, and can it approve its own change?
• Can the agent build and test against real records without touching what runs?
• Where does the app run, and who patches it?
• What record does a change leave: who asked, who approved, what changed?
• Does the documentation the agent reads match the version you run?

Not every app needs a platform. A coding agent on its own is the right tool when the application already has its data, sign in and hosting. It is enough for a tool that reads one system or none, and for a prototype nobody runs on production records. Our comparison pages for coding agents say so for each agent.

Curiosity Studio is the platform, and curio is how a coding agent reaches it. curio is a command line, so Claude Code, OpenAI Codex, GitHub Copilot or any agent that runs shell commands can work through it. curio skills install puts one skill where the agent looks for skills. It lists Sudo’s skills and the commands that read them, so the agent follows the conventions of the version you run.

The agent works in a session of Sudo’s sandbox. It reads the schema as files under /workspace, and the API reference under /sdk and /docs. It writes its change there, and build compiles it against the workspace. commit stages it, and a person approves the diff on Sudo’s review screen. Signed in without the approve right, the default, curio cannot approve anything itself. The coding agents guide has the setup for each agent.

The rest is already there. Records from more than 70 systems sit in one typed graph. Access is synced from the source systems and checked per record. Sign in runs through your SSO or SAML provider, and the audit log records the actions an administrator turns on. Studio runs on your servers or in your private cloud, and commits every configuration change to git.

What the agent adds is a small piece of code on top. The paper Count the seams first sets that against a stack you assemble yourself.