Encore

Infrastructure as code was a 2014 idea, and 2026 is the last year of Terraform. You write YAML or HCL that describes infra, then a tool reconciles it. It assumed a human was the source of truth. That assumption breaks when an AI agent is writing the code. An agent let loose on Terraform doesn't know which IAM role to reuse, or which firewall rule to remove as it's no longer needed. You end up with infra sprawl, permission drift, and a security review queue that never empties. Infrastructure FROM code flips the model. The application code is the source of truth. A compiler reads the code, understands the intent (this is a Pub/Sub topic, this service calls that one, this endpoint needs auth), and derives the infra deterministically. No YAML. No drift. No hallucinated modules. We've been building toward this at Encore for years. What we didn't predict in 2021 is how well it would fit the agentic era. Turns out a compiler is a very good guardrail for an AI writing backend code. Fewer decisions for the agent to get wrong. Fewer tokens burned on boilerplate. Reviewable, auditable output by default. The AI era doesn't need more config files. It needs fewer. More on the blog: https://lnkd.in/ebe_GgmK

You can now add open-source authentication to your Encore app using Ory Corp. Session verification, protected endpoints, and a Postgres database that Encore provisions automatically. Read more: https://lnkd.in/dGtmybf2

One of the more interesting problems we've been working through internally: what does development infrastructure look like when AI agents are doing meaningful portions of the work? The current workflow most teams are landing on is messy. Agents run locally, spin up multiple workspaces, execute changes against mocked or partially real environments, and hand off to humans for review. It works, but it doesn't scale. Setup times are long, the environments aren't real (in terms of matching production infrastructure), and by the time a human reviews the output there's no reliable way to validate the changes without deploying to real cloud infrastructure. The model we're working toward is different: cloud sandbox environments where agents can iterate against real infrastructure, with full tracing and observability from the start. The output of an agent session isn't just code, it's rich validation based on running a full-stack application on real infrastructure, walking through the changes end to end and verifying the result using both tracing and UI snapshots. Real evidence of correctness, not just a code diff to review. The other dimension is scale. If you can spin up thousands of real, fully-traced cloud environment in seconds, the economics of parallel agentic work changes completely. Instead of a handful of agent sessions per engineer, your team is running thousands of agents in parallel, each in their own sandboxed environment, with the results collapsing into validated, deployable output. This is early and we're still figuring out the right shape of it. But the direction feels right: agents need real infrastructure, real observability, and fast environments. That's what we're building toward at Encore.

"AI-native" has become one of those terms that gets attached to everything and means nothing. Here's what it means to us in practice, from something we just shipped. We added a "Copy LLM prompt" button to the Encore local dev dashboard. When you click it, it generates a prompt that will leverage Encore's built-in MCP to capture full system context: the service topology, the live request traces, the API structure, the infrastructure dependencies. Ready to paste directly into any AI coding tool. It sounds simple. But the reason it works is because Encore already knows your entire system at the framework level. It's not scraping your codebase or inferring structure from comments. The full picture of your application; every service, every API endpoint, every infrastructure dependency, is captured declaratively in the source code. That same structured representation is what makes AI agents dramatically more effective when working on Encore apps. Instead of spending tokens reading through Terraform configs, scattered YAML files, and CI pipelines, an agent can get complete system understanding from the structured metadata Encore maintains automatically. In practice this means agents working on Encore codebases use around 75% fewer tokens than on traditional toolchains. AI-native isn't a UI feature. It's a fundamental architectural property. If your system's structure isn't explicitly represented in a way AI can consume directly, you're not AI-native, you're just AI-adjacent.

You can now debug backend requests directly from your frontend. Drop a script tag into your app and get: - Traces for every API call, linked directly from your frontend - Backend logs for each request - One-click LLM prompts to debug any request with Encore MCP Works locally and in deployed environments.

We're hiring the top 0.0001% engineers to help us build the development platform for the AI era. We've grown more in the last few months than in the previous four years combined, with thousands of developers using the framework and billions of requests processed by applications built on Encore. If making Encore the default way teams build and ship in the cloud sounds interesting, link below.

You can now add Redis to your Encore app with a few lines of TypeScript (or 1 prompt). When you deploy it via Encore Cloud, it becomes a fully managed ElastiCache / Memorystore instance in your own AWS/GCP.

We wrote 60,000 lines of Rust to power a TypeScript framework, and are now sharing what that journey actually looked like. The runtime handles everything underneath your application code - HTTP, databases, pub/sub, tracing, caching, API gateway - all running multi-threaded in the same process as Node.js. Give it a read: https://lnkd.in/dd-bwM-J

You can now copy any trace from the Encore local dashboard and paste it into your AI agent to investigate and fix it.