Forem: WEDGE Method Dev

The AI Consulting Rate Card: How to Price Your AI Projects in 2026

WEDGE Method Dev — Tue, 07 Apr 2026 02:28:32 +0000

AI consulting is exploding — and so is the confusion around pricing. After building WEDGE Method, a complete AI consulting toolkit, I've talked to dozens of consultants who are either leaving money on the table or losing deals because they can't communicate value clearly.

Here's the rate card framework I use.

The Mistake Most AI Consultants Make

They price by the hour.

"I charge $75/hr for AI work" sounds reasonable until a client asks: "How many hours will this take?" Now you're stuck defending time instead of value.

The fix: price by outcome, estimate by phase.

The Three-Tier Rate Structure

Tier 1: Discovery & Audit ($2,500–$5,000 flat)

What you deliver:

Current workflow audit
AI readiness assessment
Opportunity scorecard
ROI projection model
Implementation roadmap

This is your foot-in-the-door. It's low risk for the client, high value for you — and it almost always leads to a Phase 2.

Tier 2: Implementation ($10,000–$50,000)

Broken into milestones, not hours:

Milestone 1: Setup & integration (30%)
Milestone 2: Pilot + testing (40%)
Milestone 3: Deployment + training (30%)

Never bill 100% upfront. Never go purely hourly. Milestone-based keeps everyone accountable.

Tier 3: Retainer ($3,000–$8,000/month)

Ongoing AI operations support:

Monthly model tuning
New automation builds
Team training sessions
Performance reporting

Retainers are where real income stability comes from.

The Value Anchor Formula

Before any proposal, calculate the client's current cost of NOT having AI:

Manual hours/month × hourly rate = Current cost
Current cost × 12 = Annual waste
Your project cost ÷ Annual waste = ROI payback period

If you can show a client they're burning $180K/year on tasks AI can handle for $25K — closing the deal is easy.

The Questions That Set Your Rate

What's the company's annual revenue? (Your project should cost <2% to be a no-brainer)
What decision-makers are involved? (More stakeholders = higher risk = higher price)
What's the timeline? (Rush jobs cost more, always)
Is there IP involved? (Training on proprietary data = premium)
What happens if they DON'T do this? (Quantify the pain)

Proposal Template Structure

The best proposals I've seen follow this structure:

Situation — what's happening now
Complication — why now is the right time to fix it
Resolution — what you'll do
Investment — the price (never "cost")
ROI — what they get back

Keep it under 8 pages. Clients don't read long proposals — they scan them for the number.

Common Pricing Mistakes

Mistake 1: Charging for your time, not their outcome
Fix: Anchor to business value, not hours.

Mistake 2: No discovery phase
Fix: Always start with a paid discovery. It funds your research AND qualifies the client.

Mistake 3: One price option
Fix: Always present 3 options (Good/Better/Best). Most clients choose the middle.

Mistake 4: No retainer conversation
Fix: Build retainer into your proposal from Day 1 as "Phase 3."

Mistake 5: Underpricing because you're "just getting started"
Fix: Price the outcome, not your experience level. A $25K AI automation that saves $200K is worth $25K whether you've been doing this for 1 year or 10.

What's In My Rate Card Template

If you want a ready-to-use rate card with pre-filled tier structures, a built-in ROI calculator, and client-facing language (not technical jargon), I put it all in the WEDGE Starter Toolkit along with 300+ prompts, proposal templates, and project blueprints.

What's your current pricing model? Drop it in the comments — I'll give feedback on how to strengthen it.

This article was written by Jacob Olschewski, founder of WEDGE Method — the AI operating system built for independent consultants. WEDGE replaces 17+ tools with 6 integrated AI systems that save 10-20 hours/week.

→ Try WEDGE free for 7 days — no credit card required.

I Built an AI Operating System for Consultants. Zero Customers. Here's Why I'm Talking About It Now.

WEDGE Method Dev — Mon, 06 Apr 2026 22:49:04 +0000

I Built an AI Operating System for Consultants. Zero Customers. Here's Why I'm Talking About It Now.

I've been hiding this product for 6 weeks.

Not because it's not ready. It's been live at thewedgemethodai.com for weeks.

I was hiding it because I was scared. Scared it wasn't good enough. Scared people would judge it. Scared of being wrong publicly.

Today that stops.

What is WEDGE Method?

WEDGE is an AI operating system built specifically for independent consultants.

Not a generic AI tool. Not another ChatGPT wrapper. A complete system with 6 AI engines that handle the work consultants hate doing:

Research: Client briefs in 8 minutes instead of 3 hours
Proposals: Complete proposals in 20 minutes instead of 4 hours
Email: Automated follow-up sequences that keep clients engaged
Reports: Deliverables in 1 hour instead of a full day
Strategy: AI-assisted thinking partner for your client work
Admin: The 2 hours of daily busywork, automated

The problem I'm solving: independent consultants waste 15-20 hours every week on research, writing, and admin. At $150/hr billing rate, that's $9,000-$12,000 lost every month to low-value tasks.

Why consultants specifically?

I was a consultant. I lost $47,000 in revenue in one year — not because of bad work, but because I was slow. Research took too long. Proposals took too long. Follow-ups fell through the cracks.

I built the tool I needed. Then I realized every consultant I knew had the same problem.

750,000 independent management consultants in the US. $3.6B addressable market. One problem: they're all doing $50/hour work when they should be doing $500/hour thinking.

The build-in-public commitment

Starting today, I'm documenting everything:

How many LinkedIn DMs I send and how many reply
Every customer conversation, what they said, what they needed
Weekly MRR updates (starting at $0 — honesty first)
What works, what fails, what surprises me

The goal is $100K MRR by December 2026. I'll tell you every week whether I'm on track or not.

Where we are today (April 6, 2026)

MRR: $0
Customers: 0 paying
Product: Live and working
Codebase: 12 AI agents, 42 cron jobs, 65+ routes, 330+ API endpoints
Content moat: 332 published articles on Dev.to (you might be reading one right now)
One DFY sale: $997 — proof someone will pay. Now building the repeatable system.

What's next this week

Post every day on LinkedIn — starting today
Send 20 DMs to independent consultants
Offer the first 5 free 30-day trials to get real feedback
Set up Gumroad product: WEDGE Starter Toolkit — $47 (50 AI prompts for consultants)

If you're an independent consultant, I want to hear from you. What's the biggest time drain in your practice right now?

Drop it in the comments. Every response shapes what WEDGE builds next.

Following along costs nothing. The learning is free.

Product: thewedgemethodai.com

Want this automated? Check out WEDGE Method — the AI OS built specifically for consultants and knowledge workers.

Try WEDGE free for 7 days → thewedgemethodai.com

I Charge $5,000 to Build What Takes Me 90 Minutes — Here Is How I Justify It

WEDGE Method Dev — Fri, 03 Apr 2026 04:37:41 +0000

Want to save 15+ hours of consulting work every week?

WEDGE Method AI is the AI operating system built for independent consultants.

→ Client research briefs in 8 minutes (vs 3 hours)
→ Proposals in 20 minutes (vs 4 hours)

→ Reports in 1 hour (vs a full day)

Try it free for 7 days →

My Claude Code Setup Builds Full SaaS Products in 90 Minutes — Here's Every File

WEDGE Method Dev — Fri, 03 Apr 2026 04:34:00 +0000

Want to save 15+ hours of consulting work every week?

WEDGE Method AI is the AI operating system built for independent consultants.

→ Client research briefs in 8 minutes (vs 3 hours)
→ Proposals in 20 minutes (vs 4 hours)

→ Reports in 1 hour (vs a full day)

Try it free for 7 days →

How I Automated a Faceless YouTube Channel That Runs Without Me (Code + Architecture)

WEDGE Method Dev — Fri, 03 Apr 2026 04:08:54 +0000

I built an automated system that produces and schedules faceless YouTube content with minimal manual intervention. Here's the technical architecture for developers who want to build something similar.

Why Faceless YouTube?

Faceless channels (stock footage + voiceover + captions) are one of the most automatable content formats:

No camera, no face, no filming schedule
Stock footage is reusable across videos
Scripts can be AI-generated and human-reviewed
Editing follows repeatable templates
Upload and scheduling can be API-driven

Channels in niches like finance explainers, tech reviews, history, and motivation routinely hit 100K+ subs with this model.

The Architecture

┌─────────────────────────────────────────────┐
│              Content Pipeline                │
│                                              │
│  Niche Research → Script Generation →        │
│  Voice Synthesis → Stock Footage Match →     │
│  Video Assembly → Caption Generation →       │
│  Thumbnail Creation → Upload & Schedule      │
└─────────────────────────────────────────────┘

Step 1: Script Generation

const script = await anthropic.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 2000,
  system: `You write YouTube scripts for a faceless channel about [niche].

  <format>
  - Hook (first 5 seconds): Must create curiosity gap
  - Setup (30 seconds): Context and stakes
  - Body (3-5 points, 60 seconds each): Value delivery
  - CTA (15 seconds): Subscribe + next video tease
  </format>

  <rules>
  - Reading level: 8th grade
  - Sentence length: Under 15 words average
  - Include [PAUSE] markers for natural pacing
  - Include [B-ROLL: description] markers for footage cues
  </rules>`,
  messages: [{ role: 'user', content: `Topic: ${topic}` }]
});

The [B-ROLL] markers are key — they become the shot list for Step 3.

Step 2: Voice Synthesis

I use ElevenLabs API, but any TTS with natural prosody works:

const audio = await elevenLabs.textToSpeech(voiceId, {
  text: cleanScript, // Remove [B-ROLL] markers
  model_id: 'eleven_multilingual_v2',
  voice_settings: { stability: 0.5, similarity_boost: 0.75 }
});

Cost: ~$0.30 per 1000 characters. A 7-minute script ≈ $0.50.

Step 3: Stock Footage Matching

Parse the [B-ROLL: description] markers and search stock footage APIs:

const bRollCues = script.match(/\[B-ROLL: (.+?)\]/g);
for (const cue of bRollCues) {
  const description = cue.replace(/\[B-ROLL: |\]/g, '');
  const clips = await pexels.videos.search({ query: description, per_page: 3 });
  // Select best match based on duration and relevance
}

Pexels and Pixabay have free APIs with commercial-use footage. For higher quality, Storyblocks API is ~$15/month.

Step 4: Video Assembly

FFmpeg does the heavy lifting:

# Concatenate clips with crossfade transitions
ffmpeg -i clip1.mp4 -i clip2.mp4 -i voiceover.mp3 \
  -filter_complex "[0:v][1:v]xfade=transition=fade:duration=0.5" \
  -map "[outv]" -map 2:a output.mp4

For more complex editing (captions, lower thirds), I use moviepy in Python — it's programmatic and repeatable.

Step 5: Auto-Captions

Whisper (OpenAI's speech recognition) generates accurate captions:

import whisper
model = whisper.load_model('base')
result = model.transcribe('voiceover.mp3')
# Output: timestamped segments for SRT/VTT

Burn them into the video with FFmpeg's subtitles filter for that TikTok/Reels caption style that YouTube viewers now expect.

Step 6: Thumbnail Generation

The thumbnail is 80% of whether someone clicks. Pattern that works:

Bold text (3-5 words max)
Contrasting colors (yellow on dark, white on blue)
One focal image
Faces or arrows pointing at the text (even on faceless channels)

I generate these with Canvas/Figma templates + AI-written text.

The Numbers

Component	Cost per Video
Script (Claude API)	$0.05
Voice (ElevenLabs)	$0.50
Stock footage (free tier)	$0.00
Hosting/upload	$0.00
Total	~$0.55/video

At 3 videos/week = $7.15/month to run a full YouTube channel.

Monetization kicks in at 1,000 subs + 4,000 watch hours. Faceless channels in good niches report $3-15 RPM (revenue per 1000 views). At 50K views/month: $150-750/month from ads alone, plus affiliate revenue.

What I Learned

Hook quality determines everything — I tested 50 different opening patterns and found 5 that consistently drive retention above 50%. The knowledge gap ("Most people don't realize...") and specific result ("I went from X to Y") hooks dominate.
Batch everything — Don't make one video at a time. Generate 30 scripts, record 30 voiceovers, assemble 30 videos. Assembly-line efficiency.
Niche selection is 80% of success — High RPM niches (finance, tech, business) earn 5-10x more per view than entertainment.

Resources

I packaged the complete system — all scripts, prompts, niche research data, and 30 ready-to-film video scripts — into a playbook: YouTube Automation System on Gumroad ($47).

If you just want the hook formulas to test with your existing content, I have a free set of 50: wedgemethod.gumroad.com/l/free-hooks.

Happy to answer architecture questions in the comments — this was a fun build.

Want this automated? Check out WEDGE Method — the AI OS built specifically for consultants and knowledge workers.

Try WEDGE free for 7 days → thewedgemethodai.com

The 5 AI Automation Patterns That Actually Make Money for Small Businesses (With Implementation Guide)

WEDGE Method Dev — Fri, 03 Apr 2026 04:08:05 +0000

Want to save 15+ hours of consulting work every week?

WEDGE Method AI is the AI operating system built for independent consultants.

→ Client research briefs in 8 minutes (vs 3 hours)
→ Proposals in 20 minutes (vs 4 hours)

→ Reports in 1 hour (vs a full day)

Try it free for 7 days →

I Built a Complete SaaS Product in 90 Minutes Using Claude Code — Here's the Exact Workflow

WEDGE Method Dev — Fri, 03 Apr 2026 04:07:16 +0000

I've been building AI-powered products for the past year, and the workflow I've landed on lets me go from idea to deployed SaaS in about 90 minutes. Not a prototype — a production-ready product with Stripe payments, authentication, and a polished UI.

Here's the exact system I use.

The Stack

Claude Code (Anthropic's CLI) as the AI pair programmer
React + Vite + TypeScript for the frontend
Vercel for deployment (push to deploy)
Stripe for payments
Tailwind CSS for styling

The key insight: Claude Code isn't just autocomplete. It's an autonomous agent that reads your codebase, makes multi-file edits, runs builds, and fixes its own errors. You architect, it implements.

The 90-Minute Workflow

Phase 1: Architecture (10 min)

I start every build with a clear brief. Not vague — specific:

Build a SaaS landing page for [product].
Stack: React + Vite + TypeScript + Tailwind.
Pages: Landing (hero, features, pricing, FAQ), Checkout.
Payments: Stripe Checkout with 3 tiers.
Deploy: Vercel.

Claude Code reads this, scaffolds the project structure, installs dependencies, and creates the file tree. In 10 minutes I have a working skeleton with routing, components, and types.

Phase 2: Build (40 min)

This is where the magic happens. I give Claude Code section-by-section instructions:

Hero section: "Create a hero with headline, subheadline, CTA button, and social proof pill. Use the conversion hierarchy: clarity → value → trust → action."
Pricing section: "3-tier pricing with annual/monthly toggle. Highlight the middle tier. Include trust badges below."
Stripe integration: "Set up Stripe Checkout with the 3 price IDs. Handle success/cancel redirects."

Each instruction takes 3-5 minutes. Claude Code reads the existing code, makes the changes, builds to verify, and moves on. If the build breaks, it reads the error and fixes it automatically.

Phase 3: Polish (20 min)

Responsive design (mobile-first)
SEO meta tags, OpenGraph, JSON-LD schema
Security headers in vercel.json
Performance: lazy loading, code splitting, optimized images
Accessibility: semantic HTML, ARIA labels, keyboard nav

Phase 4: Ship (20 min)

git add . && git commit -m "Initial launch"
git push origin main
# Vercel auto-deploys from push

Then I verify: check the live URL, test Stripe checkout flow, run Lighthouse.

What Makes This Work

1. Skills files — I keep markdown files (.claude/skills/) with my exact patterns for pricing pages, Stripe integration, SEO, etc. Claude Code reads these as context, so every build follows proven patterns instead of starting from scratch.

2. MCP servers — Model Context Protocol lets Claude Code connect to external services. I have 13 MCP servers: GitHub, Stripe, databases, browser automation, documentation lookup. Claude Code can create Stripe products, check deployment status, and look up library docs without leaving the terminal.

3. Prompt caching — The Claude API caches system prompts for 5 minutes. For long build sessions, this cuts API costs by ~90% on repeated context.

4. Parallel agents — For complex builds, I launch multiple Claude Code subagents in parallel: one building the frontend, one setting up the API, one writing tests. They work simultaneously and I synthesize their output.

Real Example: AgentDesk

Last week I built AgentDesk — an AI agent management platform — using this exact workflow:

3-tier SaaS pricing ($99/$349/$799 per month)
Annual pricing toggle with 20% discount
Stripe payment links for all tiers
Waitlist form with API endpoint
Full SEO with JSON-LD schemas
Deployed to Vercel

Total time from mkdir to live URL: 87 minutes.

The Patterns That Save the Most Time

Never start from a blank page — Use skills files as templates. A pricing section that took 2 hours the first time now takes 5 minutes.
Build → verify → iterate — Don't write 500 lines then build. Write 20 lines, build, fix, move on. Claude Code does this naturally.
Use the cheapest model that works — Sonnet for most tasks ($3/MTok input), Opus only for complex architecture ($15/MTok). Haiku for classification ($1/MTok).
Cache everything — System prompts, knowledge base content, few-shot examples. cache_control: { type: 'ephemeral' } on any content block >1024 tokens.
Structured prompts with XML tags — Claude responds dramatically better to <context>, <instructions>, <output_format> tags than to free-form text.

The Cost

A typical 90-minute build session costs $3-8 in API credits. For that I get a fully deployed product with payments, SEO, responsive design, and production security.

Compare that to hiring a developer for the same scope.

Getting Started

If you want to try this workflow:

Install Claude Code: npm install -g @anthropic-ai/claude-code
Set your API key: export ANTHROPIC_API_KEY=your-key
Start building: claude in any project directory

The learning curve is about a week to get comfortable, and another week to build up your skills files and patterns. After that, the speed compounds.

I wrote a comprehensive guide covering all of these patterns in detail — the skills system, MCP setup, prompt engineering, agent architectures, and cost optimization. It's at wedgemethod.gumroad.com/l/claude-code-mastery if you want the complete system.

Happy to answer questions about any part of this workflow in the comments.

Want this automated? Check out WEDGE Method — the AI OS built specifically for consultants and knowledge workers.

Try WEDGE free for 7 days → thewedgemethodai.com

Building an AI Agent Platform with Next.js 16 and Claude: A Technical Deep-Dive

WEDGE Method Dev — Thu, 26 Mar 2026 11:19:09 +0000

Last month I shipped AgentDesk — a SaaS platform where consultants and agencies can run pre-built AI agents for client intake, proposal generation, and reporting. The stack is Next.js 16, Claude Sonnet 4 with tool use, Stripe subscriptions, and Vercel. This post walks through the architecture decisions and actual code that powers it.

The Problem

Every consulting firm does the same repetitive work: qualifying inbound leads, writing proposals from call notes, generating client reports. These tasks follow predictable patterns, which makes them perfect candidates for AI agents — not chatbots, but structured agents with defined tools and outputs.

I wanted to build a platform where each agent has a specific job, uses typed tools, and produces structured output that plugs directly into existing workflows.

Architecture Overview

The project uses Next.js 16.2.1 with the App Router, React 19, TypeScript, and Tailwind CSS 4. The core is a central agent engine that defines agent configurations and orchestrates Claude API calls. The API layer exposes trial and authenticated endpoints, Stripe handles billing, and the whole thing deploys to Vercel.

src/
├── app/
│   ├── api/
│   │   ├── agents/[agentId]/route.ts   # Authenticated agent runs
│   │   ├── trial/[agentId]/route.ts    # Free trial with rate limiting
│   │   ├── billing/checkout/route.ts   # Stripe checkout sessions
│   │   └── billing/webhook/route.ts    # Stripe webhook handler
│   ├── dashboard/
│   │   ├── agents/[agentId]/page.tsx   # Individual agent UI
│   │   ├── layout.tsx                  # Dashboard shell
│   │   └── page.tsx                    # Agent list
│   └── page.tsx                        # Landing page
├── lib/
│   ├── agent-engine.ts                 # Core agent definitions + runner
│   └── stripe.ts                       # Stripe config + plan definitions

The Agent Engine

The heart of the platform is agent-engine.ts. Each agent is defined as a typed AgentConfig object: a system prompt that defines its behavior, a set of Claude tools (function-calling schemas), token limits, and a temperature setting tuned per agent type.

export interface AgentConfig {
  id: string;
  name: string;
  systemPrompt: string;
  tools: Anthropic.Messages.Tool[];
  maxTokens: number;
  temperature: number;
}

Here's a condensed look at how the Intake Agent is defined. The system prompt instructs it to qualify leads on a 1-10 scale, suggest a next action, and draft a personalized response. The qualify_lead tool gives Claude a structured way to process the inquiry:

export const INTAKE_AGENT: AgentConfig = {
  id: "intake",
  name: "Intake Agent",
  systemPrompt: `You are a professional client intake agent...
Your job is to:
1. Read incoming inquiries (emails, form submissions, messages)
2. Qualify the lead based on: budget indicators, timeline urgency,
   service fit, company size
3. Generate a personalized, professional response
4. Score the lead on a 1-10 scale with reasoning`,
  tools: [
    {
      name: "qualify_lead",
      description:
        "Analyze an incoming inquiry and produce a qualification score, suggested response, and next action.",
      input_schema: {
        type: "object" as const,
        properties: {
          inquiry_text: {
            type: "string",
            description: "The full text of the incoming inquiry",
          },
          source: {
            type: "string",
            description: "Where the inquiry came from (email, form, chat)",
          },
          sender_info: {
            type: "string",
            description: "Any available info about the sender",
          },
        },
        required: ["inquiry_text"],
      },
    },
  ],
  maxTokens: 2048,
  temperature: 0.3,
};

Temperature tuning matters. The Intake Agent runs at 0.3 for consistent, reliable lead scoring. The Proposal Agent runs at 0.4 — slightly more creative for writing proposals, but still grounded. The Report Agent is back at 0.3 because reports need to be precise, not creative.

The runAgent function is the orchestrator. It accepts an agent ID, user input, and optional context, then calls Claude's Messages API:

export async function runAgent(
  agentId: string,
  input: string,
  context?: Record<string, unknown>
): Promise<AgentTask> {
  const agent = getAgent(agentId);
  if (!agent) throw new Error(`Agent "${agentId}" not found`);

  const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! });

  const contextStr = context
    ? `\n\nAdditional context:\n${JSON.stringify(context, null, 2)}`
    : "";

  const response = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: agent.maxTokens,
    temperature: agent.temperature,
    system: agent.systemPrompt,
    messages: [{ role: "user", content: `${input}${contextStr}` }],
  });

  const textBlocks = response.content.filter(
    (block): block is Anthropic.Messages.TextBlock => block.type === "text"
  );
  return {
    ...task,
    output: textBlocks.map((b) => b.text).join("\n\n"),
    status: "completed",
  };
}

Each task gets a unique ID, tracks its lifecycle (pending to running to completed / failed), and returns structured output. The type guard on TextBlock handles Claude's multi-block response format cleanly.

Trial Rate Limiting Without a Database

For the free trial, I wanted users to try agents without signing up — but I also needed to prevent abuse. The solution: an in-memory Map with IP-based tracking, scoped to 5 requests per 24-hour window.

const trialUsage = new Map<string, { count: number; resetAt: number }>();

const TRIAL_LIMIT = 5;
const WINDOW_MS = 24 * 60 * 60 * 1000; // 24 hours

function checkTrialLimit(ip: string): { allowed: boolean; remaining: number } {
  const now = Date.now();
  const entry = trialUsage.get(ip);

  if (!entry || now > entry.resetAt) {
    trialUsage.set(ip, { count: 0, resetAt: now + WINDOW_MS });
    return { allowed: true, remaining: TRIAL_LIMIT };
  }

  if (entry.count >= TRIAL_LIMIT) {
    return { allowed: false, remaining: 0 };
  }

  return { allowed: true, remaining: TRIAL_LIMIT - entry.count };
}

Is this production-grade rate limiting? No. The Map resets on every Vercel cold start. But for a trial feature, that's actually a feature — it's forgiving, and a hard-core abuser who discovers the reset behavior still isn't costing much since each request is a single Claude call. When you need actual metering, move to Redis or a database. For launch, this took 20 minutes to build and it works.

The trial endpoint also caps input at 3,000 characters to prevent prompt-stuffing:

const trimmedInput = body.input.slice(0, 3000);
const task = await runAgent(agentId, trimmedInput, body.context);
const remainingAfter = recordUsage(ip);

When the limit is hit, the response includes an upgrade URL:

if (!allowed) {
  return NextResponse.json(
    {
      error: "trial_limit_reached",
      message: "You've used all 5 free trial runs. Upgrade to keep using AgentDesk.",
      upgradeUrl: "https://buy.stripe.com/...",
    },
    { status: 429 }
  );
}

A cleanup interval runs every 10 minutes to prune expired entries and prevent the Map from growing unbounded — a detail that's easy to forget and causes a slow memory leak if you skip it.

Stripe Subscription Tiers

Billing is structured as three tiers with clear capability gates. The Starter plan ($99/month) gives access to the Intake Agent only. Professional ($349/month) unlocks all three agents. Agency ($799/month) adds unlimited tasks:

export const PLANS = {
  starter: {
    name: "Starter",
    priceId: process.env.STRIPE_PRICE_STARTER!,
    agents: ["intake"],
    monthlyPrice: 99,
    taskLimit: 100,
  },
  professional: {
    name: "Professional",
    priceId: process.env.STRIPE_PRICE_PROFESSIONAL!,
    agents: ["intake", "proposal", "report"],
    monthlyPrice: 349,
    taskLimit: 500,
  },
  agency: {
    name: "Agency",
    priceId: process.env.STRIPE_PRICE_AGENCY!,
    agents: ["intake", "proposal", "report"],
    monthlyPrice: 799,
    taskLimit: -1, // unlimited
  },
} as const;

Price IDs come from environment variables (never hardcoded), and the as const assertion gives us full type narrowing on PlanId. The agents array doubles as an access control list — the API checks whether the user's plan includes the requested agent before running it.

The Stripe integration uses SDK v21 with the latest API version. Checkout sessions are created server-side, and a webhook handler processes checkout.session.completed and customer.subscription.updated events to keep plan status in sync.

Deployment

The whole thing deploys to Vercel with zero configuration beyond environment variables. The App Router's file-based routing means every file in src/app/api/ is automatically a serverless function. No Express server, no Docker, no infrastructure management.

Key environment variables:

ANTHROPIC_API_KEY — Claude API access
STRIPE_SECRET_KEY — Stripe billing
STRIPE_PRICE_STARTER, STRIPE_PRICE_PROFESSIONAL, STRIPE_PRICE_AGENCY — plan price IDs
STRIPE_WEBHOOK_SECRET — webhook signature verification

One Vercel gotcha: when setting env vars, use printf instead of echo to pipe values. echo adds a trailing newline that corrupts Stripe price IDs and causes silent checkout failures.

What I'd Do Differently

Persistent rate limiting from day one. The in-memory approach works for launch, but the moment you scale past one serverless instance, users get free resets. Vercel KV or Upstash Redis is the obvious fix and takes about 30 minutes to swap in.

Streaming responses. The current implementation waits for the full Claude response before returning. For the Proposal Agent, which generates 4,096 tokens of structured markdown, that's a noticeable wait. Server-Sent Events via the App Router's streaming support would improve perceived latency significantly.

Multi-turn agent conversations. Right now each agent call is a single turn. The next iteration will add conversation history so agents can ask clarifying questions before producing output — especially useful for the Intake Agent when an inquiry is ambiguous.

Try It

AgentDesk is live with a free trial — no signup required. Paste a client inquiry into the Intake Agent, feed call notes into the Proposal Agent, or drop project metrics into the Report Agent and see what comes back.

Try the agents at agentdesk.thewedgemethodai.com/dashboard

If you're building something similar, the key architectural insight is this: define agents as typed configuration objects, not ad-hoc prompt strings scattered across your codebase. It makes them testable, composable, and easy to add new agents without touching the engine.

Want this automated? Check out WEDGE Method — the AI OS built specifically for consultants and knowledge workers.

Try WEDGE free for 7 days → thewedgemethodai.com

I Built AI Agents That Write Consulting Proposals in 30 Seconds — Here's What Happened

WEDGE Method Dev — Thu, 26 Mar 2026 11:07:18 +0000

Want to save 15+ hours of consulting work every week?

WEDGE Method AI is the AI operating system built for independent consultants.

→ Client research briefs in 8 minutes (vs 3 hours)
→ Proposals in 20 minutes (vs 4 hours)

→ Reports in 1 hour (vs a full day)

Try it free for 7 days →

5 Signs Your Consulting Firm Needs AI Agents (Not More Staff)

WEDGE Method Dev — Thu, 26 Mar 2026 04:53:13 +0000

Want to save 15+ hours of consulting work every week?

WEDGE Method AI is the AI operating system built for independent consultants.

→ Client research briefs in 8 minutes (vs 3 hours)
→ Proposals in 20 minutes (vs 4 hours)

→ Reports in 1 hour (vs a full day)

Try it free for 7 days →

AgentDesk vs Hiring Another Consultant: A Cost Comparison

WEDGE Method Dev — Thu, 26 Mar 2026 04:52:46 +0000

Your firm needs more capacity. Do you hire another $150K consultant, or deploy AI agents that work 24/7 for $349/month?

The Real Cost of a New Hire

Cost	Annual
Base salary	$120,000-$180,000
Benefits (30%)	$36,000-$54,000
Office/equipment	$12,000
Recruiting costs	$25,000
Training (3-month ramp)	$30,000 in lost productivity
Total Year 1	$223,000-$301,000

The Cost of AgentDesk

Plan	Monthly	Annual	What You Get
Starter	$99	$1,188	Intake Agent (lead qualification)
Professional	$349	$4,188	All 3 agents (intake + proposals + reports)
Agency	$799	$9,588	Unlimited tasks for your whole team

What AgentDesk Handles vs What It Doesnt

AgentDesk excels at:

Qualifying inbound leads (Intake Agent)
Generating first-draft proposals (Proposal Agent)
Creating executive reports from data (Report Agent)
Working 24/7 with instant response times
Maintaining consistent quality across all outputs

You still need humans for:

Relationship building and client meetings
Complex strategy and creative problem-solving
Final review and approval of deliverables
New business development and networking

The Hybrid Approach

The smartest firms arent choosing AI or humans — theyre using AI to make their humans more effective:

AI handles the admin — intake, first drafts, reports
Humans handle the relationships — meetings, strategy, closing
Result: Each consultant can handle 3x more clients

ROI Calculation

A 5-person firm on the Professional plan ($349/mo):

Saves: 100 hours/month of admin work
At $150/hr billing rate: $15,000/month in recovered revenue
Cost: $349/month
ROI: 43x return

Compare that to hiring consultant #6 at $223K/year who still spends 42% of their time on admin.

Try It

AgentDesk — see all three agents in action from the dashboard.

Built by WEDGE Method LLC

Want this automated? Check out WEDGE Method — the AI OS built specifically for consultants and knowledge workers.

Try WEDGE free for 7 days → thewedgemethodai.com

Stop Writing Proposals by Hand: How AI Agents Generate Winning Proposals in 30 Seconds

WEDGE Method Dev — Thu, 26 Mar 2026 04:37:32 +0000

Want to save 15+ hours of consulting work every week?

WEDGE Method AI is the AI operating system built for independent consultants.

→ Client research briefs in 8 minutes (vs 3 hours)
→ Proposals in 20 minutes (vs 4 hours)

→ Reports in 1 hour (vs a full day)

Try it free for 7 days →