Cursor Agent SDK Released: Agents as Code, Evaluation Decides Everything

Cursor recently released the Agent SDK, transforming AI agents from black-box tools into versionable, testable units of code. At the same time, OpenAI's Terra model has entered the API, with prices halved and coding benchmark scores doubled. But behind both updates, the same principle emerges: evaluations are more trustworthy than launch charts.

Agent SDK: Put Agents in the Repo, Manage Them Like Code

According to a YouTube tech channel's analysis, Cursor opened up the Agent SDK on October 26. The core idea is straightforward: you define an agent as a folder containing Markdown-format prompts and TypeScript tools, then review, test, and version-control it just like any other code.

This "agents as code" paradigm solves the pain points that previously made AI agents hard to collaborate on and reproduce. Team members can review prompt changes, trace behavioral differences through version history, and run tests in CI pipelines. Deployment offers flexibility—you can run on Cursor's hosted infrastructure or fully self-host, meeting enterprise requirements for data sovereignty.

The SDK also includes built-in evaluation mechanisms. According to Cursor, this evaluation framework uses the same toolchain as its internal security review agents. This means every modification to an agent can be quantitatively measured rather than judged by feel. However, the announcement did not list pricing information.

Agent as Code is an engineering practice that manages the complete definition of an AI agent (including prompts, tool invocation logic, runtime configuration, etc.) as source code. Its core is treating agents as first-class citizens in software projects, so that existing mature toolchains—version control, code review, continuous integration—can be used to ensure agent quality and maintainability. Compared with traditional prompt engineering, agents as code emphasizes reproducibility and collaboration: team members can review prompt changes just like ordinary code, trace behavioral differences through version history, and automatically run tests in CI pipelines. This paradigm shifts agent development from personalized manual tuning to systematic team collaboration, laying the foundation for large-scale deployment of agents in production environments.

Terra Model: Half the Price, Double the Benchmark Score

On the same timeline, OpenAI's Terra model officially entered the API. According to OpenAI, the standard price is half that of the previous Terra model, and on a command-line coding benchmark, the score is more than double the previous version.

For high-intensity coding tasks, OpenAI still recommends its heavier models. This suggests Terra is positioned more toward cost-effectiveness and throughput rather than maximum capability. For everyday agent tasks, lower cost and faster response may be more valuable than peak performance.

It's worth noting that both releases come from the same video source and were not cross-verified by independent sources. Regarding the specific benchmark score improvements for Terra, currently only OpenAI's unilateral statement is available.

Command-line Coding Benchmark refers to a category of evaluation sets specifically designed to assess an AI model's ability to complete coding tasks in a command-line environment. These benchmarks typically simulate real development scenarios, requiring the model to generate, modify, or debug code based on natural language instructions, and execute it via scripts in a terminal to verify results. Common benchmarks include HumanEval and MBPP, but command-line coding benchmarks focus more on end-to-end task completion, including file operations, dependency management, and error handling. Since the command-line environment closely mirrors actual engineering practice, scores on this benchmark can reasonably reflect a model's practicality in automated coding tasks, though it should be noted that these are still general-scenario tests and may not fully represent performance in a specific business codebase.

Evaluation First: Run Your Own Tests Before Migrating

The most actionable advice from the video is: don't blindly trust launch charts. Before migrating your agents to the Cursor SDK or the Terra model, you should sample 10 tasks from your own evaluation set, run them on both your current setup and the new setup, then compare pass rates, costs, and runtime.

The underlying logic is: vendor benchmarks target general scenarios, while your agents face your codebase, your toolchain, and your business boundaries. A model that doubles its score on a command-line coding benchmark may not improve the pass rate of your specific agent tasks; an SDK with built-in evaluation only becomes meaningful when you feed it your own data.

In practice, these 10 tasks should cover the types of requests your agent handles most frequently. Record baseline data before switching to avoid vague judgments like "it feels faster." The cost dimension is equally important—halving the unit price doesn't mean halving total cost, because agent tasks may involve multiple rounds of calls and tool execution.

Self-hosting refers to deploying a software system on an organization's own infrastructure rather than relying on third-party cloud services. In the context of AI agents, self-hosting means the agent's definition, runtime environment, and data are entirely controlled by the enterprise, meeting requirements for data sovereignty, security compliance, and customization. For enterprises handling sensitive code or business data, self-hosting avoids data leakage risks and allows flexible configuration according to internal network policies. The Cursor Agent SDK offers both hosted and self-hosted options precisely to accommodate teams of different sizes: startups may prefer hosted deployment to reduce operational costs, while large enterprises may choose self-hosting to ensure compliance.

The Signal of Agent Engineering

Looking at both releases together, a clear trend line emerges: AI agents are moving from demos to engineering assets. Version-controllable definitions, self-hostable deployment, and built-in evaluation tools all point in the same direction—agents need to be tested, reviewed, and iterated like software.

For developers, this means the learning curve extends from "writing prompts" to "managing the agent lifecycle." The ability to design evaluation sets may matter more than prompt engineering tricks in determining how agents perform in actual production. After all, you can look at launch charts, but the final decision should be based on your own evaluation results.