Ehsan Bagherzadegan
Back to articles
7 min read

Laravel AI SDK 1.1: Agent Skills, Cohere Chat, and Production-Ready Tooling

Laravel AI SDK 1.1 introduces Agent Skills for reusable agent capabilities, Cohere text generation via v2 Chat API, tool approval for built-in tools, and smarter provider failover — everything you need to run agents in production.

Laravel AI SDK 1.1 landed on October 5 with two headline features that change how you build AI-powered Laravel applications: Agent Skills for reusable, discoverable agent capabilities, and Cohere text generation via their v2 Chat API. The release also adds tool approval for built-in tools, smarter provider failover, and a handful of new tools and provider integrations.

If you're building Laravel apps that talk to LLMs — chatbots, assistants, document analysis, code generation — this release is worth a close look.

Agent Skills: Reusable, Discoverable Capabilities

The biggest addition in 1.1 is Agent Skills, an implementation of the Agent Skills specification. Think of a skill as a self-contained capability: a folder with a SKILL.md file describing what the skill does, plus any reference files the agent might need (API docs, examples, schemas).

resources/skills/
├── github-issues/
│   ├── SKILL.md
│   └── api-reference.md
├── database-query/
│   ├── SKILL.md
│   └── schema.sql
└── send-email/
    ├── SKILL.md
    └── templates/

The SKILL.md uses YAML frontmatter for metadata and Markdown for instructions:

---
name: "github-issues"
description: "Search, create, and manage GitHub issues"
version: "1.0.0"
---
# GitHub Issues Skill

You can search, create, and update GitHub issues using the GitHub REST API.

## Available Actions
- `search_issues(query, repo?)`
- `create_issue(title, body, repo?)`
- `update_issue(number, updates, repo?)`

## Authentication
Requires a `GITHUB_TOKEN` environment variable with `repo` scope.

Agents opt into skills by implementing the HasSkills contract (or using the Skillable trait). Once enabled, the agent receives a LoadSkill tool that lets the LLM discover and load skills at runtime — no hardcoding required.

use Laravel\AI\Facades\AI;
use Laravel\AI\Contracts\HasSkills;

class SupportAgent extends Agent implements HasSkills
{
    use \Laravel\AI\Traits\Skillable;

    protected string $instructions = 'You are a support agent. Use skills to help users.';

    public function skills(): array
    {
        return [
            'resources/skills',           // directory of skills
            new GitHubIssuesSkill,        // PHP Skill object
            fn () => UserSkill::for(auth()->user()), // closure for dynamic skills
        ];
    }
}

This is a significant shift from v1.0. Previously, you'd bake every capability into the agent's instructions or custom tools. Skills let you compose agents from reusable pieces, share skills across projects, and even load user-specific skills from the database.

The SDK ships with two Artisan commands for working with skills:

php artisan make:skill github-issues    # scaffolds a skill folder with SKILL.md
php artisan skill:list                  # lists all discoverable skills

Cohere Text Generation

Cohere was already supported for embeddings and reranking. Version 1.1 adds text generation via Cohere's v2 Chat API (command-a-03-2025 by default), with support for:

  • Streaming responses

  • Tool/function calling

  • Structured output (JSON schema)

  • Reasoning tokens

  • Cohere-specific options like documents (for RAG) and safety_mode

use Laravel\AI\Facades\AI;

$response = AI::agent(SupportAgent::class)
    ->provider('cohere')
    ->prompt('How do I reset my password?')
    ->withOptions([
        'documents' => [
            ['id' => 'doc-1', 'text' => 'Password reset docs...'],
        ],
        'safety_mode' => 'STRICT',
    ])
    ->run();

echo $response->text();

If you're already using Cohere for embeddings, you can now keep everything in one provider. The streaming support also means you get token-by-token output for better perceived latency in chat interfaces.

Tool Approval for Built-in Tools

v1.0 introduced the Approvable contract for custom tools. v1.1 extends this to built-in tools: MCP, agent delegation, similarity search, and filesystem operations.

use Laravel\AI\Tools\Filesystem\ReadFile;
use Laravel\AI\Tools\Filesystem\WriteFile;

$agent = AI::agent(CodeAgent::class)
    ->withTools([
        (new ReadFile)->requireApproval(),
        (new WriteFile)->requireApproval(fn ($tool, $args) => $args['path'] !== 'README.md'),
    ]);

When an agent tries to use an approvable tool, the SDK pauses execution and calls your approval callback. You can present the request to a human, log it, or auto-approve based on rules. This is essential for production agents that touch sensitive operations — file writes, database mutations, external API calls.

Smarter Provider Failover

In v1.0, if your primary provider failed and the fallback didn't support a tool the agent was using, the whole request would error. v1.1 fixes this: the text generation loop now removes unsupported provider tools before each retry attempt.

$response = AI::agent(ResearchAgent::class)
    ->provider('anthropic')           // primary
    ->fallback('openai')              // fallback
    ->fallback('google')              // second fallback
    ->prompt('Analyze this codebase...')
    ->run();

If Anthropic fails and OpenAI doesn't support the WebSearch tool the agent requested, the SDK strips WebSearch and retries with OpenAI. The agent keeps working, just with a reduced toolset. This makes multi-provider setups far more resilient.

New Tools and Provider Integrations

Self-hosted Laya Classification

Laya is an open-source content classifier. The new TypeSafe driver lets you run it locally for PII detection, toxicity scoring, or custom categories — no external API calls.

Azure AI Search Tool (ToolSearch)

If you use Azure AI Search (formerly Cognitive Search), the new ToolSearch integration lets agents query your search index directly:

use Laravel\AI\Tools\Azure\ToolSearch;

$agent->withTools([
    new ToolSearch(
        endpoint: config('services.azure.search.endpoint'),
        index: 'docs',
        key: config('services.azure.search.key'),
    ),
]);

Groq WebSearch and CodeExecution

Groq's ultra-fast inference now exposes two built-in tools:

  • WebSearch — real-time web search via Groq's hosted search

  • CodeExecution — sandboxed Python execution for data analysis, calculations, plotting

MoveFile Filesystem Tool

Complements the existing ReadFile, WriteFile, ListFiles, DeleteFile. MoveFile handles renames and moves atomically.

Updated Default Models

  • Anthropic: claude-sonnet-5-5 (was claude-sonnet-4-5)

  • Google Gemini: gemini-3.8-flash (was gemini-2.5-flash)

These are set as SDK defaults but can be overridden per-request.

When to Use What

FeatureUse Case
Agent SkillsReusable capabilities across agents; per-user/per-tenant skills; sharing skills between projects
Cohere ChatYou already use Cohere for embeddings/reranking; need built-in RAG (documents param); want fast, cheap generation
Tool ApprovalProduction agents that write files, call paid APIs, or mutate data
Provider FailoverHigh-availability requirements; cost optimization (cheap primary, expensive fallback)
Azure ToolSearchEnterprise RAG on Azure AI Search
Groq WebSearch/CodeExecutionUltra-low-latency needs; agents that need live data or computation

Gotchas

  • Skills are loaded at runtime — the LLM decides which skill to load. If your skill instructions are vague, the agent may pick the wrong one. Write clear description fields and concrete examples in SKILL.md.

  • Cohere tool calling follows their v2 API format, which differs from OpenAI/Anthropic. The SDK normalizes this, but if you're parsing raw tool calls, expect Cohere's structure.

  • Approval callbacks run synchronously — don't do slow I/O in them. Queue a job if you need human review.

  • Failover strips tools silently — log the ProviderFailover event if you need visibility into which tools were dropped.

Upgrading from 1.0

The upgrade is non-breaking for most apps. Key changes:

  1. Skills are opt-in — existing agents work unchanged.

  2. Built-in tools now implement Approvable — if you were calling requireApproval() on custom tools, the API is the same.

  3. Default models updated — pin your model explicitly if you need consistency: ->model('claude-sonnet-4-5').

  4. New HasSkills contract — replaces the internal skill handling from the PR. Use the Skillable trait for the easiest migration.

Run composer require laravel/ai:^1.1 and check the upgrade guide for edge cases.

Takeaway

Laravel AI SDK 1.1 moves the ecosystem closer to production-ready agent development. Skills give you a standardized way to package and share agent capabilities. Cohere support adds a credible alternative to the big three providers. Tool approval and smarter failover address the operational concerns that kept many teams in "prototype mode."

If you've been waiting for the tooling to mature before putting an agent in front of users, this release is a good signal to start building.

Sources