diff --git a/.capy_commit_msg b/.capy_commit_msg
new file mode 100644
index 00000000..a0a980c7
--- /dev/null
+++ b/.capy_commit_msg
@@ -0,0 +1 @@
+Capy jam: Unify pricing to Free and Pro (0/mo); wire Autumn checkout/portal; consolidate Autumn wrapper; reduce Convex writes on home; default sequential thinking to Kimi K2; update env example
diff --git a/.env.example b/.env.example
index 76232cd4..da17254d 100644
--- a/.env.example
+++ b/.env.example
@@ -23,6 +23,8 @@ GROQ_API_KEY=your_groq_api_key_here
 # Get yours at https://dashboard.stripe.com/apikeys
 NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_your_stripe_publishable_key_here
 STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key_here
+# Stripe Pro price ID (fallback when Autumn isn't configured)
+NEXT_PUBLIC_STRIPE_PRO_PRICE_ID=price_your_pro_monthly_price_id
 
 # Stripe Webhook Secret (get from Stripe Dashboard > Webhooks)
 STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret_here
diff --git a/AutumnWrapper.tsx b/AutumnWrapper.tsx
index 0f8e6828..71db4d48 100644
--- a/AutumnWrapper.tsx
+++ b/AutumnWrapper.tsx
@@ -1,14 +1,2 @@
 "use client";
-import { AutumnProvider } from "autumn-js/react";
-import { api } from "./convex/_generated/api";
-import { useConvex } from "convex/react";
-
-export function AutumnWrapper({ children }: { children: React.ReactNode }) {
-  const convex = useConvex();
-
-  return (
-    <AutumnProvider convex={convex} convexApi={(api as any).autumn}>
-      {children}
-    </AutumnProvider>
-  );
-}
\ No newline at end of file
+export { AutumnWrapper } from "./app/components/AutumnWrapper";
diff --git a/app/api/autumn/billing-portal/route.ts b/app/api/autumn/billing-portal/route.ts
new file mode 100644
index 00000000..c1416906
--- /dev/null
+++ b/app/api/autumn/billing-portal/route.ts
@@ -0,0 +1,45 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuth } from '@clerk/nextjs/server';
+import { autumn } from '@/convex/autumn';
+
+export async function POST(request: NextRequest) {
+  try {
+    const auth = getAuth(request);
+    if (!auth.userId) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const { returnUrl } = await request.json().catch(() => ({ returnUrl: undefined }));
+    const origin = request.headers.get('origin') || process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000';
+
+    if (process.env.AUTUMN_SECRET_KEY) {
+      try {
+        const mockCtx = { auth: { getUserIdentity: () => ({ subject: auth.userId, name: '', email: '' }) } } as any;
+        const result: any = await autumn.billingPortal(mockCtx, { returnUrl: returnUrl || `${origin}/pricing` });
+        const url = result?.url || result?.portalUrl || result?.redirectUrl;
+        if (url) {
+          return NextResponse.json({ url });
+        }
+      } catch (e) {
+        // fall through to Stripe
+      }
+    }
+
+    // Fallback to Stripe portal
+    const stripeRes = await fetch(`${origin}/api/stripe/customer-portal`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ returnUrl: returnUrl || `${origin}/pricing` })
+    });
+
+    if (!stripeRes.ok) {
+      const err = await stripeRes.text();
+      return NextResponse.json({ error: err || 'Failed to create portal session' }, { status: 500 });
+    }
+
+    const data = await stripeRes.json();
+    return NextResponse.json({ url: data.url });
+  } catch (error) {
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}
diff --git a/app/api/autumn/checkout/route.ts b/app/api/autumn/checkout/route.ts
new file mode 100644
index 00000000..78af7151
--- /dev/null
+++ b/app/api/autumn/checkout/route.ts
@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuth } from '@clerk/nextjs/server';
+import { autumn } from '@/convex/autumn';
+
+export async function POST(request: NextRequest) {
+  try {
+    const auth = getAuth(request);
+    if (!auth.userId) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const { priceId } = await request.json().catch(() => ({ priceId: undefined }));
+
+    const mockCtx = { auth: { getUserIdentity: () => ({ subject: auth.userId, name: '', email: '' }) } } as any;
+
+    if (process.env.AUTUMN_SECRET_KEY) {
+      try {
+        const result: any = await autumn.checkout(mockCtx, { priceId });
+        const url = result?.url || result?.sessionUrl || result?.redirectUrl;
+        if (url) {
+          return NextResponse.json({ url });
+        }
+      } catch (e) {
+        // fall through to Stripe
+      }
+    }
+
+    // Fallback to Stripe
+    const origin = request.headers.get('origin') || process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000';
+    const stripeRes = await fetch(`${origin}/api/stripe/create-checkout-session`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        priceId: priceId || process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID,
+        mode: 'subscription'
+      })
+    });
+
+    if (!stripeRes.ok) {
+      const err = await stripeRes.text();
+      return NextResponse.json({ error: err || 'Failed to create checkout session' }, { status: 500 });
+    }
+
+    const { sessionId } = await stripeRes.json();
+    return NextResponse.json({ provider: 'stripe', sessionId });
+  } catch (error) {
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}
diff --git a/app/components/AutumnFallback.tsx b/app/components/AutumnFallback.tsx
index 6ea993eb..c8b07ac0 100644
--- a/app/components/AutumnFallback.tsx
+++ b/app/components/AutumnFallback.tsx
@@ -2,13 +2,10 @@
 // This file provides working alternatives when autumn-js/react is not available
 
 import React, { createContext, useContext, useState, useEffect } from 'react';
-import Link from 'next/link';
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
-import { Check, Sparkles, Crown } from "lucide-react";
-import CheckoutButton from "@/components/stripe/CheckoutButton";
+import { CheckCircle } from "lucide-react";
 
-// Types
 interface Customer {
   id: string;
   email: string;
@@ -27,7 +24,6 @@ interface UsageLimit {
   resetAt?: Date;
 }
 
-// Mock context
 const AutumnContext = createContext<{
   customer: Customer | null;
   isLoading: boolean;
@@ -38,13 +34,11 @@ const AutumnContext = createContext<{
   error: null
 });
 
-// Mock provider
 export const AutumnProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
   const [customer, setCustomer] = useState<Customer | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
-  // Mock loading customer data
   useEffect(() => {
     setIsLoading(true);
     setTimeout(() => {
@@ -69,7 +63,6 @@ export const AutumnProvider: React.FC<{ children: React.ReactNode }> = ({ childr
   );
 };
 
-// Mock hook for customer data
 export const useCustomer = () => {
   const context = useContext(AutumnContext);
   return {
@@ -81,92 +74,68 @@ export const useCustomer = () => {
 
 // Mock pricing table component (two-tier)
 export const PricingTable: React.FC = () => {
-  const proPriceId = process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID || 'price_pro_monthly';
-
   const plans = [
     {
       id: 'free',
       name: 'Free',
       price: '$0',
-      subtext: 'No credit card required',
-      description: 'Everything you need to get started.',
-      features: ['Up to 5 chats', 'Basic templates', 'Standard sandbox time', 'Community support'],
-      buttonText: 'Get started',
-      popular: false,
-      icon: Sparkles,
+      period: 'forever',
+      description: 'Perfect for getting started',
+      features: ['5 chats', '1 sandbox', 'Basic models'],
+      buttonText: 'Get Started',
+      popular: false
     },
     {
       id: 'pro',
       name: 'Pro',
       price: '$20',
-      subtext: 'per month, cancel anytime',
-      description: 'Build without limits with advanced AI.',
-      features: ['Unlimited chats', 'Advanced AI models', 'Extended sandbox time', 'Priority support'],
+      period: 'per month',
+      description: 'For builders who want more',
+      features: ['Unlimited chats', 'Advanced models'],
       buttonText: 'Upgrade to Pro',
-      popular: true,
-      icon: Crown,
-    },
+      popular: true
+    }
   ];
 
   return (
-    <div className="grid grid-cols-1 md:grid-cols-2 gap-8">
-      {plans.map((plan) => {
-        const Icon = plan.icon;
-        const isFree = plan.id === 'free';
-        return (
-          <Card
-            key={plan.id}
-            className={`relative transition hover:shadow-md hover:scale-[1.01] ${plan.popular ? 'ring-1 ring-primary/20' : ''}`}
-          >
-            {plan.popular && (
-              <div className="absolute top-3 right-3">
-                <span className="bg-primary/10 text-primary text-xs font-bold px-2 py-0.5 rounded-full">
-                  Most popular
-                </span>
-              </div>
-            )}
-            <CardHeader>
-              <div className="flex items-center gap-3">
-                <div className="rounded-md bg-primary/10 p-2">
-                  <Icon className="h-6 w-6 text-primary" aria-hidden="true" />
-                </div>
-                <div>
-                  <CardTitle className="text-2xl">{plan.name}</CardTitle>
-                  <CardDescription>{plan.description}</CardDescription>
-                </div>
-              </div>
-              <div className="mt-4 flex items-baseline gap-2">
-                <span className="text-4xl font-bold">{plan.price}</span>
-                <span className="text-sm text-muted-foreground">{plan.subtext}</span>
-              </div>
-            </CardHeader>
-            <CardContent>
-              <ul className="space-y-3 mb-6" role="list">
-                {plan.features.map((feature, index) => (
-                  <li key={index} className="flex items-start">
-                    <Check className="h-5 w-5 text-green-600 dark:text-green-500 mr-3 mt-0.5" aria-hidden="true" />
-                    <span>{feature}</span>
-                  </li>
-                ))}
-              </ul>
-              {isFree ? (
-                <Link href="/sign-in" className="block w-full" aria-label="Get started with Free">
-                  <Button variant="outline" className="w-full">{plan.buttonText}</Button>
-                </Link>
-              ) : (
-                <CheckoutButton priceId={proPriceId} mode="subscription" variant="orange" size="lg" className="w-full">
-                  {plan.buttonText}
-                </CheckoutButton>
-              )}
-            </CardContent>
-          </Card>
-        );
-      })}
+    <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
+      {plans.map((plan) => (
+        <Card
+          key={plan.id}
+          className={`relative ${plan.popular ? 'border-blue-500 ring-2 ring-blue-500' : ''}`}
+        >
+          {plan.popular && (
+            <div className="absolute top-0 left-1/2 transform -translate-x-1/2 -translate-y-1/2 bg-blue-500 text-white text-xs font-bold px-3 py-1 rounded-full">
+              MOST POPULAR
+            </div>
+          )}
+          <CardHeader>
+            <CardTitle className="text-2xl">{plan.name}</CardTitle>
+            <div className="flex items-baseline">
+              <span className="text-4xl font-bold">{plan.price}</span>
+              {plan.period && <span className="text-gray-500 ml-1">{plan.period}</span>}
+            </div>
+            <CardDescription>{plan.description}</CardDescription>
+          </CardHeader>
+          <CardContent>
+            <ul className="space-y-3 mb-6">
+              {plan.features.map((feature, index) => (
+                <li key={index} className="flex items-center">
+                  <CheckCircle className="h-5 w-5 text-green-500 mr-2" />
+                  <span>{feature}</span>
+                </li>
+              ))}
+            </ul>
+            <Button className="w-full" variant={plan.popular ? 'default' : 'outline'}>
+              {plan.buttonText}
+            </Button>
+          </CardContent>
+        </Card>
+      ))}
     </div>
   );
 };
 
-// Mock usage limit hook
 export const useUsageLimits = (featureId: string) => {
   const [limits, setLimits] = useState<UsageLimit | null>(null);
   const [isLoading, setIsLoading] = useState(false);
@@ -189,4 +158,4 @@ export const useUsageLimits = (featureId: string) => {
     mutate: () => {},
     isValidating: false
   };
-};
+};
\ No newline at end of file
diff --git a/app/page.tsx b/app/page.tsx
index ca859a95..b3c7cd04 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -493,36 +493,7 @@ Tip: I automatically detect and install npm packages from your code imports (lik
             iframeRef.current.src = data.url;
           }
         }, 100);
-        
-        // Capture screenshot for chat preview after sandbox is ready and update Convex
-        if (currentChatId && isSignedIn) {
-          setTimeout(async () => {
-            try {
-              console.log('[createSandbox] Capturing screenshot for chat preview...');
-              const screenshotResponse = await fetch('/api/scrape-screenshot', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ url: data.url })
-              });
-              
-              const screenshotData = await screenshotResponse.json();
-              if (screenshotData.success && screenshotData.screenshot) {
-                console.log('[createSandbox] Screenshot captured, updating chat...');
-                await updateChatScreenshot({
-                  chatId: currentChatId,
-                  screenshot: screenshotData.screenshot,
-                  sandboxId: data.sandboxId,
-                  sandboxUrl: data.url
-                });
-                console.log('[createSandbox] Chat updated with screenshot');
-              } else {
-                console.warn('[createSandbox] Failed to capture screenshot:', screenshotData.error);
-              }
-            } catch (error) {
-              console.error('[createSandbox] Error capturing screenshot:', error);
-            }
-          }, 3000); // Wait 3 seconds for the sandbox to fully load
-        }
+
       } else {
         throw new Error(data.error || 'Unknown error');
       }
@@ -1127,6 +1098,29 @@ Tip: I automatically detect and install npm packages from your code imports (lik
     }
   };
 
+  const savePreview = async () => {
+    try {
+      if (!sandboxData?.url || !currentChatId) return;
+      const screenshotResponse = await fetch('/api/scrape-screenshot', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ url: sandboxData.url })
+      });
+      const screenshotData = await screenshotResponse.json();
+      if (screenshotData.success && screenshotData.screenshot) {
+        await updateChatScreenshot({
+          chatId: currentChatId,
+          screenshot: screenshotData.screenshot,
+          sandboxId: sandboxData.sandboxId,
+          sandboxUrl: sandboxData.url
+        });
+        addChatMessage('Preview saved to chat.', 'system');
+      }
+    } catch (e) {
+      addChatMessage('Failed to save preview.', 'system');
+    }
+  };
+
   const applyCode = async () => {
     const code = promptInput.trim();
     if (!code) {
@@ -1669,6 +1663,16 @@ Tip: I automatically detect and install npm packages from your code imports (lik
               allow="clipboard-write"
               sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-modals"
             />
+            {/* Save preview button */}
+            {currentChatId && (
+              <button
+                onClick={savePreview}
+                className="absolute bottom-4 right-28 bg-white/90 hover:bg-white text-gray-700 px-3 py-2 rounded-lg shadow-lg transition-all duration-200 hover:scale-105"
+                title="Save preview to chat"
+              >
+                Save preview
+              </button>
+            )}
             {/* Refresh button */}
             <button
               onClick={() => {
@@ -1803,24 +1807,8 @@ Tip: I automatically detect and install npm packages from your code imports (lik
       await createSandbox(true); // Pass true to indicate this is from message, not home screen
     }
     
-    // Create or get current chat for this conversation
+    // Create or get current chat for this conversation (no auto-creation)
     let chatId = currentChatId;
-    if (!chatId && isSignedIn) {
-      try {
-        // Generate chat title from first message (truncated to 50 chars)
-        const chatTitle = message.length > 50 ? message.substring(0, 47) + '...' : message;
-        console.log('[processAIMessage] Attempting to create chat with title:', chatTitle);
-        chatId = await createChat({ title: chatTitle });
-        setCurrentChatId(chatId);
-        console.log('[processAIMessage] Successfully created new chat:', chatId);
-        // Notify user that chat has been created and will be saved
-        addChatMessage('💾 Chat created! Your conversation will be saved to history.', 'system');
-      } catch (error: any) {
-        console.error('[processAIMessage] Failed to create chat:', error);
-        // Show user-friendly error message but continue without chat persistence
-        addChatMessage('⚠️ Unable to save chat history - continuing in temporary mode. Check your connection or try signing out and back in.', 'system');
-      }
-    }
     
     // Save user message to Convex if we have a chat
     if (chatId && isSignedIn) {
diff --git a/app/pricing/page.tsx b/app/pricing/page.tsx
index 6dd7b66f..c8c06170 100644
--- a/app/pricing/page.tsx
+++ b/app/pricing/page.tsx
@@ -1,6 +1,5 @@
 "use client";
 
-import Link from "next/link";
 import { useRouter } from "next/navigation";
 import {
   Card,
@@ -11,11 +10,31 @@ import {
 } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
 import { Check, Sparkles, Crown } from "lucide-react";
-import CheckoutButton from "@/components/stripe/CheckoutButton";
+
+async function startAutumnCheckout() {
+  try {
+    const res = await fetch('/api/autumn/checkout', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ priceId: process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID })
+    });
+    const data = await res.json();
+    if (data.url) {
+      window.location.href = data.url;
+      return;
+    }
+    if (data.provider === 'stripe' && data.sessionId) {
+      const { getStripe } = await import('@/lib/stripe-client');
+      const stripe = await getStripe();
+      if (stripe) await stripe.redirectToCheckout({ sessionId: data.sessionId });
+    }
+  } catch (e) {
+    console.error('Checkout failed', e);
+  }
+}
 
 export default function PricingPage() {
   const router = useRouter();
-  const proPriceId = process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID || "price_pro_monthly";
 
   return (
     <div className="min-h-screen bg-background text-foreground">
@@ -23,8 +42,7 @@ export default function PricingPage() {
         <header className="text-center mb-12">
           <h1 className="text-4xl font-bold tracking-tight">Pricing</h1>
           <p className="text-muted-foreground mt-3 max-w-2xl mx-auto">
-            Choose the plan that fits your workflow. Start free and upgrade
-            anytime.
+            Choose the plan that fits your workflow. Start free and upgrade anytime.
           </p>
         </header>
 
@@ -120,15 +138,14 @@ export default function PricingPage() {
                   ))}
                 </ul>
                 <div className="mt-6">
-                  <CheckoutButton
-                    priceId={proPriceId}
-                    mode="subscription"
+                  <Button
                     variant="orange"
                     size="lg"
                     className="w-full"
+                    onClick={startAutumnCheckout}
                   >
                     Upgrade to Pro
-                  </CheckoutButton>
+                  </Button>
                 </div>
               </CardContent>
             </Card>
@@ -167,4 +184,4 @@ export default function PricingPage() {
       </div>
     </div>
   );
-}
+}
\ No newline at end of file
diff --git a/app/test-pricing/page.tsx b/app/test-pricing/page.tsx
index 3c92103b..f4e9630e 100644
--- a/app/test-pricing/page.tsx
+++ b/app/test-pricing/page.tsx
@@ -20,58 +20,32 @@ import { CreditCard, TestTube, DollarSign } from "lucide-react";
 
 const testPlans: PricingPlan[] = [
   {
-    id: "test-free",
-    name: "Test Free Plan",
-    description: "Testing free tier functionality",
+    id: "free",
+    name: "Free",
+    description: "Testing free tier",
     price: 0,
     currency: "usd",
     interval: "month",
     features: [
-      "Free tier testing",
-      "Basic Stripe integration",
-      "No payment required",
+      "5 chats",
+      "Basic models",
     ],
-    buttonText: "Test Free Plan",
+    buttonText: "Get Started",
     buttonVariant: "outline",
   },
   {
-    id: "test-basic",
-    name: "Test Basic",
-    description: "Basic paid plan for testing",
-    price: 10,
+    id: "pro",
+    name: "Pro",
+    description: "Testing Pro plan",
+    price: 20,
     currency: "usd",
     interval: "month",
-    priceId:
-      process.env.NEXT_PUBLIC_STRIPE_TEST_BASIC_PRICE_ID || "price_test_basic",
+    priceId: process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID || "price_test_pro",
     features: [
-      "Test basic payments",
-      "Stripe checkout flow",
-      "Subscription management",
-      "Test webhooks",
+      "Unlimited chats",
+      "Advanced models",
     ],
-    buttonText: "Test Basic Plan",
-    buttonVariant: "default",
-  },
-  {
-    id: "test-premium",
-    name: "Test Premium",
-    description: "Premium plan for comprehensive testing",
-    price: 25,
-    currency: "usd",
-    interval: "month",
-    priceId:
-      process.env.NEXT_PUBLIC_STRIPE_TEST_PREMIUM_PRICE_ID ||
-      "price_test_premium",
-    features: [
-      "All basic features",
-      "Advanced payment testing",
-      "Multiple payment methods",
-      "Subscription updates",
-      "Proration testing",
-    ],
-    popular: true,
-    buttonText: "Test Premium Plan",
-    buttonVariant: "default",
+    buttonText: "Upgrade to Pro",
   },
 ];
 
@@ -85,7 +59,6 @@ export default function TestPricingPage() {
   return (
     <div className="min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100 py-12 px-4 sm:px-6 lg:px-8">
       <div className="max-w-7xl mx-auto">
-        {/* Header */}
         <div className="text-center mb-12">
           <div className="flex justify-center items-center mb-4">
             <TestTube className="h-12 w-12 text-blue-600 mr-4" />
@@ -95,12 +68,10 @@ export default function TestPricingPage() {
           </div>
           <p className="text-xl text-gray-600 max-w-3xl mx-auto">
             Test the Stripe payment integration with various pricing scenarios
-            and configurations. This page demonstrates the full payment flow
-            including subscriptions, one-time payments, and custom amounts.
+            and configurations.
           </p>
         </div>
 
-        {/* Test Plans */}
         <div className="mb-16">
           <h2 className="text-2xl font-bold text-gray-900 mb-8 text-center">
             Test Subscription Plans
@@ -110,9 +81,7 @@ export default function TestPricingPage() {
 
         <Separator className="my-12" />
 
-        {/* Custom Testing Section */}
         <div className="grid grid-cols-1 lg:grid-cols-2 gap-8 mb-16">
-          {/* Custom Payment Test */}
           <Card>
             <CardHeader>
               <CardTitle className="flex items-center">
@@ -165,7 +134,7 @@ export default function TestPricingPage() {
 
               <CheckoutButton
                 customAmount={{
-                  amount: Math.round(customAmount * 100), // Convert to cents
+                  amount: Math.round(customAmount * 100),
                   currency: customCurrency,
                   name: `Custom ${testMode === "subscription" ? "Subscription" : "Payment"} Test`,
                   description: `Testing ${testMode} with ${customAmount} ${customCurrency.toUpperCase()}`,
@@ -175,14 +144,11 @@ export default function TestPricingPage() {
                 size="lg"
                 className="w-full"
               >
-                Test Custom{" "}
-                {testMode === "subscription" ? "Subscription" : "Payment"} -{" "}
-                {customAmount} {customCurrency.toUpperCase()}
+                Test Custom {testMode === "subscription" ? "Subscription" : "Payment"} - {customAmount} {customCurrency.toUpperCase()}
               </CheckoutButton>
             </CardContent>
           </Card>
 
-          {/* Quick Test Buttons */}
           <Card>
             <CardHeader>
               <CardTitle className="flex items-center">
@@ -196,7 +162,7 @@ export default function TestPricingPage() {
             <CardContent className="space-y-4">
               <CheckoutButton
                 customAmount={{
-                  amount: 100, // $1.00
+                  amount: 100,
                   currency: "usd",
                   name: "Minimum Payment Test",
                   description: "Testing minimum payment amount",
@@ -211,7 +177,7 @@ export default function TestPricingPage() {
 
               <CheckoutButton
                 customAmount={{
-                  amount: 999, // $9.99
+                  amount: 1999,
                   currency: "usd",
                   name: "Standard Subscription Test",
                   description: "Testing standard subscription pricing",
@@ -221,12 +187,12 @@ export default function TestPricingPage() {
                 size="lg"
                 className="w-full"
               >
-                Test $9.99/month Subscription
+                Test $19.99/month Subscription
               </CheckoutButton>
 
               <CheckoutButton
                 customAmount={{
-                  amount: 4999, // $49.99
+                  amount: 4999,
                   currency: "usd",
                   name: "Premium Payment Test",
                   description: "Testing higher-value payments",
@@ -238,27 +204,10 @@ export default function TestPricingPage() {
               >
                 Test $49.99 One-time Payment
               </CheckoutButton>
-
-              <CheckoutButton
-                customAmount={{
-                  amount: 0,
-                  currency: "usd",
-                  name: "Free Trial Test",
-                  description: "Testing free trial flow",
-                }}
-                mode="payment"
-                variant="ghost"
-                size="lg"
-                className="w-full"
-                disabled
-              >
-                Test Free Trial (Disabled)
-              </CheckoutButton>
             </CardContent>
           </Card>
         </div>
 
-        {/* Test Information */}
         <Card className="bg-blue-50 border-blue-200">
           <CardHeader>
             <CardTitle className="text-blue-900">Testing Information</CardTitle>
@@ -268,19 +217,10 @@ export default function TestPricingPage() {
               <div>
                 <h4 className="font-semibold mb-2">Test Credit Cards</h4>
                 <ul className="space-y-1 text-sm">
-                  <li>
-                    <code>4242424242424242</code> - Visa (Success)
-                  </li>
-                  <li>
-                    <code>4000000000000002</code> - Visa (Declined)
-                  </li>
-                  <li>
-                    <code>4000000000009995</code> - Visa (Insufficient funds)
-                  </li>
-                  <li>
-                    <code>4000002500003155</code> - Visa (Requires
-                    authentication)
-                  </li>
+                  <li><code>4242424242424242</code> - Visa (Success)</li>
+                  <li><code>4000000000000002</code> - Visa (Declined)</li>
+                  <li><code>4000000000009995</code> - Visa (Insufficient funds)</li>
+                  <li><code>4000002500003155</code> - Visa (Requires authentication)</li>
                 </ul>
               </div>
               <div>
@@ -293,13 +233,6 @@ export default function TestPricingPage() {
                 </ul>
               </div>
             </div>
-            <div className="mt-4 p-3 bg-blue-100 rounded-lg">
-              <p className="text-sm">
-                <strong>Note:</strong> This page is for testing Stripe
-                integration. No real payments will be processed. Make sure your
-                environment variables are set correctly with Stripe test keys.
-              </p>
-            </div>
           </CardContent>
         </Card>
       </div>
diff --git a/components/ConvexChat.tsx b/components/ConvexChat.tsx
index 2da3b2b1..1d25d020 100644
--- a/components/ConvexChat.tsx
+++ b/components/ConvexChat.tsx
@@ -208,10 +208,26 @@ export default function ConvexChat({ onChatSelect, onMessageAdd }: ConvexChatPro
   };
 
   const handleUpgrade = async (plan: string) => {
-    // Integration with Stripe will be handled here
-    console.log('Upgrading to plan:', plan);
-    setShowPricingModal(false);
-    // TODO: Integrate with Stripe checkout
+    try {
+      const res = await fetch('/api/autumn/checkout', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ priceId: process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID })
+      });
+      const data = await res.json();
+      setShowPricingModal(false);
+      if (data.url) {
+        window.location.href = data.url;
+        return;
+      }
+      if (data.provider === 'stripe' && data.sessionId) {
+        const { getStripe } = await import('@/lib/stripe-client');
+        const stripe = await getStripe();
+        if (stripe) await stripe.redirectToCheckout({ sessionId: data.sessionId });
+      }
+    } catch (e) {
+      console.error('Upgrade failed', e);
+    }
   };
 
   return (
diff --git a/components/EnhancedSettingsModal.tsx b/components/EnhancedSettingsModal.tsx
index c6f1773b..98a147bb 100644
--- a/components/EnhancedSettingsModal.tsx
+++ b/components/EnhancedSettingsModal.tsx
@@ -55,47 +55,25 @@ export default function EnhancedSettingsModal({ isOpen, onClose }: EnhancedSetti
   });
 
   const plans = [
+    {
+      name: 'Free',
+      description: 'Perfect for getting started.',
+      monthlyPrice: 0,
+      annualPrice: 0,
+      features: [
+        '5 chats',
+        'Basic models'
+      ]
+    },
     {
       name: 'Pro',
-      description: 'Designed for fast-moving teams building together in real time.',
+      description: 'Unlimited chats and advanced models.',
       monthlyPrice: 20,
       annualPrice: 20,
       popular: true,
       features: [
         'Unlimited chats',
-        'Unlimited projects',
-        'Private projects',
-        'User roles & permissions',
-        'Custom domains',
-        'Priority support'
-      ]
-    },
-    {
-      name: 'Business', 
-      description: 'Advanced controls and power features for growing departments',
-      monthlyPrice: 50,
-      annualPrice: 40,
-      features: [
-        'All features in Pro, plus:',
-        '100 monthly credits',
-        'SSO',
-        'Personal Projects',
-        'Opt out of data training',
-        'Design templates',
-        'Custom design systems'
-      ]
-    },
-    {
-      name: 'Enterprise',
-      description: 'Built for large orgs needing flexibility, scale, and governance.',
-      isEnterprise: true,
-      features: [
-        'Everything in Business, plus:',
-        'Dedicated support',
-        'Onboarding services', 
-        'Custom integrations',
-        'Group-based access control',
-        'Custom design systems'
+        'Advanced models'
       ]
     }
   ];
diff --git a/components/MasterDashboard.tsx b/components/MasterDashboard.tsx
index 89568fd8..47641899 100644
--- a/components/MasterDashboard.tsx
+++ b/components/MasterDashboard.tsx
@@ -208,13 +208,13 @@ export default function MasterDashboard({
                     ? 'border-blue-600 text-blue-600 bg-blue-50'
                     : 'border-transparent text-gray-600'
                 )}
-                title={!isAvailable ? `${item.label} requires ${userSubscription === 'free' ? 'Pro' : 'Enterprise'} subscription` : item.description}
+                title={!isAvailable ? `${item.label} requires Pro subscription` : item.description}
               >
                 <Icon className="w-4 h-4" />
                 <span>{item.label}</span>
                 {!isAvailable && (
                   <span className="text-xs bg-yellow-100 text-yellow-700 px-1.5 py-0.5 rounded">
-                    {userSubscription === 'free' ? 'Pro' : 'Enterprise'}
+                    {'Pro'}
                   </span>
                 )}
               </button>
@@ -401,7 +401,7 @@ export default function MasterDashboard({
                   >
                     <option value="1">1 Agent (Free)</option>
                     <option value="3">3 Agents (Pro)</option>
-                    <option value="10">10 Agents (Enterprise)</option>
+                    <option value="10">10 Agents (Pro)</option>
                   </select>
                 </div>
               </div>
@@ -409,7 +409,7 @@ export default function MasterDashboard({
           </div>
         )}
 
-        {currentView === 'monitoring' && userSubscription === 'enterprise' && (
+        {currentView === 'monitoring' && userSubscription !== 'free' && (
           <div className="text-center py-12">
             <Monitor className="w-16 h-16 mx-auto text-gray-400 mb-4" />
             <h3 className="text-lg font-medium text-gray-900 mb-2">
@@ -428,10 +428,10 @@ export default function MasterDashboard({
           <div className="text-center py-12">
             <Settings className="w-16 h-16 mx-auto text-gray-400 mb-4" />
             <h3 className="text-lg font-medium text-gray-900 mb-2">
-              {userSubscription === 'free' ? 'Pro Subscription Required' : 'Enterprise Subscription Required'}
+              {'Pro Subscription Required'}
             </h3>
             <p className="text-gray-600 mb-4">
-              This feature requires a {userSubscription === 'free' ? 'Pro' : 'Enterprise'} subscription to access.
+              This feature requires a Pro subscription to access.
             </p>
             <Button>
               Upgrade Subscription
diff --git a/lib/groq-sequential-thinking.ts b/lib/groq-sequential-thinking.ts
index e929c94e..09993731 100644
--- a/lib/groq-sequential-thinking.ts
+++ b/lib/groq-sequential-thinking.ts
@@ -1,14 +1,17 @@
 /**
- * Groq Sequential Thinking Engine
- * 
- * Implements advanced sequential thinking capabilities specifically for Groq models,
- * leveraging Groq's reasoning API and MCP integration for enhanced reasoning experiences.
+ * Sequential Thinking Engine (Kimi K2 default)
+ *
+ * Replaces Groq-specific implementation with a provider-agnostic approach
+ * defaulting to moonshotai/kimi-k2-instruct-0905 from app.config.
  */
 
-import { createGroq } from '@ai-sdk/groq';
 import { streamText } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { getSequentialThinkingService } from '@/lib/mcp/sequential-thinking-service';
 import { getReasoningSearchService } from '@/lib/search/reasoning-search';
+import { appConfig } from '@/config/app.config';
 
 export interface ThoughtStep {
   stepNumber: number;
@@ -62,22 +65,26 @@ export interface ReasoningProgress {
   message?: string;
 }
 
+function getProvider(modelId: string) {
+  const isAnthropic = modelId.startsWith('anthropic/');
+  const isGoogle = modelId.startsWith('google/');
+  const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+  const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY, baseURL: process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com/v1' });
+  const google = createGoogleGenerativeAI({ apiKey: process.env.GEMINI_API_KEY });
+  const actual = isAnthropic ? modelId.replace('anthropic/', '') : (isGoogle ? modelId.replace('google/', '') : modelId);
+  const provider = isAnthropic ? anthropic : (isGoogle ? google : openai);
+  return { provider, actualModel: actual };
+}
+
 export class GroqSequentialThinking {
-  private groqClient;
   private mcpService;
   private searchService;
 
   constructor() {
-    this.groqClient = createGroq({
-      apiKey: process.env.GROQ_API_KEY,
-    });
     this.mcpService = getSequentialThinkingService();
     this.searchService = getReasoningSearchService();
   }
 
-  /**
-   * Process a query using sequential thinking with UltraThink mode
-   */
   async processUltraThink(
     request: UltraThinkRequest,
     progressCallback?: (progress: ReasoningProgress) => void
@@ -85,62 +92,42 @@ export class GroqSequentialThinking {
     const startTime = Date.now();
     const reasoningPaths: ReasoningPath[] = [];
     const searchSources: any[] = [];
-    
+
     try {
-      // Initialize MCP Sequential Thinking
       await this.mcpService.initialize();
-      
-      // Start primary reasoning path
+
       const primaryPath = await this.createReasoningPath(request, progressCallback);
       reasoningPaths.push(primaryPath);
-      
-      // Enable branching for complex problems
+
       if (request.enableBranching && this.shouldCreateBranches(request.query)) {
         const branchPaths = await this.createAlternativePaths(request, primaryPath, progressCallback);
         reasoningPaths.push(...branchPaths);
       }
-      
-      // Select best path and generate final answer
+
       const bestPath = this.selectBestReasoningPath(reasoningPaths);
       const finalAnswer = await this.generateFinalAnswer(request, bestPath, progressCallback);
-      
-      // Collect all search sources used
+
       reasoningPaths.forEach(path => {
         path.steps.forEach(step => {
-          if (step.searchResults) {
-            searchSources.push(...step.searchResults);
-          }
+          if (step.searchResults) searchSources.push(...step.searchResults);
         });
       });
-      
-      const processingTime = Date.now() - startTime;
-      const thoughtCount = reasoningPaths.reduce((total, path) => total + path.steps.length, 0);
-      
-      progressCallback?.({
-        type: 'reasoning_complete',
-        progress: 100,
-        message: `Completed reasoning with ${thoughtCount} thoughts across ${reasoningPaths.length} path(s)`
-      });
-      
+
       return {
         reasoningPaths,
         finalAnswer,
         confidence: bestPath.confidence,
         searchSources: this.deduplicateSearchSources(searchSources),
-        processingTime,
-        thoughtCount,
+        processingTime: Date.now() - startTime,
+        thoughtCount: reasoningPaths.reduce((t, p) => t + p.steps.length, 0),
         ultraThinkMode: true
       };
-      
     } catch (error) {
       console.error('UltraThink processing error:', error);
       throw new Error(`Sequential thinking failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
   }
 
-  /**
-   * Create a reasoning path using MCP Sequential Thinking
-   */
   private async createReasoningPath(
     request: UltraThinkRequest,
     progressCallback?: (progress: ReasoningProgress) => void,
@@ -151,7 +138,7 @@ export class GroqSequentialThinking {
     let currentStep = 1;
     let totalEstimatedSteps = request.maxThoughts || 5;
     let nextThoughtNeeded = true;
-    
+
     const path: ReasoningPath = {
       pathId,
       steps,
@@ -161,23 +148,17 @@ export class GroqSequentialThinking {
       isComplete: false,
       branchedFrom
     };
-    
-    progressCallback?.({
-      type: 'thought_start',
-      pathId,
-      progress: 0,
-      message: `Starting reasoning path${branchedFrom ? ' (alternative approach)' : ''}`
-    });
-    
+
+    progressCallback?.({ type: 'thought_start', pathId, progress: 0, message: `Starting reasoning path${branchedFrom ? ' (alternative approach)' : ''}` });
+
     while (nextThoughtNeeded && currentStep <= totalEstimatedSteps) {
-      // Generate thought using Groq with reasoning format
       const thoughtResponse = await this.generateThought(
         request,
         steps,
         currentStep,
         totalEstimatedSteps
       );
-      
+
       const thought: ThoughtStep = {
         stepNumber: currentStep,
         thought: thoughtResponse.thought,
@@ -188,21 +169,13 @@ export class GroqSequentialThinking {
         searchResults: [],
         alternatives: []
       };
-      
-      progressCallback?.({
-        type: 'thought_complete',
-        step: thought,
-        pathId,
-        progress: (currentStep / totalEstimatedSteps) * 100,
-        message: `Completed thought ${currentStep}/${totalEstimatedSteps}`
-      });
-      
-      // Enhance thought with search if enabled
+
+      progressCallback?.({ type: 'thought_complete', step: thought, pathId, progress: (currentStep / totalEstimatedSteps) * 100, message: `Completed thought ${currentStep}/${totalEstimatedSteps}` });
+
       if (request.enableSearch && this.shouldSearch(thought.thought)) {
         await this.enhanceThoughtWithSearch(thought, request.query, progressCallback);
       }
-      
-      // Check if we need more thoughts using MCP
+
       const mcpResponse = await this.mcpService.processThought({
         thought: thought.thought,
         thoughtNumber: currentStep,
@@ -213,46 +186,38 @@ export class GroqSequentialThinking {
           searchEnabled: request.enableSearch
         }
       });
-      
-      // Update thought with MCP insights
+
       if (mcpResponse.alternatives) {
         thought.alternatives = mcpResponse.alternatives;
       }
-      
+
       steps.push(thought);
-      
-      // Update path progress
+
       nextThoughtNeeded = mcpResponse.nextThoughtNeeded;
       totalEstimatedSteps = mcpResponse.adjustedTotalThoughts || totalEstimatedSteps;
       currentStep++;
-      
-      // Update path confidence (running average)
+
       path.confidence = steps.reduce((avg, step) => avg + step.confidence, 0) / steps.length;
     }
-    
+
     path.currentStep = currentStep - 1;
     path.totalEstimatedSteps = totalEstimatedSteps;
     path.isComplete = !nextThoughtNeeded || currentStep > totalEstimatedSteps;
-    
+
     return path;
   }
-  
-  /**
-   * Generate individual thought using Groq's reasoning capabilities
-   */
+
   private async generateThought(
     request: UltraThinkRequest,
     previousSteps: ThoughtStep[],
     stepNumber: number,
     totalSteps: number
   ): Promise<{thought: string, confidence: number, reasoning: string}> {
-    const model = request.model || 'llama-3.3-70b-versatile';
-    
-    // Build context from previous thoughts
-    const previousThoughts = previousSteps.map(step => 
-      `Step ${step.stepNumber}: ${step.thought}`
-    ).join('\n');
-    
+    const modelId = request.model || appConfig.ai.defaultModel;
+    const { provider, actualModel } = getProvider(modelId);
+
+    const previousThoughts = previousSteps.map(step => `Step ${step.stepNumber}: ${step.thought}`).join('\n');
+
     const systemPrompt = `You are an advanced reasoning system performing sequential thinking. This is step ${stepNumber} of approximately ${totalSteps} steps.
 
 Your task is to think deeply about the user's query and provide ONE specific thought or analysis step that builds on previous thinking.
@@ -278,206 +243,120 @@ THOUGHT: [Your specific thought or analysis for this step]
 CONFIDENCE: [0-100 score for this thought]`;
 
     const result = await streamText({
-      model: this.groqClient(model),
+      model: provider(actualModel),
       messages: [
         { role: 'system', content: systemPrompt },
         { role: 'user', content: `Please provide step ${stepNumber} of your reasoning about: "${request.query}"` }
       ],
       temperature: 0.7,
-      maxTokens: 1000,
-      // Use Groq's reasoning format to get <think> tags
-      experimental_providerMetadata: {
-        groq: {
-          reasoning_format: 'raw'
-        }
-      }
+      maxTokens: 1000
     });
-    
-    // Extract the full response
+
     let fullResponse = '';
     for await (const textPart of result.textStream) {
       fullResponse += textPart;
     }
-    
-    // Parse the response to extract thought, reasoning, and confidence
+
     const thinkMatch = fullResponse.match(/<think>([\s\S]*?)<\/think>/);
     const thoughtMatch = fullResponse.match(/THOUGHT:\s*([\s\S]*?)(?=CONFIDENCE:|$)/);
     const confidenceMatch = fullResponse.match(/CONFIDENCE:\s*(\d+)/);
-    
+
     return {
       thought: thoughtMatch?.[1]?.trim() || fullResponse.split('THOUGHT:')[1]?.split('CONFIDENCE:')[0]?.trim() || fullResponse.trim(),
       reasoning: thinkMatch?.[1]?.trim() || 'No explicit reasoning provided',
       confidence: confidenceMatch ? parseInt(confidenceMatch[1]) : 75
     };
   }
-  
-  /**
-   * Enhance thought with search results
-   */
+
   private async enhanceThoughtWithSearch(
     thought: ThoughtStep,
     originalQuery: string,
     progressCallback?: (progress: ReasoningProgress) => void
   ): Promise<void> {
-    // Generate search queries based on the thought
     const searchQueries = this.generateSearchQueries(thought.thought, originalQuery);
     thought.searchQueries = searchQueries;
-    
+
     for (const query of searchQueries) {
-      progressCallback?.({
-        type: 'search_query',
-        searchQuery: query,
-        message: `Searching for: ${query}`
-      });
-      
+      progressCallback?.({ type: 'search_query', searchQuery: query, message: `Searching for: ${query}` });
       try {
-        const searchResults = await this.searchService.searchForReasoning(query, {
-          maxResults: 3,
-          relevanceThreshold: 0.7
-        });
-        
+        const searchResults = await this.searchService.searchForReasoning(query, { maxResults: 3, relevanceThreshold: 0.7 });
         if (searchResults && searchResults.length > 0) {
           thought.searchResults?.push(...searchResults);
-          progressCallback?.({
-            type: 'search_results',
-            searchResults: searchResults,
-            message: `Found ${searchResults.length} relevant sources`
-          });
+          progressCallback?.({ type: 'search_results', searchResults, message: `Found ${searchResults.length} relevant sources` });
         }
       } catch (error) {
         console.warn(`Search failed for query "${query}":`, error);
       }
     }
   }
-  
-  /**
-   * Generate search queries based on thought content
-   */
+
   private generateSearchQueries(thought: string, originalQuery: string): string[] {
     const queries: string[] = [];
-    
-    // Extract key terms and concepts from the thought
     const words = thought.toLowerCase().split(/\W+/).filter(word => word.length > 3);
-    const importantWords = words.filter(word => 
-      !['that', 'this', 'with', 'from', 'they', 'have', 'been', 'will', 'would', 'could', 'should'].includes(word)
-    );
-    
-    // Create focused search queries
+    const importantWords = words.filter(word => !['that', 'this', 'with', 'from', 'they', 'have', 'been', 'will', 'would', 'could', 'should'].includes(word));
+
     if (importantWords.length >= 2) {
       queries.push(`${originalQuery} ${importantWords.slice(0, 3).join(' ')}`);
     }
-    
-    // Look for specific concepts or technical terms
-    const technicalTerms = words.filter(word => 
-      word.length > 5 && (
-        word.includes('tion') || 
-        word.includes('ment') || 
-        word.includes('ness') ||
-        word.includes('able') ||
-        word.match(/^[A-Z][a-z]+[A-Z]/)
-      )
-    );
-    
+
+    const technicalTerms = words.filter(word => word.length > 5 && (word.includes('tion') || word.includes('ment') || word.includes('ness') || word.includes('able') || word.match(/^[A-Z][a-z]+[A-Z]/)));
     if (technicalTerms.length > 0) {
       queries.push(`${technicalTerms[0]} ${originalQuery.split(' ').slice(0, 2).join(' ')}`);
     }
-    
-    return queries.slice(0, 2); // Limit to 2 search queries per thought
+
+    return queries.slice(0, 2);
   }
-  
-  /**
-   * Determine if we should search for this thought
-   */
+
   private shouldSearch(thought: string): boolean {
-    const searchIndicators = [
-      'how', 'what', 'why', 'when', 'where',
-      'example', 'best practice', 'documentation',
-      'research', 'study', 'evidence', 'data',
-      'recent', 'current', 'latest', 'new'
-    ];
-    
+    const searchIndicators = ['how', 'what', 'why', 'when', 'where','example', 'best practice', 'documentation','research', 'study', 'evidence', 'data','recent', 'current', 'latest', 'new'];
     const lowerThought = thought.toLowerCase();
     return searchIndicators.some(indicator => lowerThought.includes(indicator));
   }
-  
-  /**
-   * Determine if we should create alternative reasoning branches
-   */
+
   private shouldCreateBranches(query: string): boolean {
-    const branchIndicators = [
-      'complex', 'multiple', 'various', 'different',
-      'alternatives', 'options', 'approaches', 'strategies',
-      'compare', 'versus', 'vs', 'or'
-    ];
-    
+    const branchIndicators = ['complex', 'multiple', 'various', 'different','alternatives', 'options', 'approaches', 'strategies','compare', 'versus', 'vs', 'or'];
     const lowerQuery = query.toLowerCase();
-    return branchIndicators.some(indicator => lowerQuery.includes(indicator)) ||
-           query.split(' ').length > 10; // Complex queries likely benefit from branching
+    return branchIndicators.some(indicator => lowerQuery.includes(indicator)) || query.split(' ').length > 10;
   }
-  
-  /**
-   * Create alternative reasoning paths
-   */
+
   private async createAlternativePaths(
     request: UltraThinkRequest,
     primaryPath: ReasoningPath,
     progressCallback?: (progress: ReasoningProgress) => void
   ): Promise<ReasoningPath[]> {
     const alternatives: ReasoningPath[] = [];
-    
-    // Create one alternative approach
-    progressCallback?.({
-      type: 'branch_created',
-      message: 'Creating alternative reasoning approach...'
-    });
-    
-    const alternativeRequest = {
-      ...request,
-      maxThoughts: Math.min(request.maxThoughts || 5, 4), // Shorter for alternatives
-    };
-    
+    progressCallback?.({ type: 'branch_created', message: 'Creating alternative reasoning approach...' });
+
+    const alternativeRequest = { ...request, maxThoughts: Math.min(request.maxThoughts || 5, 4) };
+
     try {
-      const altPath = await this.createReasoningPath(
-        alternativeRequest,
-        progressCallback,
-        primaryPath.pathId
-      );
+      const altPath = await this.createReasoningPath(alternativeRequest, progressCallback, primaryPath.pathId);
       alternatives.push(altPath);
     } catch (error) {
       console.warn('Failed to create alternative reasoning path:', error);
     }
-    
+
     return alternatives;
   }
-  
-  /**
-   * Select the best reasoning path based on confidence and completeness
-   */
+
   private selectBestReasoningPath(paths: ReasoningPath[]): ReasoningPath {
     return paths.reduce((best, current) => {
       const currentScore = current.confidence * (current.isComplete ? 1.2 : 1.0);
       const bestScore = best.confidence * (best.isComplete ? 1.2 : 1.0);
-      
       return currentScore > bestScore ? current : best;
     });
   }
-  
-  /**
-   * Generate final answer based on the best reasoning path
-   */
+
   private async generateFinalAnswer(
     request: UltraThinkRequest,
     bestPath: ReasoningPath,
     progressCallback?: (progress: ReasoningProgress) => void
   ): Promise<string> {
-    progressCallback?.({
-      type: 'thought_start',
-      message: 'Generating final answer...'
-    });
-    
-    const model = request.model || 'llama-3.3-70b-versatile';
-    
-    // Compile all thoughts and search results
+    progressCallback?.({ type: 'thought_start', message: 'Generating final answer...' });
+
+    const modelId = request.model || appConfig.ai.defaultModel;
+    const { provider, actualModel } = getProvider(modelId);
+
     const reasoningContext = bestPath.steps.map(step => {
       let stepContent = `Step ${step.stepNumber}: ${step.thought}`;
       if (step.searchResults && step.searchResults.length > 0) {
@@ -485,7 +364,7 @@ CONFIDENCE: [0-100 score for this thought]`;
       }
       return stepContent;
     }).join('\n\n');
-    
+
     const systemPrompt = `You are providing a final, comprehensive answer based on sequential reasoning analysis.
 
 REASONING PROCESS:
@@ -503,7 +382,7 @@ Query: "${request.query}"
 Provide your final answer based on the reasoning analysis above.`;
 
     const result = await streamText({
-      model: this.groqClient(model),
+      model: provider(actualModel),
       messages: [
         { role: 'system', content: systemPrompt },
         { role: 'user', content: 'Please provide your final answer based on the reasoning analysis.' }
@@ -511,18 +390,15 @@ Provide your final answer based on the reasoning analysis above.`;
       temperature: 0.6,
       maxTokens: 2000
     });
-    
+
     let finalAnswer = '';
     for await (const textPart of result.textStream) {
       finalAnswer += textPart;
     }
-    
+
     return finalAnswer;
   }
-  
-  /**
-   * Remove duplicate search sources
-   */
+
   private deduplicateSearchSources(sources: any[]): any[] {
     const seen = new Set();
     return sources.filter(source => {
@@ -534,7 +410,6 @@ Provide your final answer based on the reasoning analysis above.`;
   }
 }
 
-// Export singleton instance
 let groqSequentialThinkingInstance: GroqSequentialThinking | null = null;
 
 export function getGroqSequentialThinking(): GroqSequentialThinking {
@@ -544,13 +419,10 @@ export function getGroqSequentialThinking(): GroqSequentialThinking {
   return groqSequentialThinkingInstance;
 }
 
-/**
- * Convenience function for UltraThink processing
- */
 export async function processUltraThink(
   request: UltraThinkRequest,
   progressCallback?: (progress: ReasoningProgress) => void
 ): Promise<UltraThinkResponse> {
   const engine = getGroqSequentialThinking();
   return engine.processUltraThink(request, progressCallback);
-}
\ No newline at end of file
+}