We open-sourced 50+ Laravel packages

In June we wrote about why open source matters more than ever in the age of agentic coding and ended on a promise: a serious body of open-source work for the Laravel ecosystem was on its way. Today it is here. We are publishing more than 50 Laravel packages, every one of them free, MIT-licensed and on GitHub and Packagist, with full developer documentation in our open-source catalogue.

They cover the plumbing almost every serious application ends up rebuilding: media, commerce, messaging, approvals, teams, authentication, permissions, infrastructure. We built them so we would never write that plumbing again. Now you do not have to either, and neither does your AI agent.

What is inside

The packages fall into six groups. Each name below opens its docs:

• Content & media — Media Library, Posts, Translatable, Sluggable and QR.
• Commerce — Shops, Purchases, Money, Coupons, Credits, Advertisements and Trading Analytics.
• Social & engagement — Messages, Comments, Reviews, Likes, Contacts, Connections and Campaigns.
• Workflow & lifecycle — Approvals, Requests, Appointments, Onboarding, Teams, Forms, Reports and Opening Hours.
• Data & modeling — Attributes, Options, Addresses, Enums, Metrics and Query Builder.
• Infrastructure — Passkeys, Two-Factor, Auth, Permissions, JWT, Refresh Tokens, Kubernetes API, Git, Certificates, Alerts and seven more.

Spend your AI tokens on your product, not on plumbing

If you build with Claude Code, Cursor, Copilot or any other coding agent, every feature comes with a token bill. Ask an agent to build a two-of-three approval flow, a media library or likes with reactions from scratch, and it has to design the schema, write the models and services, write the tests, run them, read the failures and fix them. Every loop re-reads the code it just wrote, so the bill grows with each iteration, and what you get at the end is still new, unreviewed code that you now own.

With a package, the same feature is one composer require, a trait or two and a few lines of configuration. Your agent reads a documented contract instead of inventing one, and spends its budget on the part only you have: your domain logic.

• Across the catalogue that is more than 220,000 lines of source and 200,000 lines of tests: about 15 million characters, or roughly 3.7 million tokens at a conservative four characters per token, just to generate once, before a single test run or fix. Your agent skips all of it.
• Approvals for Laravel alone is about 4,300 lines of source and 3,200 lines of tests. Using it takes three commands, three traits and one method call.
• Documented, strictly typed APIs mean fewer wrong guesses, and every wrong guess costs your agent another round trip.
• Tokens are the visible saving; maintenance is the bigger one. Code you install gets fixes from us, while code your agent generated is yours to fix for good.

Built as a foundation, not extracted as an afterthought

Most open-source releases are code tidied up after the fact: a helper that grew inside one project, lifted out and published. These were designed the other way around. We set out to build our own foundation, the layer every product and client system of ours stands on, so that no problem gets solved twice. Publishing it was part of the plan from the first commit, and it shows in what you get:

• One toolkit under all of them. Every package boots through the same Package Toolkit for Laravel and is tested with the same testing helpers. Learn how one package is configured and you know the rest.
• Your schema, not ours. Most packages that add tables read a single key-type setting (bigint, UUID or ULID), so they fit the models you already have.
• Dependency-light. Runtime dependencies are official Laravel and Symfony components plus our own toolkit. No third-party code to audit before you install.
• Readable by people and agents. Strict types, stable naming and documented contracts: the properties that let an AI coding agent use a package correctly on the first attempt instead of guessing and burning tokens on retries.

The quality bar, in numbers

In June we promised production quality, thoroughly tested and statically analysed. Here is what that means, measured across every package:

• More than 12,000 Pest tests.
• A coverage floor of at least 90% on every package, and 95% or higher on eleven of them.
• Larastan (PHPStan) at level 7 on every package.
• A CI matrix against Laravel 12 and 13 on PHP 8.4, with Pint keeping the code style consistent.
• The MIT license: use them in commercial projects, fork them, ship them.
• Sectioned documentation for every package, in English and Slovak.

Try one in under a minute

Every package installs the same way. Here is Approvals for Laravel, which adds sign-off to any Eloquent model. Say a release needs two of three people (the tech lead, QA and the product manager) to approve it before it ships. No workflow preset, no config file:

composer require roundly-consulting/approvals-for-laravel

php artisan vendor:publish --tag="approvals-migrations"
php artisan migrate

use RoundlyConsulting\Approvals\Enums\ApprovalRule;
use RoundlyConsulting\Approvals\Traits\GivesApprovals;
use RoundlyConsulting\Approvals\Traits\HasApprovals;
use RoundlyConsulting\Approvals\Traits\RequiresApproval;

class User extends Model
{
    use GivesApprovals;                   // can approve or reject
}

class Release extends Model
{
    use HasApprovals, RequiresApproval;   // needs sign-off
}

// approved at 2 of 3; two rejections reject it
$release->requestApproval([$lead, $qa, $pm], ApprovalRule::Quorum, quorum: 2);

$lead->approve($release, 'Changelog checked');
$release->isPendingApproval();   // true — 1 of 2

$qa->approve($release);
$release->isApproved();          // true — quorum reached, $pm never had to act

That is the whole setup, and everything your agent has to write. Behind those lines sit the rule engine, the decision history with reasons, events and expiry. Quorum is one of four rules (unanimous, quorum, any and weighted), and when the same setup repeats across your app, the Approvals docs show how to name it once as a workflow preset or split it into sequential stages. Every other package is one composer require away.

Free for good, and why we are asking for support

Every package stays free and MIT-licensed. There is no paid edition and no feature held back. But publishing code is the easy part. The real cost starts after release: following every Laravel and PHP version, patching security issues quickly, answering bug reports, and keeping 12,000 tests green and every set of docs in step with the code. That is permanent work, and it is the work your support pays for:

• Maintenance and security — security fixes in tagged releases, framework upgrades as Laravel ships them, dependency updates and issue triage.
• New packages — the catalogue keeps growing. This launch is where it starts, not where it stops.

There are three ways to give:

• A Patreon membership. Recurring support is the most valuable kind, because it lets us plan maintenance months ahead instead of squeezing it in between client projects.
• A one-off donation through Stripe’s secure checkout. No account needed.
• Crypto: BTC, ETH, BNB or SOL. The addresses are on our support page.

No budget? You can still help

• Star the repositories on GitHub. Stars are how other developers find a package.
• Open issues and pull requests. A bug report that comes with a failing test is the best gift a maintainer can get.
• Share this post with a Laravel developer who is about to hand-roll their own approval flow.
• Tell us what to build next. The most requested ideas go to the top of the list.

The same foundation, in your product

These packages are how we work every day. The same foundations sit under the web applications and AI agents we build for clients, which is how we ship quickly without cutting corners. If you would rather have one of these built into your product than wire it up yourself, tell us what you need and you will have a concrete proposal within 48 hours.