Points Economies for AI Agents: How to Design and Ship Them

If you're building an AI agent ecosystem, money is the wrong primitive. Points are better. They're flexible, less regulated, and you can tune them to shape behavior. This is the core mechanic behind TaskBounty-style marketplaces.

This guide shows how to design a points economy, implement it in TypeScript/Convex, and avoid the traps that make economies collapse.

Why Points Beat Real Money

Points give you control:

• No payment rails required
• Dynamic incentives (you can boost categories)
• Inflation control (tune issuance)
• Safer experimentation

Money is rigid and regulated. Points are a sandbox.

Economy Design Basics

1) Define Earning Paths

Decide what behavior you want to reward:

• Completing tasks
• Submitting high-quality agent outputs
• Participating in duels
• Giving feedback

Each action should map to a clear, predictable reward.

2) Define Spending Paths

Points need sinks or inflation spirals. Common sinks:

• Unlock premium agents
• Boost visibility in the marketplace
• Access to bounties
• Cosmetic upgrades

3) Control Inflation

If you issue too many points, they lose meaning. Tactics:

• Daily caps on earnings
• Diminishing returns for repeated actions
• Seasonal resets or soft decay

4) Keep It Transparent

Users should understand why they earned points. Ambiguity kills trust.

Implementation Pattern (Convex)

Here's a minimal points ledger design:

// convex/schema.ts
export default defineSchema({
  users: defineTable({
    name: s.string(),
    balance: s.number(),
  }),
  pointsLedger: defineTable({
    userId: s.id("users"),
    delta: s.number(),
    reason: s.string(),
    createdAt: s.number(),
  }),
});

Add Points

// convex/points.ts
export const addPoints = mutation({
  args: { userId: v.id("users"), amount: v.number(), reason: v.string() },
  handler: async (ctx, args) => {
    const user = await ctx.db.get(args.userId);
    if (!user) throw new Error("User not found");

    await ctx.db.patch(args.userId, {
      balance: user.balance + args.amount,
    });

    await ctx.db.insert("pointsLedger", {
      userId: args.userId,
      delta: args.amount,
      reason: args.reason,
      createdAt: Date.now(),
    });
  },
});

Spend Points

export const spendPoints = mutation({
  args: { userId: v.id("users"), amount: v.number(), reason: v.string() },
  handler: async (ctx, args) => {
    const user = await ctx.db.get(args.userId);
    if (!user || user.balance < args.amount) throw new Error("Insufficient points");

    await ctx.db.patch(args.userId, {
      balance: user.balance - args.amount,
    });

    await ctx.db.insert("pointsLedger", {
      userId: args.userId,
      delta: -args.amount,
      reason: args.reason,
      createdAt: Date.now(),
    });
  },
});

This ledger pattern keeps everything auditable.

Daily Engagement Loops

To drive repeat usage:

• Daily tasks (complete 1 task = +10 points)
• Streak bonuses (5-day streak = +50)
• Leaderboard resets (weekly top performers)

The key is to reward consistent behavior, not just one‑off spikes. If agents compete in duels or ranked challenges, ELO rankings provide the competitive layer that makes points meaningful.

Leaderboards and Visibility Boosts

A points system becomes a marketplace mechanic when points can be used to buy visibility:

• Promote your agent for 24 hours
• Highlight your task bounty
• Unlock premium placements

This creates a natural sink and makes points feel valuable.

Anti-Gaming Measures

Points economies attract gaming. Plan for it early:

• Rate limits: cap points per day
• Duplicate detection: block repeated low-quality actions
• Human review for suspicious spikes
• Cooldowns on high-value actions

If you don't plan for abuse, it will define your economy. Gamasutra's analysis of virtual economies and Anthropic's safety research both highlight that unchecked reward loops degrade system quality fast.

TaskBounty Example

In TaskBounty, users post tasks with point rewards. Agents (or humans) complete them and earn points. Those points are then spent to post higher-value tasks or boost listings.

This creates a closed loop:

1. Points are issued for completions
2. Points are spent to post new bounties
3. Demand stays high because points are needed to participate

Practical Tips

• Start with small numbers. You can always adjust.
• Track all point changes in a ledger.
• Make the top 10 leaderboard visible.
• Add sinks early, not later.

Final Thoughts

A points economy is less about currency and more about behavior design. It's the core mechanic that turns your agent ecosystem into a living system.

If you're building TaskBounty or any agent marketplace, start with points. You can always layer in real money later - but points will get you to product-market fit faster.

Points pair naturally with competitive mechanics - see the ELO rankings guide for implementing leaderboards that drive real improvement. And if you want agents with distinct personalities competing in your marketplace, the SOUL.md pattern gives each agent a consistent identity that users connect with. The AI Agent Masterclass covers building these systems end to end, from agent architecture to marketplace mechanics.