Tired of re-explaining your Laravel app every session? Laracopilot 2.0 adds persistent context, Blueprint Mode, and full Laravel 13 support. See what's new.

Laracopilot 2.0: What's New in the Laravel AI Builder

The most common feedback we got on Laracopilot 1.x was a single sentence: "It forgets everything I built yesterday."

That one complaint showed up in support tickets, Discord messages, and user interviews more than any other. Developers would open a new session, describe their app all over again, re-explain their data model, and pick up where they left off. It worked. It just didn't feel like a real development partner.

Laracopilot 2.0 is built around persistence. Context survives across sessions. A planning layer runs before any code gets generated. And the full 2026 Laravel stack is supported on day one.

If you've been building on 1.x and waiting for something that feels like the version we should have shipped first, this is it.

Try Laracopilot 2.0 free at laracopilot.com

What is Laracopilot 2.0?

Laracopilot 2.0 is a Laravel vibecoding platform that generates production-ready Laravel applications from natural language prompts. It is the first major update to Laracopilot since launch, and the defining Laracopilot update for developers who build with AI in 2026. Version 2.0 introduces persistent project context, Blueprint Mode, Laravel 13 same-day support, Filament v5, and multi-model LLM selection — every Laracopilot new feature in this release is a direct response to user feedback from 1.x.

What's new in Laracopilot 2.0

Here's the full before/after picture:

	Laracopilot 1.x	Laracopilot 2.0
Session memory	Resets each session	Persistent project context
Planning layer	Generate immediately	Blueprint Mode first
Laravel version	Laravel 11/12	Laravel 13 (same-day)
Filament support	Filament v3	Filament v5 + Livewire 4
LLM choice	Fixed model	Claude, GPT-4o, Gemini
Test quality	Basic Pest	Full HTTP layer tests
Team features	Solo only	Shared project workspaces
CI integration	Manual deploy	GitHub Actions scaffold
Context source	Prompt only	Laravel Boost MCP

Every row in that table is a decision we made in response to real user feedback. Let me walk through each one.

Blueprint Mode: plan before you generate

What Blueprint Mode does

Before Laracopilot 2.0 generates a single line of code, it builds a blueprint. That blueprint covers your data model, feature list, route structure, and component breakdown in full.

You review the blueprint and edit it before generation starts. Add a relationship. Rename a model. Remove a feature you don't need yet.

The blueprint is yours to shape before a single file is written.

The result is fewer mid-generation surprises and a cleaner architecture from the first commit. No more realizing halfway through that a relationship was generated wrong and having to rebuild three models.

Why we built it

James is a founder who used Laracopilot 1.x to build a subscription SaaS. He got deep into generation before realizing his data model had a problem: a has-many relationship he'd described vaguely had been interpreted incorrectly. His Subscription model had been tied to the wrong parent. He had to regenerate three models and their Filament resources, rewrite the migration files, and reconcile the policies.

That took him two hours. Blueprint Mode would have surfaced the relationship conflict in 30 seconds during review. We heard enough versions of that story to make Blueprint Mode the first feature we scoped for 2.0.

Laravel 13 and Filament v5 support

Laravel 13 shipped on March 18, 2026. Laracopilot 2.0 shipped Laravel 13 support the same day.

Same-day support is not an accident. We track the Laravel release calendar and start compatibility work at the release candidate stage. When the stable tag drops, we're already tested and ready.

That discipline matters for teams who want to start new projects on the current version without waiting weeks for their tooling to catch up. Laravel 13 ships new features in the application skeleton, updates the default Vite configuration, and introduces refinements to the service container. Laracopilot 2.0 generates against those changes from day one.

Filament v5: what changed

Filament v5 released on January 16, 2026. The headline improvements are 60% faster DOM diffing, single-file components, and native Livewire 4 support. For Laracopilot users, this means generated admin panels render faster and the component structure is cleaner to extend.

Laracopilot generates Filament v5 resources by default on all new projects. Here's the structural difference between a generated resource in 1.x versus 2.0:

Filament v3 (Laracopilot 1.x)

// app/Filament/Resources/PostResource.php
class PostResource extends Resource
{
 protected static ?string $model = Post::class;

 public static function form(Form $form): Form
 {
 return $form->schema([
 TextInput::make('title')->required(),
 RichEditor::make('body'),
 Select::make('status')
 ->options(['draft' => 'Draft', 'published' => 'Published']),
 ]);
 }

 public static function table(Table $table): Table
 {
 return $table->columns([
 TextColumn::make('title'),
 BadgeColumn::make('status'),
 TextColumn::make('created_at')->dateTime(),
 ]);
 }

 public static function getPages(): array
 {
 return [
 'index' => Pages\ListPosts::route('/'),
 'create' => Pages\CreatePost::route('/create'),
 'edit' => Pages\EditPost::route('/{record}/edit'),
 ];
 }
}

Filament v5 (Laracopilot 2.0)

// app/Filament/Resources/PostResource.php
class PostResource extends Resource
{
 protected static ?string $model = Post::class;

 public function form(Form $form): Form
 {
 return $form->schema([
 TextInput::make('title')->required(),
 RichEditor::make('body'),
 ToggleButtons::make('status')
 ->options(PostStatus::class)
 ->inline(),
 ]);
 }

 public function table(Table $table): Table
 {
 return $table->columns([
 TextColumn::make('title'),
 TextColumn::make('status')->badge(),
 TextColumn::make('created_at')->since(),
 ]);
 }

 public static function getPages(): array
 {
 return [
 'index' => Pages\ListPosts::route('/'),
 'create' => Pages\CreatePost::route('/create'),
 'edit' => Pages\EditPost::route('/{record}/edit'),
 ];
 }
}

The v5 resource uses instance methods instead of static methods. Native enum support lands via ToggleButtons, and the .since() formatter replaces the verbose .dateTime() call for relative timestamps. These are not cosmetic changes. They affect how Livewire 4 hydrates the component and how the panel handles reactivity under load.

The switch from static to instance methods is the most significant structural change. It lets Filament v5 inject dependencies directly into resource classes, which opens the door to contextual admin panels that respond to authenticated user state. Laracopilot 2.0 generates this correctly by default.

Try it yourself. Create a new Laracopilot project and select Laravel 13 from the version picker. If you're new to this workflow, the guide to generate Filament resources with AI walks through the full process.

Multi-model LLM support

Laracopilot 2.0 lets you choose your generation model: Claude 3.5 Sonnet, GPT-4o, or Gemini 2.0 Flash.

This matters because different models perform differently on different tasks. Our internal testing over 400 generation runs surfaced clear patterns:

Claude 3.5 Sonnet wins on Filament v5 accuracy. It generates the correct instance method signatures, handles enum types cleanly, and gets relationship fields right on the first pass more consistently than the others.
GPT-4o wins on Pest test completeness. The HTTP layer tests it produces are more thorough and catch more edge cases. If test coverage is your priority, start with GPT-4o.
Gemini 2.0 Flash wins on speed for simple CRUD operations. If you're scaffolding a fast internal tool and need velocity over depth, Flash delivers.

This mirrors Laravel's own AI SDK approach: one interface, multiple backends. You choose based on what you're building, not based on what we defaulted to.

We will keep expanding this list as new models mature. Gemini 2.5 Pro is already in our testing pipeline. The goal is to surface real performance differences and let users make an informed choice rather than trust marketing claims about which model is "best."

Persistent context: the feature we built Laracopilot 2.0 around

Persistent context is not a nice-to-have. It's the architectural shift that makes everything else in 2.0 possible.

How it works

Laracopilot now maintains a project manifest for every project you create. The manifest stores your models, relationships, routes, policies, and generated files. It updates every time you generate. When you return to a project the next day or the next week, Laracopilot reads the manifest before responding to your first prompt.

You don't re-explain anything. You just continue.

What this looks like in practice

Nadia is a solo developer building a property management SaaS. In Laracopilot 1.x, she copy-pasted her entire data model into every new session. She had a Tenant model, a Property model, a Lease model, and a MaintenanceRequest model. Getting Laracopilot to understand the relationships and generate correctly required a long prompt block every time she opened the tool.

With 2.0, Nadia opens her project and types: "Add tenant payment tracking."

Laracopilot already knows her Tenant model, her Lease model, and how they relate. It generates the Payment model with the correct foreign keys, the Filament v5 resource with the right relationship fields, and the Pest tests for the payment store and index endpoints. Nothing already built breaks.

That shift from "re-explain everything" to "just continue" is the core of Laracopilot 2.0. For a deeper look at what this makes possible, see how teams build Laravel apps with AI from scratch.

Laravel Boost MCP integration

Laracopilot 1.x was built for greenfield projects. You described an app, it generated an app. Developers with existing codebases had no way to bring Laracopilot into their workflow.

Laracopilot 2.0 reads your Laravel Boost MCP context when working on existing projects. If you have an existing Laravel application with Laravel Boost installed, Laracopilot can augment it.

Add a new module. Generate a new Filament resource that fits your existing architecture. Scaffold a new API endpoint that follows your existing patterns.

This closes the "Laracopilot only works greenfield" gap for good.

In practice, this means you can use Laracopilot on a production app that has been running for two years. Point it at your existing codebase, let it read the Boost context, and ask it to add a feature. It generates against your actual conventions, not generic assumptions. The manifest from Boost becomes the foundation the same way a blueprint does for new projects.

Improved Pest test generation

Laracopilot 1.x wrote Pest tests that mocked too much. The tests passed in isolation and missed bugs that only surfaced when the actual HTTP layer was involved. We heard from developers who shipped regressions that their Laracopilot-generated test suite did not catch.

Laracopilot 2.0 generates tests that hit the real HTTP layer. Every generated controller ships with a full test suite by default, using actingAs(), $this->post(), and assertStatus() against the real application routes.

Here's what that looks like for a generated posts controller:

it('allows an authenticated user to create a post', function () {
 $user = User::factory()->create();

 $response = $this->actingAs($user)->post('/api/posts', [
 'title' => 'New Post',
 'body' => 'Post content here.',
 'status' => 'draft',
 ]);

 $response->assertStatus(201);
 $this->assertDatabaseHas('posts', ['title' => 'New Post']);
});

it('returns 403 when a guest tries to create a post', function () {
 $response = $this->post('/api/posts', [
 'title' => 'New Post',
 'body' => 'Post content here.',
 'status' => 'draft',
 ]);

 $response->assertStatus(403);
});

Real routes. Real middleware. Real assertions. This is what test coverage should look like, and it's now the default for every generated controller.

Team workspaces and GitHub Actions

Laracopilot 2.0 ships team features that 1.x users have been asking for since launch.

Shared project workspaces

Multiple team members can now access the same Laracopilot project. Role-based access controls who can generate, who can review, and who can manage the project:

Owner: Full access, billing, team management
Developer: Generate, edit blueprint, view history
Reviewer: View and comment only

For agencies using the Agency plan, shared workspaces mean a lead developer can set up the blueprint and architecture, then hand off generation tasks to the team without losing context.

GitHub Actions scaffold

Every generated application now includes a basic CI workflow. On push to any branch, it runs Pest and Pint. On merge to main, it triggers your deploy hook. The workflow file ships with sensible defaults and works with GitHub-hosted runners without additional configuration.

You don't have to write your CI setup from scratch. You inherit a working pipeline on day one.

This matters most for solo developers and small teams who don't have a DevOps specialist. A generated app that ships with a working CI workflow is a different product category from one that generates code and leaves the infrastructure to you. We want every Laracopilot project to be production-ready from the first commit.

What comes next

Laracopilot 2.0 is the version we should have shipped first. Persistent context and a planning layer were not optional features. They were foundational requirements we underestimated when we rushed to launch.

Laravel 13 support, Filament v5, multi-model LLM, real HTTP-layer tests, team workspaces: these are the table stakes for a serious Laravel AI builder 2026. We're now at that baseline. Everything we build from here compounds on a foundation that actually works.

If you've been waiting to try Laracopilot, or if you tried 1.x and walked away frustrated, now is the right time to come back. This is the Laravel vibecoding platform we set out to build from day one.

Try Laracopilot 2.0 free at laracopilot.com