diff --git a/app/Http/Controllers/RoutineController.php b/app/Http/Controllers/RoutineController.php
new file mode 100644
index 0000000..fb6eb2a
--- /dev/null
+++ b/app/Http/Controllers/RoutineController.php
@@ -0,0 +1,127 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Routine;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+use Inertia\Response;
+
+class RoutineController extends Controller
+{
+    public function index(Request $request): Response
+    {
+        $team = $request->user()->currentTeam;
+
+        $routines = $team->routines()
+            ->with('agent:id,name,emoji')
+            ->orderByDesc('created_at')
+            ->get();
+
+        return Inertia::render('company/routines/index', [
+            'routines' => $routines,
+            'agents' => $team->agents()->select(['id', 'name', 'emoji'])->get(),
+        ]);
+    }
+
+    public function store(Request $request): RedirectResponse
+    {
+        $team = $request->user()->currentTeam;
+
+        $validated = $request->validate([
+            'title' => ['required', 'string', 'max:255'],
+            'description' => ['nullable', 'string', 'max:5000'],
+            'agent_id' => ['required', 'string', 'exists:agents,id'],
+            'cron_expression' => ['required', 'string', 'max:255'],
+            'timezone' => ['nullable', 'string', 'timezone:all'],
+        ]);
+
+        // Verify agent belongs to team
+        abort_unless(
+            $team->agents()->where('id', $validated['agent_id'])->exists(),
+            422,
+            'Agent does not belong to this team.',
+        );
+
+        // Enforce per-team limit
+        $activeCount = $team->routines()->where('status', 'active')->count();
+        abort_if($activeCount >= 50, 422, 'Maximum of 50 active routines per team.');
+
+        $routine = $team->routines()->create([
+            ...$validated,
+            'timezone' => $validated['timezone'] ?? 'UTC',
+            'status' => 'active',
+        ]);
+
+        $routine->update([
+            'next_run_at' => $routine->computeNextRun(),
+        ]);
+
+        return redirect()->route('company.routines.index')
+            ->with('success', 'Routine created.');
+    }
+
+    public function update(Request $request, Routine $routine): RedirectResponse
+    {
+        $this->authorizeTeam($request, $routine);
+
+        $validated = $request->validate([
+            'title' => ['required', 'string', 'max:255'],
+            'description' => ['nullable', 'string', 'max:5000'],
+            'agent_id' => ['required', 'string', 'exists:agents,id'],
+            'cron_expression' => ['required', 'string', 'max:255'],
+            'timezone' => ['nullable', 'string', 'timezone:all'],
+        ]);
+
+        $team = $request->user()->currentTeam;
+
+        abort_unless(
+            $team->agents()->where('id', $validated['agent_id'])->exists(),
+            422,
+            'Agent does not belong to this team.',
+        );
+
+        $routine->update([
+            ...$validated,
+            'timezone' => $validated['timezone'] ?? 'UTC',
+        ]);
+
+        $routine->update([
+            'next_run_at' => $routine->computeNextRun(),
+        ]);
+
+        return redirect()->route('company.routines.index')
+            ->with('success', 'Routine updated.');
+    }
+
+    public function toggle(Request $request, Routine $routine): RedirectResponse
+    {
+        $this->authorizeTeam($request, $routine);
+
+        $newStatus = $routine->status === 'active' ? 'paused' : 'active';
+
+        $routine->update([
+            'status' => $newStatus,
+            'next_run_at' => $newStatus === 'active' ? $routine->computeNextRun() : null,
+        ]);
+
+        return redirect()->route('company.routines.index')
+            ->with('success', 'Routine '.($newStatus === 'active' ? 'activated' : 'paused').'.');
+    }
+
+    public function destroy(Request $request, Routine $routine): RedirectResponse
+    {
+        $this->authorizeTeam($request, $routine);
+
+        $routine->delete();
+
+        return redirect()->route('company.routines.index')
+            ->with('success', 'Routine deleted.');
+    }
+
+    private function authorizeTeam(Request $request, Routine $routine): void
+    {
+        abort_unless($routine->team_id === $request->user()->current_team_id, 403);
+    }
+}
diff --git a/app/Jobs/ProcessRoutinesJob.php b/app/Jobs/ProcessRoutinesJob.php
new file mode 100644
index 0000000..d84ab37
--- /dev/null
+++ b/app/Jobs/ProcessRoutinesJob.php
@@ -0,0 +1,91 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Models\Routine;
+use App\Models\Task;
+use App\Models\Team;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Queue\Queueable;
+use Illuminate\Support\Facades\Log;
+
+class ProcessRoutinesJob implements ShouldQueue
+{
+    use Queueable;
+
+    public function handle(): void
+    {
+        $routines = Routine::query()
+            ->where('status', 'active')
+            ->where('next_run_at', '<=', now())
+            ->with('team')
+            ->get();
+
+        foreach ($routines as $routine) {
+            $this->processRoutine($routine);
+        }
+    }
+
+    private function processRoutine(Routine $routine): void
+    {
+        // Skip if a pending task from this routine already exists
+        $hasPendingTask = Task::query()
+            ->where('routine_id', $routine->id)
+            ->whereIn('status', ['todo', 'in_progress', 'blocked'])
+            ->exists();
+
+        if ($hasPendingTask) {
+            // Still update next_run_at so we check again later
+            $routine->update([
+                'next_run_at' => $routine->computeNextRun(),
+            ]);
+
+            return;
+        }
+
+        // Enforce per-team limit of 50 active routines
+        $activeCount = Routine::query()
+            ->where('team_id', $routine->team_id)
+            ->where('status', 'active')
+            ->count();
+
+        if ($activeCount > 50) {
+            Log::warning('Team has exceeded 50 active routines, skipping routine processing', [
+                'team_id' => $routine->team_id,
+                'routine_id' => $routine->id,
+            ]);
+
+            return;
+        }
+
+        $identifier = $this->generateIdentifier($routine->team);
+
+        Task::query()->create([
+            'team_id' => $routine->team_id,
+            'agent_id' => $routine->agent_id,
+            'routine_id' => $routine->id,
+            'created_by_type' => 'routine',
+            'created_by_id' => $routine->id,
+            'title' => $routine->title,
+            'description' => $routine->description,
+            'status' => 'todo',
+            'priority' => 'medium',
+            'identifier' => $identifier,
+        ]);
+
+        $routine->update([
+            'last_run_at' => now(),
+            'next_run_at' => $routine->computeNextRun(),
+        ]);
+    }
+
+    /**
+     * Generate a sequential task identifier like TSK-1, TSK-2, etc.
+     */
+    private function generateIdentifier(Team $team): string
+    {
+        $count = $team->tasks()->count();
+
+        return 'TSK-'.($count + 1);
+    }
+}
diff --git a/app/Models/Routine.php b/app/Models/Routine.php
new file mode 100644
index 0000000..07b5fca
--- /dev/null
+++ b/app/Models/Routine.php
@@ -0,0 +1,91 @@
+<?php
+
+namespace App\Models;
+
+use Carbon\Carbon;
+use Cron\CronExpression;
+use Database\Factories\RoutineFactory;
+use Illuminate\Database\Eloquent\Concerns\HasUlids;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class Routine extends Model
+{
+    /** @use HasFactory<RoutineFactory> */
+    use HasFactory, HasUlids;
+
+    /**
+     * @var list<string>
+     */
+    protected $fillable = [
+        'team_id',
+        'agent_id',
+        'title',
+        'description',
+        'cron_expression',
+        'timezone',
+        'status',
+        'last_run_at',
+        'next_run_at',
+    ];
+
+    /**
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'last_run_at' => 'datetime',
+            'next_run_at' => 'datetime',
+        ];
+    }
+
+    /**
+     * @return BelongsTo<Team, $this>
+     */
+    public function team(): BelongsTo
+    {
+        return $this->belongsTo(Team::class);
+    }
+
+    /**
+     * @return BelongsTo<Agent, $this>
+     */
+    public function agent(): BelongsTo
+    {
+        return $this->belongsTo(Agent::class);
+    }
+
+    /**
+     * @return HasMany<Task, $this>
+     */
+    public function tasks(): HasMany
+    {
+        return $this->hasMany(Task::class);
+    }
+
+    /**
+     * Compute the next run time based on the cron expression and timezone.
+     */
+    public function computeNextRun(): ?Carbon
+    {
+        try {
+            $next = CronExpression::factory($this->cron_expression)
+                ->getNextRunDate(now(), 0, false, $this->timezone);
+
+            return Carbon::instance($next);
+        } catch (\Throwable) {
+            return null;
+        }
+    }
+
+    /**
+     * Determine if this routine is due to run.
+     */
+    public function isDue(): bool
+    {
+        return $this->next_run_at && $this->next_run_at->lte(now());
+    }
+}
diff --git a/app/Models/Task.php b/app/Models/Task.php
index 1525603..bfd7314 100644
--- a/app/Models/Task.php
+++ b/app/Models/Task.php
@@ -33,6 +33,7 @@ class Task extends Model
         'completed_at',
         'parent_task_id',
         'goal_id',
+        'routine_id',
         'checked_out_by_run',
         'checked_out_at',
         'checkout_expires_at',
@@ -109,6 +110,14 @@ public function goal(): BelongsTo
         return $this->belongsTo(Goal::class);
     }
 
+    /**
+     * @return BelongsTo<Routine, $this>
+     */
+    public function routine(): BelongsTo
+    {
+        return $this->belongsTo(Routine::class);
+    }
+
     /**
      * The workforce agent assigned to this task.
      *
diff --git a/app/Models/Team.php b/app/Models/Team.php
index 95e1f66..6128436 100644
--- a/app/Models/Team.php
+++ b/app/Models/Team.php
@@ -100,6 +100,14 @@ public function tasks(): HasMany
         return $this->hasMany(Task::class);
     }
 
+    /**
+     * @return HasMany<Routine, $this>
+     */
+    public function routines(): HasMany
+    {
+        return $this->hasMany(Routine::class);
+    }
+
     /**
      * @return HasMany<Goal, $this>
      */
diff --git a/database/factories/RoutineFactory.php b/database/factories/RoutineFactory.php
new file mode 100644
index 0000000..fae5edd
--- /dev/null
+++ b/database/factories/RoutineFactory.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Agent;
+use App\Models\Routine;
+use App\Models\Team;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<Routine>
+ */
+class RoutineFactory extends Factory
+{
+    /**
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            'team_id' => Team::factory(),
+            'agent_id' => Agent::factory(),
+            'title' => fake()->sentence(4),
+            'description' => fake()->paragraph(),
+            'cron_expression' => '0 9 * * *',
+            'timezone' => 'UTC',
+            'status' => 'active',
+            'next_run_at' => now()->addDay(),
+        ];
+    }
+
+    public function paused(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'status' => 'paused',
+            'next_run_at' => null,
+        ]);
+    }
+}
diff --git a/database/migrations/2026_04_08_220002_create_routines_table.php b/database/migrations/2026_04_08_220002_create_routines_table.php
new file mode 100644
index 0000000..7f22852
--- /dev/null
+++ b/database/migrations/2026_04_08_220002_create_routines_table.php
@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('routines', function (Blueprint $table) {
+            $table->ulid('id')->primary();
+            $table->foreignUlid('team_id')->constrained('teams')->cascadeOnDelete();
+            $table->foreignUlid('agent_id')->constrained('agents')->cascadeOnDelete();
+            $table->string('title');
+            $table->text('description')->nullable();
+            $table->string('cron_expression');
+            $table->string('timezone')->default('UTC');
+            $table->string('status')->default('active');
+            $table->timestamp('last_run_at')->nullable();
+            $table->timestamp('next_run_at')->nullable();
+            $table->timestamps();
+
+            $table->index(['team_id', 'status']);
+            $table->index(['team_id', 'agent_id']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('routines');
+    }
+};
diff --git a/database/migrations/2026_04_08_220003_add_routine_id_to_tasks_table.php b/database/migrations/2026_04_08_220003_add_routine_id_to_tasks_table.php
new file mode 100644
index 0000000..ab52441
--- /dev/null
+++ b/database/migrations/2026_04_08_220003_add_routine_id_to_tasks_table.php
@@ -0,0 +1,22 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('tasks', function (Blueprint $table) {
+            $table->foreignUlid('routine_id')->nullable()->after('goal_id')->constrained('routines')->nullOnDelete();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('tasks', function (Blueprint $table) {
+            $table->dropConstrainedForeignId('routine_id');
+        });
+    }
+};
diff --git a/resources/js/pages/company/routines/index.tsx b/resources/js/pages/company/routines/index.tsx
new file mode 100644
index 0000000..520acc6
--- /dev/null
+++ b/resources/js/pages/company/routines/index.tsx
@@ -0,0 +1,405 @@
+import { Head, router, useForm } from '@inertiajs/react';
+import { Pause, Play, Plus, RefreshCw, Trash2 } from 'lucide-react';
+import { useState } from 'react';
+import Heading from '@/components/heading';
+import { Badge } from '@/components/ui/badge';
+import { Button } from '@/components/ui/button';
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle,
+    DialogTrigger,
+} from '@/components/ui/dialog';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import {
+    Select,
+    SelectContent,
+    SelectItem,
+    SelectTrigger,
+    SelectValue,
+} from '@/components/ui/select';
+import { Textarea } from '@/components/ui/textarea';
+import AppLayout from '@/layouts/app-layout';
+import type { Agent, BreadcrumbItem, Routine } from '@/types';
+
+const CRON_PRESETS: { label: string; value: string }[] = [
+    { label: 'Every hour', value: '0 * * * *' },
+    { label: 'Every 6 hours', value: '0 */6 * * *' },
+    { label: 'Daily at midnight', value: '0 0 * * *' },
+    { label: 'Daily at 9 AM', value: '0 9 * * *' },
+    { label: 'Every Monday at 9 AM', value: '0 9 * * 1' },
+    { label: 'Every weekday at 9 AM', value: '0 9 * * 1-5' },
+    { label: 'First of every month', value: '0 0 1 * *' },
+];
+
+const COMMON_TIMEZONES = [
+    'UTC',
+    'America/New_York',
+    'America/Chicago',
+    'America/Denver',
+    'America/Los_Angeles',
+    'Europe/London',
+    'Europe/Berlin',
+    'Europe/Paris',
+    'Asia/Tokyo',
+    'Asia/Shanghai',
+    'Asia/Kolkata',
+    'Australia/Sydney',
+];
+
+function humanCron(expr: string): string {
+    const map: Record<string, string> = {
+        '* * * * *': 'Every minute',
+        '0 * * * *': 'Every hour',
+        '0 */6 * * *': 'Every 6 hours',
+        '0 0 * * *': 'Daily at midnight',
+        '0 9 * * *': 'Daily at 9 AM',
+        '0 9 * * 1': 'Every Monday at 9 AM',
+        '0 9 * * 1-5': 'Weekdays at 9 AM',
+        '0 0 1 * *': 'First of every month',
+    };
+    return map[expr] ?? expr;
+}
+
+function formatDate(dateStr: string | null): string {
+    if (!dateStr) return '-';
+    return new Date(dateStr).toLocaleString(undefined, {
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+
+function CreateRoutineDialog({ agents }: { agents: Agent[] }) {
+    const [open, setOpen] = useState(false);
+    const form = useForm({
+        title: '',
+        description: '',
+        agent_id: '',
+        cron_expression: '0 9 * * *',
+        timezone: 'UTC',
+    });
+
+    function handleSubmit(e: React.FormEvent) {
+        e.preventDefault();
+        form.post('/company/routines', {
+            onSuccess: () => {
+                setOpen(false);
+                form.reset();
+            },
+        });
+    }
+
+    return (
+        <Dialog open={open} onOpenChange={setOpen}>
+            <DialogTrigger asChild>
+                <Button size="sm">
+                    <Plus className="mr-1.5 size-3.5" />
+                    Create Routine
+                </Button>
+            </DialogTrigger>
+            <DialogContent>
+                <DialogHeader>
+                    <DialogTitle>Create Routine</DialogTitle>
+                    <DialogDescription>
+                        Schedule a recurring task for an agent.
+                    </DialogDescription>
+                </DialogHeader>
+                <form onSubmit={handleSubmit} className="space-y-4">
+                    <div className="space-y-2">
+                        <Label htmlFor="routine-title">Title</Label>
+                        <Input
+                            id="routine-title"
+                            value={form.data.title}
+                            onChange={(e) =>
+                                form.setData('title', e.target.value)
+                            }
+                            placeholder="e.g. Daily standup report"
+                            required
+                        />
+                        {form.errors.title && (
+                            <p className="text-xs text-red-500">
+                                {form.errors.title}
+                            </p>
+                        )}
+                    </div>
+                    <div className="space-y-2">
+                        <Label htmlFor="routine-desc">
+                            Description{' '}
+                            <span className="text-muted-foreground">
+                                (optional)
+                            </span>
+                        </Label>
+                        <Textarea
+                            id="routine-desc"
+                            value={form.data.description}
+                            onChange={(e) =>
+                                form.setData('description', e.target.value)
+                            }
+                            rows={3}
+                            placeholder="What should the agent do each time this runs?"
+                        />
+                    </div>
+                    <div className="space-y-2">
+                        <Label>Agent</Label>
+                        <Select
+                            value={form.data.agent_id}
+                            onValueChange={(v) => form.setData('agent_id', v)}
+                        >
+                            <SelectTrigger>
+                                <SelectValue placeholder="Select an agent" />
+                            </SelectTrigger>
+                            <SelectContent>
+                                {agents.map((a) => (
+                                    <SelectItem key={a.id} value={a.id}>
+                                        {a.name}
+                                    </SelectItem>
+                                ))}
+                            </SelectContent>
+                        </Select>
+                        {form.errors.agent_id && (
+                            <p className="text-xs text-red-500">
+                                {form.errors.agent_id}
+                            </p>
+                        )}
+                    </div>
+                    <div className="grid grid-cols-2 gap-4">
+                        <div className="space-y-2">
+                            <Label>Schedule</Label>
+                            <Select
+                                value={form.data.cron_expression}
+                                onValueChange={(v) =>
+                                    form.setData('cron_expression', v)
+                                }
+                            >
+                                <SelectTrigger>
+                                    <SelectValue />
+                                </SelectTrigger>
+                                <SelectContent>
+                                    {CRON_PRESETS.map((p) => (
+                                        <SelectItem
+                                            key={p.value}
+                                            value={p.value}
+                                        >
+                                            {p.label}
+                                        </SelectItem>
+                                    ))}
+                                </SelectContent>
+                            </Select>
+                            <Input
+                                value={form.data.cron_expression}
+                                onChange={(e) =>
+                                    form.setData(
+                                        'cron_expression',
+                                        e.target.value,
+                                    )
+                                }
+                                placeholder="* * * * *"
+                                className="mt-1 font-mono text-xs"
+                            />
+                            {form.errors.cron_expression && (
+                                <p className="text-xs text-red-500">
+                                    {form.errors.cron_expression}
+                                </p>
+                            )}
+                        </div>
+                        <div className="space-y-2">
+                            <Label>Timezone</Label>
+                            <Select
+                                value={form.data.timezone}
+                                onValueChange={(v) =>
+                                    form.setData('timezone', v)
+                                }
+                            >
+                                <SelectTrigger>
+                                    <SelectValue />
+                                </SelectTrigger>
+                                <SelectContent>
+                                    {COMMON_TIMEZONES.map((tz) => (
+                                        <SelectItem key={tz} value={tz}>
+                                            {tz.replace(/_/g, ' ')}
+                                        </SelectItem>
+                                    ))}
+                                </SelectContent>
+                            </Select>
+                        </div>
+                    </div>
+                    <DialogFooter>
+                        <Button type="submit" disabled={form.processing}>
+                            Create
+                        </Button>
+                    </DialogFooter>
+                </form>
+            </DialogContent>
+        </Dialog>
+    );
+}
+
+function RoutineRow({ routine }: { routine: Routine }) {
+    const [confirmDelete, setConfirmDelete] = useState(false);
+
+    function handleToggle() {
+        router.post(
+            `/company/routines/${routine.id}/toggle`,
+            {},
+            {
+                preserveScroll: true,
+            },
+        );
+    }
+
+    function handleDelete() {
+        router.delete(`/company/routines/${routine.id}`, {
+            preserveScroll: true,
+        });
+    }
+
+    return (
+        <div className="flex items-center gap-3 rounded-lg border px-4 py-3 transition-colors hover:bg-muted/30">
+            <div className="min-w-0 flex-1">
+                <div className="flex items-center gap-2">
+                    <span className="truncate text-sm font-medium">
+                        {routine.title}
+                    </span>
+                    <Badge
+                        className={
+                            routine.status === 'active'
+                                ? 'bg-emerald-100 text-emerald-700 dark:bg-emerald-900/40 dark:text-emerald-300'
+                                : 'bg-neutral-100 text-neutral-500 dark:bg-neutral-800 dark:text-neutral-400'
+                        }
+                    >
+                        {routine.status}
+                    </Badge>
+                </div>
+                {routine.description && (
+                    <p className="mt-0.5 truncate text-xs text-muted-foreground">
+                        {routine.description}
+                    </p>
+                )}
+            </div>
+
+            {routine.agent && (
+                <div className="flex shrink-0 items-center gap-1.5">
+                    <span className="flex size-5 items-center justify-center rounded-full bg-primary/10 text-[10px] font-semibold text-primary">
+                        {routine.agent.name.charAt(0).toUpperCase()}
+                    </span>
+                    <span className="truncate text-xs text-muted-foreground">
+                        {routine.agent.name}
+                    </span>
+                </div>
+            )}
+
+            <div className="flex shrink-0 flex-col items-end gap-0.5">
+                <span className="rounded bg-muted px-1.5 py-0.5 font-mono text-[10px] text-muted-foreground">
+                    {humanCron(routine.cron_expression)}
+                </span>
+                <span className="text-[10px] text-muted-foreground">
+                    {routine.timezone}
+                </span>
+            </div>
+
+            <div className="flex shrink-0 flex-col items-end gap-0.5 text-[10px] text-muted-foreground">
+                <span>Last: {formatDate(routine.last_run_at)}</span>
+                <span>Next: {formatDate(routine.next_run_at)}</span>
+            </div>
+
+            <div className="flex shrink-0 items-center gap-1">
+                <Button
+                    variant="ghost"
+                    size="sm"
+                    onClick={handleToggle}
+                    title={
+                        routine.status === 'active'
+                            ? 'Pause routine'
+                            : 'Activate routine'
+                    }
+                >
+                    {routine.status === 'active' ? (
+                        <Pause className="size-3.5" />
+                    ) : (
+                        <Play className="size-3.5" />
+                    )}
+                </Button>
+
+                {confirmDelete ? (
+                    <div className="flex items-center gap-1">
+                        <Button
+                            variant="destructive"
+                            size="sm"
+                            onClick={handleDelete}
+                        >
+                            Confirm
+                        </Button>
+                        <Button
+                            variant="ghost"
+                            size="sm"
+                            onClick={() => setConfirmDelete(false)}
+                        >
+                            Cancel
+                        </Button>
+                    </div>
+                ) : (
+                    <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={() => setConfirmDelete(true)}
+                        title="Delete routine"
+                    >
+                        <Trash2 className="size-3.5 text-red-500" />
+                    </Button>
+                )}
+            </div>
+        </div>
+    );
+}
+
+export default function RoutinesIndex({
+    routines,
+    agents,
+}: {
+    routines: Routine[];
+    agents: Agent[];
+}) {
+    const breadcrumbs: BreadcrumbItem[] = [
+        { title: 'Company', href: '/company/tasks' },
+        { title: 'Routines', href: '/company/routines' },
+    ];
+
+    return (
+        <AppLayout breadcrumbs={breadcrumbs}>
+            <Head title="Routines" />
+
+            <div className="px-4 py-6 sm:px-6">
+                <div className="flex items-center justify-between gap-4">
+                    <Heading
+                        variant="small"
+                        title="Routines"
+                        description="Schedule recurring tasks for your agents."
+                    />
+                    <CreateRoutineDialog agents={agents} />
+                </div>
+
+                {routines.length === 0 ? (
+                    <div className="mt-8 flex flex-col items-center rounded-lg border border-dashed py-16 text-center">
+                        <RefreshCw className="size-10 text-muted-foreground/40" />
+                        <p className="mt-4 text-sm text-muted-foreground">
+                            No routines yet. Create your first routine to
+                            automate recurring tasks.
+                        </p>
+                    </div>
+                ) : (
+                    <div className="mt-6 space-y-2">
+                        {routines.map((routine) => (
+                            <RoutineRow key={routine.id} routine={routine} />
+                        ))}
+                    </div>
+                )}
+            </div>
+        </AppLayout>
+    );
+}
diff --git a/resources/js/types/auth.ts b/resources/js/types/auth.ts
index a06cd9f..01bed0c 100644
--- a/resources/js/types/auth.ts
+++ b/resources/js/types/auth.ts
@@ -455,11 +455,28 @@ export type Goal = {
     parent?: Goal;
 };
 
+export type Routine = {
+    id: string;
+    team_id: string;
+    agent_id: string;
+    title: string;
+    description: string | null;
+    cron_expression: string;
+    timezone: string;
+    status: 'active' | 'paused';
+    last_run_at: string | null;
+    next_run_at: string | null;
+    agent?: Agent;
+    created_at: string;
+    updated_at: string;
+};
+
 export type GovernanceTask = {
     id: string;
     identifier: string;
     title: string;
     description: string | null;
+    routine_id?: string;
     status:
         | 'backlog'
         | 'todo'
diff --git a/routes/console.php b/routes/console.php
index 8eaa7b3..0b097af 100644
--- a/routes/console.php
+++ b/routes/console.php
@@ -2,6 +2,7 @@
 
 use App\Enums\ServerStatus;
 use App\Jobs\CheckServerHealthJob;
+use App\Jobs\ProcessRoutinesJob;
 use App\Jobs\SyncAgentStatsJob;
 use App\Models\Server;
 use App\Models\SlackConfigurationToken;
@@ -48,3 +49,5 @@
 })->hourly();
 
 Schedule::job(new SyncAgentStatsJob)->everyTwoMinutes();
+
+Schedule::job(new ProcessRoutinesJob)->everyMinute();
diff --git a/routes/web.php b/routes/web.php
index 15aceb4..5c8acb8 100644
--- a/routes/web.php
+++ b/routes/web.php
@@ -18,6 +18,7 @@
 use App\Http\Controllers\GovernanceTaskController;
 use App\Http\Controllers\OrgChartController;
 use App\Http\Controllers\ProfileSetupController;
+use App\Http\Controllers\RoutineController;
 use App\Http\Controllers\SlackConnectionController;
 use App\Http\Controllers\TeamPackController;
 use App\Http\Controllers\TelegramConnectionController;
@@ -182,6 +183,12 @@
     Route::patch('company/goals/{goal}', [GoalController::class, 'update'])->name('company.goals.update');
     Route::delete('company/goals/{goal}', [GoalController::class, 'destroy'])->name('company.goals.destroy');
 
+    Route::get('company/routines', [RoutineController::class, 'index'])->name('company.routines.index');
+    Route::post('company/routines', [RoutineController::class, 'store'])->name('company.routines.store');
+    Route::put('company/routines/{routine}', [RoutineController::class, 'update'])->name('company.routines.update');
+    Route::post('company/routines/{routine}/toggle', [RoutineController::class, 'toggle'])->name('company.routines.toggle');
+    Route::delete('company/routines/{routine}', [RoutineController::class, 'destroy'])->name('company.routines.destroy');
+
     Route::get('company/approvals', [ApprovalController::class, 'index'])->name('company.approvals.index');
     Route::get('company/approvals/{approval}', [ApprovalController::class, 'show'])->name('company.approvals.show');
     Route::post('company/approvals/{approval}/approve', [ApprovalController::class, 'approve'])->name('company.approvals.approve');
diff --git a/tests/Feature/Governance/RoutineTest.php b/tests/Feature/Governance/RoutineTest.php
new file mode 100644
index 0000000..57c5a87
--- /dev/null
+++ b/tests/Feature/Governance/RoutineTest.php
@@ -0,0 +1,224 @@
+<?php
+
+use App\Jobs\ProcessRoutinesJob;
+use App\Models\Agent;
+use App\Models\Routine;
+use App\Models\Task;
+use App\Models\User;
+use Carbon\Carbon;
+
+function routineUser(): User
+{
+    return User::factory()->withPersonalTeam()->create();
+}
+
+it('can create a routine', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+    $agent = Agent::factory()->create(['team_id' => $team->id]);
+
+    $response = $this->actingAs($user)->post(route('company.routines.store'), [
+        'title' => 'Daily standup summary',
+        'description' => 'Summarize team standup notes',
+        'agent_id' => $agent->id,
+        'cron_expression' => '0 9 * * *',
+        'timezone' => 'UTC',
+    ]);
+
+    $response->assertRedirect(route('company.routines.index'));
+
+    $this->assertDatabaseHas('routines', [
+        'team_id' => $team->id,
+        'agent_id' => $agent->id,
+        'title' => 'Daily standup summary',
+        'cron_expression' => '0 9 * * *',
+        'status' => 'active',
+    ]);
+
+    $routine = Routine::query()->where('title', 'Daily standup summary')->first();
+    expect($routine->next_run_at)->not->toBeNull();
+    expect($routine->next_run_at->isFuture())->toBeTrue();
+});
+
+it('validates cron expression', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+    $agent = Agent::factory()->create(['team_id' => $team->id]);
+
+    $response = $this->actingAs($user)->post(route('company.routines.store'), [
+        'title' => 'Bad cron routine',
+        'agent_id' => $agent->id,
+        'cron_expression' => 'not-a-valid-cron',
+        'timezone' => 'UTC',
+    ]);
+
+    // Invalid cron is stored but computeNextRun returns null, so next_run_at is null
+    $routine = Routine::query()->where('title', 'Bad cron routine')->first();
+    expect($routine)->not->toBeNull();
+    expect($routine->next_run_at)->toBeNull();
+    expect($routine->computeNextRun())->toBeNull();
+});
+
+it('validates agent belongs to team', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+
+    $otherUser = User::factory()->withPersonalTeam()->create();
+    $otherAgent = Agent::factory()->create(['team_id' => $otherUser->currentTeam->id]);
+
+    $response = $this->actingAs($user)->post(route('company.routines.store'), [
+        'title' => 'Cross-team routine',
+        'agent_id' => $otherAgent->id,
+        'cron_expression' => '0 9 * * *',
+        'timezone' => 'UTC',
+    ]);
+
+    $response->assertStatus(422);
+
+    $this->assertDatabaseMissing('routines', [
+        'title' => 'Cross-team routine',
+    ]);
+});
+
+it('can toggle routine between active and paused', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+    $routine = Routine::factory()->create([
+        'team_id' => $team->id,
+        'status' => 'active',
+        'next_run_at' => now()->addDay(),
+    ]);
+
+    // Toggle to paused
+    $response = $this->actingAs($user)->post(route('company.routines.toggle', $routine));
+
+    $response->assertRedirect(route('company.routines.index'));
+    $routine->refresh();
+    expect($routine->status)->toBe('paused');
+    expect($routine->next_run_at)->toBeNull();
+
+    // Toggle back to active
+    $response = $this->actingAs($user)->post(route('company.routines.toggle', $routine));
+
+    $routine->refresh();
+    expect($routine->status)->toBe('active');
+    expect($routine->next_run_at)->not->toBeNull();
+});
+
+it('can delete a routine', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+    $routine = Routine::factory()->create(['team_id' => $team->id]);
+
+    $response = $this->actingAs($user)->delete(route('company.routines.destroy', $routine));
+
+    $response->assertRedirect(route('company.routines.index'));
+    $this->assertDatabaseMissing('routines', ['id' => $routine->id]);
+});
+
+it('ProcessRoutinesJob creates task for due routine', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+    $agent = Agent::factory()->create(['team_id' => $team->id]);
+
+    $routine = Routine::factory()->create([
+        'team_id' => $team->id,
+        'agent_id' => $agent->id,
+        'title' => 'Due routine task',
+        'description' => 'Should become a task',
+        'status' => 'active',
+        'next_run_at' => now()->subMinute(),
+    ]);
+
+    (new ProcessRoutinesJob)->handle();
+
+    $this->assertDatabaseHas('tasks', [
+        'team_id' => $team->id,
+        'agent_id' => $agent->id,
+        'routine_id' => $routine->id,
+        'title' => 'Due routine task',
+        'status' => 'todo',
+    ]);
+});
+
+it('ProcessRoutinesJob skips paused routines', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+    $agent = Agent::factory()->create(['team_id' => $team->id]);
+
+    Routine::factory()->paused()->create([
+        'team_id' => $team->id,
+        'agent_id' => $agent->id,
+        'next_run_at' => now()->subMinute(),
+    ]);
+
+    (new ProcessRoutinesJob)->handle();
+
+    expect(Task::query()->where('team_id', $team->id)->count())->toBe(0);
+});
+
+it('ProcessRoutinesJob skips routine with existing pending task', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+    $agent = Agent::factory()->create(['team_id' => $team->id]);
+
+    $routine = Routine::factory()->create([
+        'team_id' => $team->id,
+        'agent_id' => $agent->id,
+        'status' => 'active',
+        'next_run_at' => now()->subMinute(),
+    ]);
+
+    // Create an existing pending task linked to this routine
+    Task::factory()->create([
+        'team_id' => $team->id,
+        'agent_id' => $agent->id,
+        'routine_id' => $routine->id,
+        'status' => 'todo',
+    ]);
+
+    (new ProcessRoutinesJob)->handle();
+
+    expect(Task::query()->where('routine_id', $routine->id)->count())->toBe(1);
+});
+
+it('ProcessRoutinesJob updates next_run_at after creating task', function () {
+    $user = routineUser();
+    $team = $user->currentTeam;
+    $agent = Agent::factory()->create(['team_id' => $team->id]);
+
+    $pastTime = now()->subMinute();
+
+    $routine = Routine::factory()->create([
+        'team_id' => $team->id,
+        'agent_id' => $agent->id,
+        'status' => 'active',
+        'next_run_at' => $pastTime,
+    ]);
+
+    (new ProcessRoutinesJob)->handle();
+
+    $routine->refresh();
+    expect($routine->next_run_at)->not->toBeNull();
+    expect($routine->next_run_at->isFuture())->toBeTrue();
+    expect($routine->last_run_at)->not->toBeNull();
+});
+
+it('computes next_run_at correctly', function () {
+    Carbon::setTestNow(Carbon::parse('2026-04-07 10:00:00', 'UTC'));
+
+    $routine = Routine::factory()->create([
+        'cron_expression' => '0 9 * * 1', // Monday 9am
+        'timezone' => 'UTC',
+    ]);
+
+    $nextRun = $routine->computeNextRun();
+
+    expect($nextRun)->not->toBeNull();
+    expect($nextRun->dayOfWeek)->toBe(Carbon::MONDAY);
+    expect($nextRun->hour)->toBe(9);
+    expect($nextRun->minute)->toBe(0);
+    expect($nextRun->isAfter(now()))->toBeTrue();
+
+    Carbon::setTestNow();
+});