Now available in beta, Neptune is a conversational AI agent designed to act like an AI platform engineer, handling the provisioning, wiring, and configuration of the cloud services needed to run a containerized app. Neptune is both language and cloud-agnostic, with support for AWS, GCP, and Azure.
Neptune aims to bridge the gap between a deployment agent and a true AI platform engineer by understanding code and automatically planning and provisioning the infrastructure required to run it. It supports Cursor, Claude Code, Windsurf, and other AI coding assistants that implement the Model Context Protocol (MCP).
Neptune builds on the experience the company gathered with Shuttle, an open-source tool for building and deploying Rust applications with automatically provisioned infrastructure. Neptune extends this approach by becoming language-agnostic and integrating with AI coding assistants to gather the necessary context about a project and its infrastructure requirements. Neptune emphasizes the importance of this connection:
When infrastructure lives close to the code, it gives both developers and AI a shared context – and that shared understanding unlocks new possibilities. Agents can reason about an entire system, not just snippets of code, and start doing meaningful work for builders instead of generating isolated outputs.
By installing Neptune MCP, AI assistants gain access to a set of tools that allow them to authenticate with Neptune, provision cloud resource, build and deploy applications, and monitor deployment status or retrieve logs. Compute resources are defined in a neptune.json configuration file, which the assistant can also create automatically, including any required port mappings. The following snippet provides an example of a compute resource definition in neptune.json:
{
"kind": "Service",
"name": "my-app",
"cpu": "512",
"memory": "1024",
"port_mappings": [
{ "container_port": 3000, "host_port": 8080 }
]
}
The neptune.json configuration is used to generate the infrastructure model in a deterministic way and allows developers to review deployments and explicitly approve a plan or ask to modify it. Supported cloud resources include storage buckets, secrets, and databases. All provisioned resources have unique physical names the AI assistant can use when generating code to address them unambiguously.
The main requirement for Neptune to automatically provision and deploy a solution is that the appication is containerized. If an app is not containerized, Neptune can provide context to a supported coding assistant to generate a suitable Dockerfile.
Under the hood, Neptune leverages Kubernetes and Crossplane to manage the full lifecycle of provisioned resources, including networking and identity layers, databases and object storage, DNS and TLS, secrets with automatic rotation, and orchestration of rollout and runtime behavior.
When Neptune provisions a resource, it returns authoritative metadata: exact physical identifiers, connection details, and a description of configured permissions. This grounding prevents AI tools from guessing environment variables or inventing configuration. Instead, the AI updates application code using real, provider-generated values, keeping code and infrastructure aligned.
Neptune is not the only player in the nascent field of AI-driven IaC. Pulumi offers a cloud-agnostic platform with an AI-powered agent called Neo that can understand infrastructure dependencies, enforce policies, and automate lifecycle tasks from planning to execution, while supporting human-in-the-loop approvals and governance.
As an alternative approach, though considerably more complex, you can use AI assistants with the de facto IaC standard, Terraform, or with Crossplane for Kubernetes-only deployments to generate the necessary code or configuration.
As mentioned, Neptune is currently in beta. You can sign up to join the closed program on the company’s website.
