Model Tiers & Credits

Choose the right quality/speed/cost tradeoff for each use case with ProposeFlow's model tier system.

Overview

ProposeFlow uses a credit-based system to normalize costs across different AI model quality tiers. Instead of paying different rates for different models, you consume credits at tier-specific rates—giving you predictable costs and the flexibility to choose the right model for each task.

Key benefit: Use fast, cheap models for simple autocomplete suggestions while reserving high-quality models for important content—all with a unified billing model.

Available Model Tiers

ProposeFlow offers three model tiers, each optimized for different use cases:

Tier	Credit Rate	Best For
`fast`	0.1x	Quick suggestions, autocomplete, high-volume tasks
`balanced`	1.0x	General use cases, most workflows (default)
`quality`	5.0x	Complex reasoning, high-stakes content, best output

When to Use Each Tier

Fast Tier (0.1x credits)

• Autocomplete suggestions as users type
• Quick task name or title generation
• Tag suggestions based on content
• High-volume background processing
• Draft previews before final generation

Balanced Tier (1.0x credits)

• Standard blog posts and articles
• Recipe generation from ingredients
• Task descriptions and project summaries
• Email drafts and messages
• General content creation workflows

Quality Tier (5.0x credits)

• Technical documentation and specifications
• Legal or compliance content
• Complex multi-step reasoning
• Customer-facing communications
• Content requiring nuanced understanding

Setting Model Tier

Model tier can be configured at multiple levels, with higher specificity taking precedence:

Per-generation — Highest priority, overrides all other settings
Per-schema — Default for all generations of that schema
Per-application — Default for your entire application
System default — Falls back to balanced

Per-Generation Override

per-generation.ts

// Use fast tier for quick suggestions
const { proposal } = await pf.generate('taskTitle', {
  input: 'Suggest a title for my project about user onboarding',
  modelTier: 'fast',
});

// Use quality tier for important content
const { proposal } = await pf.generate('technicalSpec', {
  input: 'Write a technical specification for the auth module',
  modelTier: 'quality',
});

Schema-Level Default

schema-default.ts

// Set default tier when registering a schema
await pf.schemas.register('quickSuggestion', {
  version: '1.0.0',
  jsonSchema: QuickSuggestionSchema,
  modelTier: 'fast',  // All generations use fast tier by default
});

await pf.schemas.register('legalDocument', {
  version: '1.0.0',
  jsonSchema: LegalDocumentSchema,
  modelTier: 'quality',  // All generations use quality tier by default
});

Application-Level Default

Set your application's default model tier in the dashboard settings. This applies to all schemas and generations that don't specify a tier.

Credit Calculation

Credits are calculated based on tokens consumed and the model tier rate:

Credits = (tokens / 1000) × tierRate

Example Calculations

Tokens	Tier	Calculation	Credits
2,000	`fast`	(2000 / 1000) × 0.1	0.2
5,000	`balanced`	(5000 / 1000) × 1.0	5.0
3,000	`quality`	(3000 / 1000) × 5.0	15.0

Accessing Credit Usage

credit-usage.ts

const { proposal, generation } = await pf.generate('blogPost', {
  input: 'Write a post about TypeScript patterns',
  modelTier: 'balanced',
});

// Generation includes credit information
console.log(generation.modelTier);       // 'balanced'
console.log(generation.promptTokens);    // 1500
console.log(generation.completionTokens); // 3500
console.log(generation.credits);         // 5.0

Cost Optimization Strategies

1. Match tier to task complexity

Don't use quality tier for simple tasks. A tag suggestion doesn't need the same model as a technical specification.

2. Set smart schema defaults

Configure the appropriate tier at the schema level so you don't need to specify it on every generation.

3. Use fast tier for previews

Generate quick previews with the fast tier, then regenerate with balanced or quality when the user wants to finalize.

4. Monitor usage in analytics

Track credit consumption by schema in the Analytics dashboard to identify optimization opportunities.

Monitoring Credit Usage

Track your credit consumption through the API or dashboard.

usage-api.ts

// Get current period usage
const usage = await pf.usage.current();

console.log(usage.credits.used);      // 1,250.5
console.log(usage.credits.limit);     // 10,000
console.log(usage.credits.remaining); // 8,749.5
console.log(usage.period.start);      // '2025-01-01T00:00:00Z'
console.log(usage.period.end);        // '2025-02-01T00:00:00Z'

// Breakdown by tier
console.log(usage.byTier);
// { fast: 50.2, balanced: 800.3, quality: 400.0 }

You can also view detailed usage breakdowns in your dashboard, including per-schema credit consumption and historical trends.

→SDK Configuration — Configure model tiers in the SDK
→Generating Proposals — Per-generation tier selection
→Analytics — Track credit consumption and usage patterns