diff --git a/apps/web/__tests__/ai-analyze-label-removal.test.ts b/apps/web/__tests__/ai-analyze-label-removal.test.ts
new file mode 100644
index 0000000000..552575cc92
--- /dev/null
+++ b/apps/web/__tests__/ai-analyze-label-removal.test.ts
@@ -0,0 +1,456 @@
+import { describe, expect, test, vi, beforeEach } from "vitest";
+import { aiAnalyzeLabelRemoval } from "@/utils/ai/label-analysis/analyze-label-removal";
+import { GroupItemType } from "@prisma/client";
+
+// Run with: pnpm test-ai ai-analyze-label-removal
+
+vi.mock("server-only", () => ({}));
+
+// Skip tests unless explicitly running AI tests
+const isAiTest = process.env.RUN_AI_TESTS === "true";
+
+describe.runIf(isAiTest)("aiAnalyzeLabelRemoval", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  function getUser() {
+    return {
+      email: "user@test.com",
+      aiModel: null,
+      aiProvider: null,
+      aiApiKey: null,
+      about: null,
+    };
+  }
+
+  function getEmailAccount(overrides = {}) {
+    return {
+      id: "test-account-id",
+      userId: "test-user-id",
+      email: "user@test.com",
+      about: null,
+      user: getUser(),
+      account: {
+        provider: "gmail",
+      },
+      ...overrides,
+    };
+  }
+
+  function getMatchedRule(overrides = {}) {
+    return {
+      systemType: "TO_REPLY",
+      instructions: "Emails that require a response",
+      labelName: "To Reply",
+      learnedPatterns: [
+        {
+          type: GroupItemType.FROM,
+          value: "colleague@company.com",
+          exclude: false,
+          reasoning: "User frequently replies to emails from colleagues",
+        },
+      ],
+      ...overrides,
+    };
+  }
+
+  function getEmail(overrides = {}) {
+    return {
+      id: "test-email-id",
+      from: "sender@example.com",
+      to: "user@test.com",
+      subject: "Test Email Subject",
+      content:
+        "This is a test email body that contains some content for analysis.",
+      date: new Date("2024-01-01T00:00:00Z"),
+      attachments: [],
+      ...overrides,
+    };
+  }
+
+  function getTestData(overrides = {}) {
+    return {
+      matchedRule: getMatchedRule(),
+      email: getEmail(),
+      emailAccount: getEmailAccount(),
+      ...overrides,
+    };
+  }
+
+  test("successfully analyzes label removal with valid input", async () => {
+    const testData = getTestData();
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+    expect(result.action).toMatch(/^(EXCLUDE|REMOVE|NO_ACTION)$/);
+
+    // If pattern exists, validate its structure
+    if (result.pattern) {
+      expect(result.pattern.type).toBeDefined();
+      expect(result.pattern.value).toBeDefined();
+      expect(result.pattern.exclude).toBeDefined();
+      expect(result.pattern.reasoning).toBeDefined();
+
+      // Log generated content for debugging as per guidelines
+      console.debug(
+        "Generated pattern:\n",
+        JSON.stringify(result.pattern, null, 2),
+      );
+    }
+  }, 15_000);
+
+  test("handles rule with no instructions", async () => {
+    const testData = getTestData({
+      matchedRule: getMatchedRule({ instructions: null }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+  }, 15_000);
+
+  test("handles email with minimal content", async () => {
+    const testData = getTestData({
+      email: getEmail({
+        from: "minimal@example.com",
+        to: "user@test.com",
+        subject: "Minimal",
+        content: "Short email",
+        date: new Date("2024-01-01T00:00:00Z"),
+      }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+  }, 15_000);
+
+  test("handles different rule types", async () => {
+    const ruleTypes = [
+      {
+        systemType: "NEWSLETTER",
+        instructions: "Newsletter subscriptions",
+        labelName: "Newsletter",
+      },
+      {
+        systemType: "FOLLOW_UP",
+        instructions: "Emails requiring follow-up action",
+        labelName: "Follow Up",
+      },
+      {
+        systemType: "IMPORTANT",
+        instructions: "High priority emails",
+        labelName: "Important",
+      },
+    ];
+
+    for (const ruleType of ruleTypes) {
+      const testData = getTestData({
+        matchedRule: getMatchedRule(ruleType),
+      });
+      const result = await aiAnalyzeLabelRemoval(testData);
+
+      expect(result.action).toBeDefined();
+    }
+  }, 30_000);
+
+  test("handles different email content types", async () => {
+    const emails = [
+      getEmail({
+        from: "newsletter@company.com",
+        subject: "Weekly Newsletter",
+        content: "This week's updates and news...",
+      }),
+      getEmail({
+        from: "support@service.com",
+        subject: "Support Request #123",
+        content: "We've received your support request and are working on it...",
+      }),
+      getEmail({
+        from: "noreply@system.com",
+        subject: "System Notification",
+        content: "Your account has been updated successfully.",
+      }),
+    ];
+
+    for (const email of emails) {
+      const testData = getTestData({ email });
+      const result = await aiAnalyzeLabelRemoval(testData);
+
+      expect(result.action).toBeDefined();
+    }
+  }, 30_000);
+
+  test("returns valid schema structure", async () => {
+    const testData = getTestData();
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    // Validate action field exists
+    expect(result.action).toBeDefined();
+    expect(result.action).toMatch(/^(EXCLUDE|REMOVE|NO_ACTION)$/);
+
+    // Validate optional pattern field if present
+    if (result.pattern) {
+      expect(Object.values(GroupItemType)).toContain(result.pattern.type);
+      expect(typeof result.pattern.value).toBe("string");
+      expect(result.pattern.value.length).toBeGreaterThan(0);
+      expect(typeof result.pattern.exclude).toBe("boolean");
+      expect(typeof result.pattern.reasoning).toBe("string");
+
+      // Log generated content for debugging as per guidelines
+      console.debug(
+        "Schema validation pattern:\n",
+        JSON.stringify(result.pattern, null, 2),
+      );
+    }
+  }, 15_000);
+
+  test("handles edge case with very long email content", async () => {
+    const testData = getTestData({
+      email: getEmail({
+        content: "A".repeat(10_000), // Very long content that might exceed limits
+      }),
+    });
+
+    try {
+      const result = await aiAnalyzeLabelRemoval(testData);
+      expect(result.action).toBeDefined();
+    } catch (error) {
+      // If the AI processing fails, we should get a meaningful error
+      expect(error).toBeDefined();
+      console.debug("Error occurred as expected:\n", error);
+    }
+  }, 15_000);
+
+  test("handles email with special characters and formatting", async () => {
+    const testData = getTestData({
+      email: getEmail({
+        subject: "Special Characters: @#$%^&*()_+{}|:<>?[]\\;'\"",
+        content:
+          "Email with special chars: @#$%^&*() and newlines\n\nAnd more content here.",
+        from: "special+chars@example-domain.com",
+      }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+  }, 15_000);
+
+  test("handles different user AI configurations", async () => {
+    const aiConfigs = [
+      { aiModel: "gpt-4", aiProvider: "openai" },
+      { aiModel: "gemini-2.0-flash", aiProvider: "google" },
+      { aiModel: null, aiProvider: null },
+    ];
+
+    for (const config of aiConfigs) {
+      const testData = getTestData({
+        emailAccount: getEmailAccount({
+          user: { ...config },
+        }),
+      });
+
+      const result = await aiAnalyzeLabelRemoval(testData);
+
+      expect(result.action).toBeDefined();
+    }
+  }, 45_000);
+
+  test("handles empty email content", async () => {
+    const testData = getTestData({
+      email: getEmail({
+        content: "",
+        subject: "",
+      }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+  }, 15_000);
+
+  test("handles null email account about field", async () => {
+    const testData = getTestData({
+      emailAccount: getEmailAccount({ about: null }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+  }, 15_000);
+
+  test("returns unchanged when no AI processing needed", async () => {
+    // Test with minimal data that might not require AI analysis
+    const testData = getTestData({
+      email: getEmail({
+        content: "",
+        subject: "",
+        from: "",
+      }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    // Should still return a valid response structure
+    expect(result.action).toBeDefined();
+
+    // Log the result to see what the AI generates
+    console.debug(
+      "AI response for minimal input:\n",
+      JSON.stringify(result, null, 2),
+    );
+  }, 15_000);
+
+  test("learns pattern when newsletter label is incorrectly applied", async () => {
+    // Test scenario: User removes "Newsletter" label from a work email
+    // This should trigger the AI to learn an exclude pattern because the initial classification was wrong
+    const testData = getTestData({
+      matchedRule: getMatchedRule({
+        systemType: "NEWSLETTER",
+        instructions: "Newsletter subscriptions and marketing emails",
+        labelName: "Newsletter",
+        learnedPatterns: [
+          {
+            type: GroupItemType.FROM,
+            value: "newsletter@techblog.com",
+            exclude: false,
+            reasoning: "User subscribed to tech blog",
+          },
+        ],
+      }),
+      email: getEmail({
+        from: "colleague@company.com",
+        subject: "Project Update - Q4 Goals",
+        content:
+          "Hi team, here's the latest update on our Q4 objectives. We need to finalize the budget proposal by Friday. Let me know if you have any questions.",
+      }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+
+    // The AI should learn that emails from @company.com with work-related subjects
+    // should not be labeled as newsletters (initial classification was wrong)
+    if (result.pattern) {
+      console.debug(
+        "Learned pattern for newsletter misclassification:\n",
+        JSON.stringify(result.pattern, null, 2),
+      );
+
+      // Should have learned an exclude pattern
+      expect(result.pattern.exclude).toBe(true);
+    }
+  }, 15_000);
+
+  test("learns pattern when to-reply label is removed after completion", async () => {
+    // Test scenario: User removes "To Reply" label after responding
+    // This might not generate a learned pattern since it's a one-off action
+    const testData = getTestData({
+      matchedRule: getMatchedRule({
+        systemType: "TO_REPLY",
+        instructions: "Emails that require a response from the user",
+        labelName: "To Reply",
+      }),
+      email: getEmail({
+        from: "client@external.com",
+        subject: "Meeting Request",
+        content:
+          "Hi, I'd like to schedule a meeting to discuss the project timeline. When would be a good time for you?",
+      }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+
+    // Log what the AI learned about this label removal
+    console.debug(
+      "AI analysis of to-reply label removal:\n",
+      JSON.stringify(result, null, 2),
+    );
+  }, 15_000);
+
+  test("does not learn pattern when newsletter label was correctly applied", async () => {
+    // Test scenario: User removes "Newsletter" label from an actual newsletter email
+    // The AI should NOT learn a pattern because the initial classification was correct
+    // and we want to be conservative about pattern learning
+    const testData = getTestData({
+      matchedRule: getMatchedRule({
+        systemType: "NEWSLETTER",
+        instructions: "Newsletter subscriptions and marketing emails",
+        labelName: "Newsletter",
+      }),
+      email: getEmail({
+        from: "newsletter@techblog.com",
+        subject: "Weekly Tech Roundup - Latest Updates",
+        content:
+          "Here's this week's roundup of the latest technology news and updates. Read our featured articles on AI developments, new software releases, and industry trends.",
+      }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+
+    // The AI should choose NO_ACTION because this is clearly a newsletter
+    // and the initial classification was correct. When in doubt, it should do nothing.
+    if (result.action === "NO_ACTION") {
+      console.debug(
+        "AI correctly chose NO_ACTION - being conservative about pattern learning:\n",
+        JSON.stringify(result, null, 2),
+      );
+      // This is the expected behavior - no pattern learning when the classification was correct
+    } else {
+      console.debug(
+        "AI chose action instead of NO_ACTION:\n",
+        JSON.stringify(result, null, 2),
+      );
+      // If the AI still chooses an action, log it for analysis but don't fail the test
+      // The prompt may need further adjustment
+    }
+
+    // We expect NO_ACTION but won't fail the test if the AI still needs prompt tuning
+    // The important thing is that the AI is being more conservative overall
+  }, 15_000);
+
+  test("learns pattern from complex email scenario", async () => {
+    // Test scenario: Complex email that might trigger pattern learning
+    // This tests when the AI should learn patterns because the initial classification was wrong
+    const testData = getTestData({
+      matchedRule: getMatchedRule({
+        systemType: "NEWSLETTER",
+        instructions: "Newsletter subscriptions and marketing emails",
+        labelName: "Newsletter",
+      }),
+      email: getEmail({
+        from: "marketing@startup.com",
+        subject: "🚀 New Product Launch - Limited Time Offer!",
+        content:
+          "Don't miss out on our revolutionary new product! Special launch pricing available only this week. Click here to learn more and get 50% off!",
+      }),
+    });
+
+    const result = await aiAnalyzeLabelRemoval(testData);
+
+    expect(result.action).toBeDefined();
+
+    // This should generate meaningful patterns since the user is removing labels
+    // from an email that clearly fits the newsletter criteria
+    // (indicating the initial classification was wrong for this specific sender)
+    if (result.pattern) {
+      console.debug(
+        "Pattern learned from complex scenario:\n",
+        JSON.stringify(result.pattern, null, 2),
+      );
+
+      // Should have learned a pattern for this type of email
+      expect(result.pattern.value.length).toBeGreaterThan(0);
+      expect(result.pattern.reasoning.length).toBeGreaterThan(10);
+    }
+  }, 15_000);
+});
diff --git a/apps/web/app/api/google/webhook/process-history-item.ts b/apps/web/app/api/google/webhook/process-history-item.ts
index 200da3f0fc..7ee7084a90 100644
--- a/apps/web/app/api/google/webhook/process-history-item.ts
+++ b/apps/web/app/api/google/webhook/process-history-item.ts
@@ -26,7 +26,7 @@ import { formatError } from "@/utils/error";
 import { createEmailProvider } from "@/utils/email/provider";
 import { enqueueDigestItem } from "@/utils/digest/index";
 import { HistoryEventType } from "@/app/api/google/webhook/types";
-import { handleLabelRemovedEvent } from "@/app/api/google/webhook/process-label-removed-event";
+import { processLabelRemoval } from "@/app/api/google/webhook/process-label-removed-event";
 
 export async function processHistoryItem(
   historyItem: {
@@ -67,7 +67,7 @@ export async function processHistoryItem(
 
   if (type === HistoryEventType.LABEL_REMOVED) {
     logger.info("Processing label removed event for learning", loggerOptions);
-    return handleLabelRemovedEvent(item, {
+    return processLabelRemoval(item, {
       emailAccount,
       provider,
     });
diff --git a/apps/web/app/api/google/webhook/process-label-removed-event.test.ts b/apps/web/app/api/google/webhook/process-label-removed-event.test.ts
index 5d695f4068..15487056f0 100644
--- a/apps/web/app/api/google/webhook/process-label-removed-event.test.ts
+++ b/apps/web/app/api/google/webhook/process-label-removed-event.test.ts
@@ -1,7 +1,7 @@
 import { vi, describe, it, expect, beforeEach } from "vitest";
 import { ColdEmailStatus } from "@prisma/client";
 import { HistoryEventType } from "./types";
-import { handleLabelRemovedEvent } from "./process-label-removed-event";
+import { processLabelRemoval } from "./process-label-removed-event";
 import type { gmail_v1 } from "@googleapis/gmail";
 import { inboxZeroLabels } from "@/utils/label";
 import { saveLearnedPatterns } from "@/utils/rule/learned-patterns";
@@ -63,6 +63,24 @@ describe("process-label-removed-event", () => {
     } as gmail_v1.Schema$HistoryLabelRemoved,
   });
 
+  const mockGmail = {
+    users: {
+      labels: {
+        list: vi.fn().mockImplementation((_params) => {
+          return Promise.resolve({
+            data: {
+              labels: [
+                { id: "label-1", name: inboxZeroLabels.cold_email.name },
+                { id: "label-2", name: "Newsletter" },
+                { id: "label-3", name: "Marketing" },
+                { id: "label-4", name: "To Reply" },
+              ],
+            },
+          });
+        }),
+      },
+    },
+  } as any;
   const mockEmailAccount = {
     id: "email-account-id",
     email: "user@test.com",
@@ -82,24 +100,18 @@ describe("process-label-removed-event", () => {
   } as any;
 
   const defaultOptions = {
+    gmail: mockGmail,
     emailAccount: mockEmailAccount,
     provider: mockProvider,
   };
 
-  describe("handleLabelRemovedEvent", () => {
+  describe("processLabelRemoval", () => {
     it("should process Cold Email label removal and update ColdEmail status", async () => {
       prisma.coldEmail.upsert.mockResolvedValue({} as any);
 
       const historyItem = createLabelRemovedHistoryItem();
 
-      console.log("Test data:", JSON.stringify(historyItem.item, null, 2));
-
-      try {
-        await handleLabelRemovedEvent(historyItem.item, defaultOptions);
-      } catch (error) {
-        console.error("Function error:", error);
-        throw error;
-      }
+      await processLabelRemoval(historyItem.item, defaultOptions);
 
       expect(prisma.coldEmail.upsert).toHaveBeenCalledWith({
         where: {
@@ -126,7 +138,7 @@ describe("process-label-removed-event", () => {
         "label-2",
       ]);
 
-      await handleLabelRemovedEvent(historyItem.item, defaultOptions);
+      await processLabelRemoval(historyItem.item, defaultOptions);
 
       expect(saveLearnedPatterns).not.toHaveBeenCalled();
     });
@@ -136,7 +148,7 @@ describe("process-label-removed-event", () => {
         "label-4",
       ]);
 
-      await handleLabelRemovedEvent(historyItem.item, defaultOptions);
+      await processLabelRemoval(historyItem.item, defaultOptions);
 
       expect(saveLearnedPatterns).not.toHaveBeenCalled();
     });
@@ -146,7 +158,7 @@ describe("process-label-removed-event", () => {
         "label-2",
       ]);
 
-      await handleLabelRemovedEvent(historyItem.item, defaultOptions);
+      await processLabelRemoval(historyItem.item, defaultOptions);
 
       expect(saveLearnedPatterns).not.toHaveBeenCalled();
     });
@@ -156,7 +168,7 @@ describe("process-label-removed-event", () => {
         "label-2",
       ]);
 
-      await handleLabelRemovedEvent(historyItem.item, defaultOptions);
+      await processLabelRemoval(historyItem.item, defaultOptions);
 
       expect(saveLearnedPatterns).not.toHaveBeenCalled();
     });
@@ -166,7 +178,7 @@ describe("process-label-removed-event", () => {
         "label-3",
       ]);
 
-      await handleLabelRemovedEvent(historyItem.item, defaultOptions);
+      await processLabelRemoval(historyItem.item, defaultOptions);
 
       expect(saveLearnedPatterns).not.toHaveBeenCalled();
     });
@@ -177,7 +189,7 @@ describe("process-label-removed-event", () => {
         labelIds: ["label-1"],
       } as gmail_v1.Schema$HistoryLabelRemoved;
 
-      await handleLabelRemovedEvent(historyItem, defaultOptions);
+      await processLabelRemoval(historyItem, defaultOptions);
 
       expect(prisma.coldEmail.upsert).not.toHaveBeenCalled();
     });
@@ -188,7 +200,7 @@ describe("process-label-removed-event", () => {
         labelIds: ["label-1"],
       } as gmail_v1.Schema$HistoryLabelRemoved;
 
-      await handleLabelRemovedEvent(historyItem, defaultOptions);
+      await processLabelRemoval(historyItem, defaultOptions);
 
       expect(prisma.coldEmail.upsert).not.toHaveBeenCalled();
     });
diff --git a/apps/web/app/api/google/webhook/process-label-removed-event.ts b/apps/web/app/api/google/webhook/process-label-removed-event.ts
index 4fddaf02b9..413481ca9b 100644
--- a/apps/web/app/api/google/webhook/process-label-removed-event.ts
+++ b/apps/web/app/api/google/webhook/process-label-removed-event.ts
@@ -1,13 +1,24 @@
 import type { gmail_v1 } from "@googleapis/gmail";
 import prisma from "@/utils/prisma";
-
-import { ColdEmailStatus } from "@prisma/client";
-import { logger } from "@/app/api/google/webhook/logger";
+import { ActionType, ColdEmailStatus } from "@prisma/client";
+import type { GroupItem } from "@prisma/client";
+import { createScopedLogger } from "@/utils/logger";
 import { extractEmailAddress } from "@/utils/email";
 import type { EmailAccountWithAI } from "@/utils/llms/types";
 import type { EmailProvider } from "@/utils/email/types";
+import type { ParsedMessage } from "@/utils/types";
+import { getEmailForLLM } from "@/utils/get-email-from-message";
 import { inboxZeroLabels } from "@/utils/label";
 import { GmailLabel } from "@/utils/gmail/label";
+import { aiAnalyzeLabelRemoval } from "@/utils/ai/label-analysis/analyze-label-removal";
+
+import {
+  saveLearnedPatterns,
+  removeLearnedPattern,
+} from "@/utils/rule/learned-patterns";
+import type { LabelRemovalAnalysis } from "@/utils/ai/label-analysis/analyze-label-removal";
+
+const logger = createScopedLogger("webhook-label-removal");
 
 const SYSTEM_LABELS = [
   GmailLabel.INBOX,
@@ -20,7 +31,122 @@ const SYSTEM_LABELS = [
   GmailLabel.UNREAD,
 ];
 
-export async function handleLabelRemovedEvent(
+async function findMatchingRuleWithLearnPatterns(
+  emailAccountId: string,
+  labelNames: string[],
+): Promise<{
+  systemType: string;
+  instructions: string | null;
+  ruleName: string;
+  labelName: string;
+  learnedPatterns: Pick<
+    GroupItem,
+    "type" | "value" | "exclude" | "reasoning"
+  >[];
+} | null> {
+  const systemTypeData = await getSystemRuleLabels(emailAccountId);
+
+  for (const [systemType, data] of systemTypeData) {
+    for (const labelName of labelNames) {
+      if (data.labels.includes(labelName)) {
+        const learnedPatterns = await getLearnedPatternsForRule(
+          emailAccountId,
+          data.ruleName,
+        );
+        return {
+          systemType,
+          instructions: data.instructions,
+          ruleName: data.ruleName,
+          labelName,
+          learnedPatterns,
+        };
+      }
+    }
+  }
+  return null;
+}
+
+async function getLearnedPatternsForRule(
+  emailAccountId: string,
+  ruleName: string,
+): Promise<Pick<GroupItem, "type" | "value" | "exclude" | "reasoning">[]> {
+  const rule = await prisma.rule.findFirst({
+    where: {
+      emailAccountId,
+      name: ruleName,
+    },
+    select: {
+      group: {
+        select: {
+          items: {
+            select: {
+              type: true,
+              value: true,
+              exclude: true,
+              reasoning: true,
+            },
+          },
+        },
+      },
+    },
+  });
+
+  return rule?.group?.items || [];
+}
+
+export async function getSystemRuleLabels(
+  emailAccountId: string,
+): Promise<
+  Map<
+    string,
+    { labels: string[]; instructions: string | null; ruleName: string }
+  >
+> {
+  const actions = await prisma.action.findMany({
+    where: {
+      type: ActionType.LABEL,
+      rule: {
+        emailAccountId,
+        systemType: {
+          not: null,
+        },
+      },
+    },
+    select: {
+      label: true,
+      rule: {
+        select: {
+          name: true,
+          systemType: true,
+          instructions: true,
+        },
+      },
+    },
+  });
+
+  const systemTypeData = new Map<
+    string,
+    { labels: string[]; instructions: string | null; ruleName: string }
+  >();
+
+  for (const action of actions) {
+    if (action.label && action.rule?.systemType && action.rule?.name) {
+      const systemType = action.rule.systemType;
+      if (!systemTypeData.has(systemType)) {
+        systemTypeData.set(systemType, {
+          labels: [],
+          instructions: action.rule.instructions,
+          ruleName: action.rule.name,
+        });
+      }
+      systemTypeData.get(systemType)!.labels.push(action.label);
+    }
+  }
+
+  return systemTypeData;
+}
+
+export async function processLabelRemoval(
   message: gmail_v1.Schema$HistoryLabelRemoved,
   {
     emailAccount,
@@ -35,106 +161,88 @@ export async function handleLabelRemovedEvent(
   const emailAccountId = emailAccount.id;
   const userEmail = emailAccount.email;
 
-  const loggerOptions = {
-    email: userEmail,
-    messageId,
-    threadId,
-  };
-
   if (!messageId || !threadId) {
-    logger.warn(
-      "Skipping label removal - missing messageId or threadId",
-      loggerOptions,
-    );
+    logger.warn("Skipping label removal - missing messageId or threadId", {
+      email: userEmail,
+      messageId,
+      threadId,
+    });
     return;
   }
 
-  logger.info("Processing label removal for learning", loggerOptions);
-
-  let sender: string | null = null;
+  logger.info("Processing label removal for learning", {
+    email: userEmail,
+    messageId,
+    threadId,
+  });
 
   try {
     const parsedMessage = await provider.getMessage(messageId);
-    sender = extractEmailAddress(parsedMessage.headers.from);
-  } catch (error) {
-    logger.error("Error getting sender for label removal", {
-      error,
-      ...loggerOptions,
-    });
-  }
 
-  const removedLabelIds = message.labelIds || [];
+    const removedLabelIds = message.labelIds || [];
 
-  const labels = await provider.getLabels();
+    const labels = await provider.getLabels();
 
-  for (const labelId of removedLabelIds) {
-    const label = labels?.find((l) => l.id === labelId);
-    const labelName = label?.name;
+    const removedLabelNames = removedLabelIds
+      .map((labelId: string) => {
+        const label = labels.find((l) => l.id === labelId);
+        return label?.name;
+      })
+      .filter(
+        (labelName: string | null | undefined): labelName is string =>
+          !!labelName && !SYSTEM_LABELS.includes(labelName),
+      );
 
-    if (!labelName) {
-      logger.info("Skipping label removal - missing label name", {
-        labelId,
-        ...loggerOptions,
-      });
-      continue;
-    }
-
-    if (SYSTEM_LABELS.includes(labelName)) {
-      logger.info("Skipping system label removal", {
-        labelName,
-        ...loggerOptions,
-      });
-      continue;
-    }
-
-    try {
-      await learnFromRemovedLabel({
-        labelName,
-        sender,
-        messageId,
-        threadId,
-        emailAccountId,
-      });
-    } catch (error) {
-      logger.error("Error learning from label removal", {
-        error,
-        labelName,
-        removedLabelIds,
-        ...loggerOptions,
-      });
-    }
+    await analyseLabelRemoval({
+      labelNames: removedLabelNames,
+      messageId,
+      threadId,
+      emailAccountId,
+      parsedMessage,
+      emailAccount,
+    });
+  } catch (error) {
+    logger.error("Error processing label removal", {
+      error,
+      email: userEmail,
+      messageId,
+      threadId,
+    });
   }
 }
 
-async function learnFromRemovedLabel({
-  labelName,
-  sender,
+async function analyseLabelRemoval({
+  labelNames,
   messageId,
   threadId,
   emailAccountId,
+  parsedMessage,
+  emailAccount,
 }: {
-  labelName: string;
-  sender: string | null;
+  labelNames: string[];
   messageId: string;
   threadId: string;
   emailAccountId: string;
+  parsedMessage: ParsedMessage;
+  emailAccount: EmailAccountWithAI;
 }) {
-  const loggerOptions = {
-    emailAccountId,
-    messageId,
-    threadId,
-    labelName,
-    sender,
-  };
+  const sender = extractEmailAddress(parsedMessage.headers.from);
 
   // Can't learn patterns without knowing who to exclude
   if (!sender) {
-    logger.info("No sender found, skipping learning", loggerOptions);
+    logger.info("No sender found, skipping learning", {
+      emailAccountId,
+      messageId,
+      labelNames,
+    });
     return;
   }
 
-  if (labelName === inboxZeroLabels.cold_email.name) {
-    logger.info("Processing Cold Email label removal", loggerOptions);
+  if (labelNames.includes(inboxZeroLabels.cold_email.name)) {
+    logger.info("Processing Cold Email label removal", {
+      emailAccountId,
+      messageId,
+    });
 
     await prisma.coldEmail.upsert({
       where: {
@@ -157,4 +265,121 @@ async function learnFromRemovedLabel({
 
     return;
   }
+
+  const matchedRule = await findMatchingRuleWithLearnPatterns(
+    emailAccountId,
+    labelNames,
+  );
+
+  if (!matchedRule) {
+    logger.info(
+      "No system rules found for label removal, skipping AI analysis",
+      { emailAccountId, matchedRule },
+    );
+    return;
+  }
+
+  logger.info("Processing system rule label removal with AI analysis", {
+    emailAccountId,
+    messageId,
+  });
+
+  try {
+    const analysis = await aiAnalyzeLabelRemoval({
+      matchedRule,
+      email: getEmailForLLM(parsedMessage),
+      emailAccount,
+    });
+
+    await processLabelRemovalAnalysis({
+      analysis,
+      emailAccountId,
+      matchedRule,
+    });
+  } catch (error) {
+    logger.error("Error analyzing label removal with AI", {
+      emailAccountId,
+      error,
+    });
+  }
+}
+
+export async function processLabelRemovalAnalysis({
+  analysis,
+  emailAccountId,
+  matchedRule,
+}: {
+  analysis: LabelRemovalAnalysis;
+  emailAccountId: string;
+  matchedRule: {
+    systemType: string;
+    instructions: string | null;
+    ruleName: string;
+    labelName: string;
+  };
+}): Promise<void> {
+  if (analysis.action === "NO_ACTION") {
+    logger.info("No action needed for this label removal", {
+      emailAccountId,
+      matchedRule,
+    });
+    return;
+  }
+
+  if (analysis.action === "REMOVE" && analysis.pattern) {
+    logger.info("Removing learned pattern from rule", {
+      emailAccountId,
+      ruleName: matchedRule.ruleName,
+      patternType: analysis.pattern.type,
+      patternValue: analysis.pattern.value,
+    });
+
+    const result = await removeLearnedPattern({
+      emailAccountId,
+      ruleName: matchedRule.ruleName,
+      pattern: {
+        type: analysis.pattern.type,
+        value: analysis.pattern.value,
+      },
+    });
+
+    if (result.error) {
+      logger.error("Failed to remove learned pattern", {
+        emailAccountId,
+        ruleName: matchedRule.ruleName,
+        error: result.error,
+      });
+    } else {
+      logger.info("Successfully removed learned pattern", {
+        emailAccountId,
+        ruleName: matchedRule.ruleName,
+        patternType: analysis.pattern.type,
+        patternValue: analysis.pattern.value,
+      });
+    }
+    return;
+  }
+
+  if (analysis.action === "EXCLUDE" && analysis.pattern) {
+    const patternToSave = {
+      type: analysis.pattern.type,
+      value: analysis.pattern.value,
+      exclude: analysis.pattern.exclude,
+      reasoning: analysis.pattern.reasoning,
+    };
+
+    logger.info("Adding learned pattern to rule", {
+      emailAccountId,
+      ruleName: matchedRule.ruleName,
+      patternType: patternToSave.type,
+      patternValue: patternToSave.value,
+      exclude: patternToSave.exclude,
+    });
+
+    await saveLearnedPatterns({
+      emailAccountId,
+      ruleName: matchedRule.ruleName,
+      patterns: [patternToSave],
+    });
+  }
 }
diff --git a/apps/web/prisma/migrations/20250819203156_add_reasoning_to_group_item/migration.sql b/apps/web/prisma/migrations/20250819203156_add_reasoning_to_group_item/migration.sql
new file mode 100644
index 0000000000..ac3da2dfac
--- /dev/null
+++ b/apps/web/prisma/migrations/20250819203156_add_reasoning_to_group_item/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "GroupItem" ADD COLUMN     "reasoning" TEXT;
diff --git a/apps/web/prisma/schema.prisma b/apps/web/prisma/schema.prisma
index 3819cec54a..8aa9d439c0 100644
--- a/apps/web/prisma/schema.prisma
+++ b/apps/web/prisma/schema.prisma
@@ -504,6 +504,7 @@ model GroupItem {
   type      GroupItemType
   value     String // eg "@gmail.com", "matt@gmail.com", "Receipt from"
   exclude   Boolean       @default(false) // Whether this pattern should be excluded rather than included
+  reasoning String?       // Reasoning for why this pattern was learned if added by AI
 
   @@unique([groupId, type, value])
 }
diff --git a/apps/web/utils/ai/label-analysis/analyze-label-removal.ts b/apps/web/utils/ai/label-analysis/analyze-label-removal.ts
new file mode 100644
index 0000000000..d735dff3e0
--- /dev/null
+++ b/apps/web/utils/ai/label-analysis/analyze-label-removal.ts
@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { createGenerateObject } from "@/utils/llms";
+import { getModel } from "@/utils/llms/model";
+import type { EmailAccountWithAI } from "@/utils/llms/types";
+import type { EmailForLLM } from "@/utils/types";
+import { stringifyEmail } from "@/utils/stringify-email";
+import { type GroupItem, GroupItemType } from "@prisma/client";
+
+const schema = z.object({
+  action: z
+    .enum(["EXCLUDE", "REMOVE", "NO_ACTION"])
+    .describe(
+      "The action to take, EXCLUDE to add an exclude learned pattern, REMOVE to remove an existing pattern, NO_ACTION if nothing should be done",
+    ),
+  pattern: z
+    .object({
+      reasoning: z
+        .string()
+        .describe(
+          "A short human-readable explanation of why this learned pattern is important to learn",
+        ),
+      type: z
+        .nativeEnum(GroupItemType)
+        .describe(
+          "The pattern type which can be FROM (sender/domain), SUBJECT (sender/domain/subject keyword), or BODY (content)",
+        ),
+      value: z
+        .string()
+        .describe(
+          "The specific value for the learned pattern (e.g., email address, domain, subject keyword)",
+        ),
+      exclude: z
+        .boolean()
+        .describe(
+          "Whether this learned pattern should be excluded (true) or just not included (false)",
+        ),
+    })
+    .nullish()
+    .describe(
+      "The pattern to learn from or remove based on this label removal",
+    ),
+});
+
+export type LabelRemovalAnalysis = z.infer<typeof schema>;
+
+export async function aiAnalyzeLabelRemoval({
+  matchedRule,
+  email,
+  emailAccount,
+}: {
+  matchedRule: {
+    systemType: string;
+    instructions: string | null;
+    labelName: string;
+    learnedPatterns: Pick<
+      GroupItem,
+      "type" | "value" | "exclude" | "reasoning"
+    >[];
+  };
+  email: EmailForLLM;
+  emailAccount: EmailAccountWithAI;
+}): Promise<LabelRemovalAnalysis> {
+  const system = `You are an email expert managing a user's inbox. Focus only on label removals.
+
+What are Rules?
+- Define conditions (static or AI) and actions (labels, archive, forward, etc.).
+
+What are Learned Patterns?
+- Discovered from repeated user behavior.  
+- Can *include* (always apply) or *exclude* (always skip).  
+- Override rules when consistent patterns emerge.  
+
+Given:  
+- The email
+- The rule and learned patterns that matched
+- The label removed by the user
+
+Decide if a learned pattern adjustment is needed:  
+1. If match came from a learned pattern → should it be removed or converted to EXCLUDE?  
+2. If match came from an AI instruction → should an EXCLUDE pattern be added?  
+3. If match came from a static condition → do nothing.  
+
+Guidelines
+- Prefer NO_ACTIONif label removal seems like a mistake or if unsure about pattern inference.  
+- Use EXCLUDE only with clear evidence the label is unwanted.
+- Use REMOVE only when certain a learned pattern is wrong.
+- Always provide reasoning.
+- Not every label removal requires a new pattern.
+`;
+
+  const prompt = `The rule:
+
+<rule>
+  <system_type>${matchedRule.systemType}</system_type>
+  <label>${matchedRule.labelName}</label>
+  <instructions>${matchedRule.instructions || "No instructions provided"}</instructions>
+  <learned_patterns>
+    ${matchedRule.learnedPatterns.map((pattern) => `<pattern_type>${pattern.type}</pattern_type><pattern_value>${pattern.value}</pattern_value><pattern_exclude>${pattern.exclude}</pattern_exclude><pattern_reasoning>${pattern.reasoning || "User provided"}</pattern_reasoning>`).join("\n")}
+  </learned_patterns>
+</rule>
+
+The email:
+<email>
+${stringifyEmail(email, 1000)}
+</email>
+
+The label:
+<label>
+${matchedRule.labelName}
+</label>`;
+
+  const modelOptions = getModel(emailAccount.user);
+
+  const generateObject = createGenerateObject({
+    userEmail: emailAccount.email,
+    label: "label-removal-analysis",
+    modelOptions,
+  });
+
+  const aiResponse = await generateObject({
+    ...modelOptions,
+    system,
+    prompt,
+    schema,
+  });
+
+  return aiResponse.object;
+}
diff --git a/apps/web/utils/auth.ts b/apps/web/utils/auth.ts
index b357fb5d4f..340d6db91d 100644
--- a/apps/web/utils/auth.ts
+++ b/apps/web/utils/auth.ts
@@ -41,8 +41,6 @@ export const betterAuthConfig = betterAuth({
       }
     },
   },
-  baseURL: env.NEXT_PUBLIC_BASE_URL,
-  trustedOrigins: [env.NEXT_PUBLIC_BASE_URL],
   secret: env.AUTH_SECRET || env.NEXTAUTH_SECRET,
   emailAndPassword: {
     enabled: false,
diff --git a/apps/web/utils/rule/learned-patterns.ts b/apps/web/utils/rule/learned-patterns.ts
index cbb78a7718..762d2b1b0f 100644
--- a/apps/web/utils/rule/learned-patterns.ts
+++ b/apps/web/utils/rule/learned-patterns.ts
@@ -14,10 +14,12 @@ export async function saveLearnedPattern({
   emailAccountId,
   from,
   ruleName,
+  reasoning,
 }: {
   emailAccountId: string;
   from: string;
   ruleName: string;
+  reasoning?: string;
 }) {
   const rule = await prisma.rule.findUnique({
     where: {
@@ -62,6 +64,7 @@ export async function saveLearnedPattern({
       groupId,
       type: GroupItemType.FROM,
       value: from,
+      reasoning,
     },
   });
 }
@@ -81,6 +84,7 @@ export async function saveLearnedPatterns({
     type: GroupItemType;
     value: string;
     exclude?: boolean;
+    reasoning?: string;
   }>;
 }) {
   const rule = await prisma.rule.findUnique({
@@ -146,12 +150,14 @@ export async function saveLearnedPatterns({
         },
         update: {
           exclude: pattern.exclude || false,
+          reasoning: pattern.reasoning,
         },
         create: {
           groupId,
           type: pattern.type,
           value: pattern.value,
           exclude: pattern.exclude || false,
+          reasoning: pattern.reasoning,
         },
       });
     } catch (error) {
@@ -173,3 +179,64 @@ export async function saveLearnedPatterns({
 
   return { success: true };
 }
+
+/**
+ * Removes a learned pattern for a rule
+ */
+export async function removeLearnedPattern({
+  emailAccountId,
+  ruleName,
+  pattern,
+}: {
+  emailAccountId: string;
+  ruleName: string;
+  pattern: {
+    type: GroupItemType;
+    value: string;
+  };
+}) {
+  const rule = await prisma.rule.findUnique({
+    where: {
+      name_emailAccountId: {
+        name: ruleName,
+        emailAccountId,
+      },
+    },
+    select: { id: true, groupId: true },
+  });
+
+  if (!rule || !rule.groupId) {
+    logger.error("Rule or group not found", { emailAccountId, rule });
+    return { error: "Rule or group not found" };
+  }
+
+  try {
+    const deletedItem = await prisma.groupItem.delete({
+      where: {
+        groupId_type_value: {
+          groupId: rule.groupId,
+          type: pattern.type,
+          value: pattern.value,
+        },
+      },
+    });
+
+    logger.info("Successfully removed learned pattern", {
+      emailAccountId,
+      ruleName,
+      patternType: pattern.type,
+      patternValue: pattern.value,
+    });
+
+    return { success: true, deletedItem };
+  } catch (error) {
+    logger.error("Error removing learned pattern", {
+      error,
+      emailAccountId,
+      ruleName,
+      patternType: pattern.type,
+      patternValue: pattern.value,
+    });
+    return { error: "Failed to remove pattern" };
+  }
+}