> ## Documentation Index
> Fetch the complete documentation index at: https://docs.actionmodel.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Token Utility ($LAM)
> The fuel that powers every action in the AI revolution. Learn how $LAM tokens create a self-sustaining economy where usage drives value, creators earn, and the community owns the future of automation.
**LAM is Action Fuel**: Unlike speculative tokens, LAM has real utility—every click, type, and navigation performed by AI agents consumes \$LAM. This isn't a currency; it's the gasoline that powers the automation economy.
## The \$LAM Token: Powering the Action Economy
### More Than a Token—It's Ownership
LAM represents a fundamental shift in how AI value is created and distributed. When Big Tech trains on your data to build their AI, they keep 100% of the profits while you get nothing. When Action Model's AI performs actions, the value flows back to the community through \$LAM.
Every agent click, type, scroll, upload, or form submit consumes \$LAM as fuel
Decentralized Autonomous Organization - Action Model is the Uprising
Earn from your workflows and agents in the creator economy
Contributors help train the Large Action Model and earn rewards
Partners and devs preload \$LAM to fund fleets of agents
Build your network through referrals, affiliates, and quest rewards
## How \$LAM Powers Every Action
### The Action Loop
The LAM receives the current state: screenshot, DOM, user goal, and action history
The AI searches the Action Tree to find the optimal next action
The LAM determines the precise GUI action to execute
This single action consumes \$LAM tokens based on the current pricing model
The action is performed (click, type, navigate, etc.)
Process repeats until the goal is achieved or time expires
**Every Action Loop = Billable Action**: Each loop through this process is one action that consumes \$LAM. A complex workflow might require 100+ actions, creating continuous token demand.
## \$LAM Token Overview
**LAM is Action Fuel:** Every GUI action executed by a LAM agent consumes \$LAM.
**Action Price is fixed** by LAM version (e.g., LAM-1 = \$0.01/action), while the number of tokens per action floats with the token price.
Each consumed action distributes tokens: **Creator Distribution** (33%), **Burn** (34%), **Ecosystem** (33%).
**B2C + B2B + Partners create continuous buy pressure.** \
Subscriptions and API usage require \$LAM purchases to fund actions
**Because a share of every action is burned/locked**, usage reduces supply, increasing token value
## Token Economics Model
### Fixed USD Pricing, Floating Token Cost
**Price Stability for Businesses**: The USD cost per action is fixed by LAM version (e.g., LAM-1 = \$0.01/action), while the number of tokens consumed adjusts with market price. This gives businesses predictable usage limits and costs while allowing token value to appreciate.
### Pricing Formula
For LAM version `v` with USD price per action `pv`:
**Tokens Required Per Action:**
```
τ(v,t) = pv / Pt
```
Where:
* `τ(v,t)` = Tokens required per action at time t
* `pv` = USD price per action for version v
* `Pt` = Market price of \$LAM in USD at time t
### LAM-1 Examples (p1 = \$0.01/action)
| Token Price | Tokens Per Action | 1000 Actions Cost |
| ----------- | ----------------- | ----------------- |
| \$0.001 | 10 tokens | 10,000 tokens |
| \$0.01 | 1 token | 1,000 tokens |
| \$0.10 | 0.1 tokens | 100 tokens |
| \$1.00 | 0.01 tokens | 10 tokens |
**Key Insight**: As token price increases, fewer tokens are needed per action, benefiting early holders.
## Token Distribution Per Action
### Where Every \$LAM Goes
When an action consumes tokens, they are distributed as follows:
**Marketplace Rewards**
Goes to workflow creators based on their [Creator Epoch](/tokenomics/point-tiers-and-epochs#creator-epochs-permanent-marketplace-rewards) when their automations are used
**Deflationary Mechanism**
Permanently removed from circulation, creating scarcity with every action
**Platform Growth**
Powers ecosystem development, operations, and community initiatives
### Distribution Mathematics
| Distribution | Percentage | Formula | Purpose |
| ---------------- | ---------- | -------------------- | ------------------------------------------------------- |
| **💡 Creator** | Up to 33% | `(≤0.33) × τ` tokens | Rewards workflow creators based on Creator Epoch |
| **🔥 Burn** | 34% | `0.34 × τ` tokens | Permanently removed from circulation, creating scarcity |
| **🌱 Ecosystem** | 33% | `0.33 × τ` tokens | Powers ecosystem growth, development, and operations |
**Creator Epoch Rewards**: The actual creator percentage varies by when workflows are published. See [Creator Epoch table](/tokenomics/marketplace-distributions#creator-epochs-time-based-reward-tiers) for specific reward rates.
### Example Distribution
| Action Size | Tokens Consumed | 💡 To Creator | 🔥 Burned | 🌱 Ecosystem |
| ----------- | --------------- | ------------- | ------------ | ------------ |
| Small Task | 10 tokens | 3.3 tokens | 3.4 tokens | 3.3 tokens |
| Medium Task | 100 tokens | 33 tokens | 34 tokens | 33 tokens |
| Large Task | 1,000 tokens | 330 tokens | 340 tokens | 330 tokens |
| Enterprise | 10,000 tokens | 3,300 tokens | 3,400 tokens | 3,300 tokens |
## The B2B Buyback Loop
### How Business Demand Drives Token Value
Enterprise pays \$1,000-2,000/month per AI agent
Subscription revenue used to purchase \$LAM from market to fund Action Loop fuel
AI agents perform actions, consuming \$LAM as fuel
Up to 33% to creators, 34% burned, 33% to ecosystem
Burning reduces total supply permanently
Decreased supply + continued demand = price appreciation
### The Virtuous Cycle
**Self-Reinforcing Economics**: Each step in the cycle strengthens the next, creating exponential growth. More usage leads to more burning, which increases scarcity, driving up value, attracting more creators, who build better automations, which attracts more businesses.
## Token Utility Ecosystem
### Multiple Demand Drivers
### Direct API Usage
**Developers and Partners**
* Pre-load \$LAM for API calls
* Each API action consumes tokens
* Usage-based pricing model
* No subscription required
**Consumption Rate**
* Average workflow: 50-200 actions
* Complex automation: 500+ actions
* Daily agent operations: 10,000+ actions
### Creator Economy
**Workflow Publishing**
* Creators earn 33% of tokens consumed
* Passive income from popular workflows
* Incentive for quality automation
**Success Examples**
* Top workflow: 1M+ monthly executions
* Creator earnings: \$3,000+/month
* No maintenance required
### DAO Participation
**Voting Power**
* Propose platform changes
* Influence development priorities
**Staking Benefits**
* Enhanced voting weight
* Priority feature access
* Revenue sharing participation
### Earn by Contributing
**Data Contribution**
* Browser extension training
* Active workflow labeling
* Platform bounties
* Referral rewards
## Subscription Discount Model
### Pay with \$LAM, Save 10%
Businesses can pay subscriptions directly in \$LAM tokens for a 10% discount:
**Example**: \$1,000 monthly subscription
* Pay in USD: \$1,000
* Pay in $LAM: $900 worth of tokens
This incentivizes businesses to hold and use \$LAM, creating additional buy pressure.
### Discount Formula
```
Tokens Required = S × (1 - d) / Pt
```
Where:
* S = Subscription amount in USD
* d = Discount rate (0.10 for 10%)
* Pt = Current token price
## Deflationary Dynamics
### Why \$LAM Becomes More Valuable Over Time
**34% of Every Action**
* Millions of daily actions
* Permanent supply reduction
* Accelerates with adoption
* Cannot be reversed
**Multiple Demand Sources**
* B2B subscriptions
* API usage
* Marketplace activity
* Speculation and holding
## Real-World Usage Examples
### Understanding Token Consumption
**Task:** Check Gmail, summarize important emails, create daily digest
**Actions Required:** \~50
* Login: 5 actions
* Navigate inbox: 10 actions
* Read emails: 20 actions
* Create summary: 10 actions
* Send digest: 5 actions
**AI Agent Cost** (at $0.01 token price): 50 tokens = $0.50
**Human Cost** (15 minutes @ $30/hour): $7.50
**Savings:** 93% cost reduction
**Task:** Post content across LinkedIn, Twitter, Instagram
**Actions Required:** \~150
* Content preparation: 20 actions
* LinkedIn posting: 40 actions
* Twitter posting: 40 actions
* Instagram posting: 50 actions
**AI Agent Cost** (at $0.01 token price): 150 tokens = $1.50
**Human Cost** (45 minutes @ $30/hour): $22.50
**Savings:** 93% cost reduction
**Task:** Extract data from 100 invoices, update CRM, generate report
**Actions Required:** \~2,000
* Invoice processing: 1,500 actions
* CRM updates: 300 actions
* Report generation: 200 actions
**AI Agent Cost** (at $0.01 token price): 2,000 tokens = $20.00
**Human Cost** (8 hours @ $30/hour): $240.00
**Savings:** 92% cost reduction
## Formal Tokenomics Model
### Mathematical Framework
### Pricing Model (Versioned "Price Per Action")
* Let `pᵥ` be the **USD price per action** for model version `v` (e.g., LAM-1 has `p₁ = $0.10` per action)
* Let `Pₜ` be the **market price of \$LAM in USD** at time `t`
* **Tokens required per action** for version `v` at time `t` is:
**Formula:**
```
τᵥ,ₜ = pᵥ / Pₜ
```
**Fractional tokens** are supported to meter actions precisely.
#### Examples (LAM-1):
* If `Pₜ = $0.01`, then `τ₁,ₜ = 0.10 / 0.01 = 10 tokens/action`
* If `Pₜ = $0.10`, then `τ₁,ₜ = 1 token/action`
* If `Pₜ = $1.00`, then `τ₁,ₜ = 0.1 token/action`
**USD cost per action is stable for developers; tokens per action adjusts automatically to market price.**
***
### Token Fuel Distribution (Per Action)
Let the distribution shares be:
* **Creator share** `μ = 0.33`
* **Burn share** `β = 0.34`
* **Ecosystem share** `ε = 0.33`
For one action that consumes `τ` tokens:
```
Creator tokens/action = μ · τ (if a Marketplace workflow was used)
Burned tokens/action = β · τ
Ecosystem tokens/action = ε · τ
```
#### USD Equivalents Per Action:
**USD to creator/action = μ · pᵥ**
**USD burned/action = β · pᵥ**
**USD to ecosystem/action = ε · pᵥ**
For LAM-1 (`p₁ = $0.10`): **0.034** is burned, and **\$0.033** to the ecosystem **per action**, independent of token price.
**No-Marketplace case**: If a run doesn't use a Marketplace workflow, the creator share can be (a) retained in an **Ecosystem Rewards** pool or (b) redirected to **Ecosystem**. The DAO should ratify the default.
***
### The Buyback Loop (Why Usage Creates Demand)
* **B2B subscriptions** (e.g., $1k–$2k per agent/month) and **API partners** include usage allowances measured in actions
* To deliver those actions, **operators must acquire \$LAM** (buy on the market or hold inventory)
* When actions run, tokens flow through the **Fuel distribution** above (with 34% burned)
#### Paying Subscriptions in \$LAM (10% Discount)
* Paying a $1,000 subscription in $LAM yields a **10% discount**: you spend tokens equivalent to **\$900** at the time of payment
* Those tokens may be escrowed and released into the Fuel distribution as actions are consumed (implementation detail—DAO parameter)
**`Tokens needed to pay a subscription S in USD with a discount d:`**
**Formula:**
```
Tokens = S(1 - d) / Pₜ
```
***
### Advanced Tokenomics Calculations
#### Per-Action Accounting (LAM-v)
* **Tokens per action:** `τᵥ,ₜ = pᵥ / Pₜ`
* **Burn:** `Bₐcₜ = βτᵥ,ₜ`
* **Creator:** `Mₐcₜ = μτᵥ,ₜ · 𝟙marketplace`
* **Ecosystem:** `Eₐcₜ = ετᵥ,ₜ`
#### Network-Level, Period t (e.g., monthly)
Let `Aₜ` be actions executed in `t`. Then:
```
Tokens needed Dₜ = τᵥ,ₜ · Aₜ
Creator tokens Mₜ = μ · Dₜ · Pr(marketplace use)
Burned tokens Bₜ = β · Dₜ
Ecosystem tokens Eₜ = ε · Dₜ
USD spent on actions Uₜ = pᵥ · Aₜ (price-invariant)
```
#### Supply Dynamics
Let `Sₜ` be circulating supply at start of `t`. Let `Eₜ` be new emissions (training rewards, grants) approved by DAO.
**Supply Evolution:**
```
Sₜ₊₁ = Sₜ + Eₜ - Bₜ
```
**Conditions:**
* **Deflationary condition:** `Bₜ > Eₜ`
* **Neutral:** `Bₜ = Eₜ`
* **Inflationary:** `Bₜ < Eₜ`
**Break-even emissions (deflation-neutral):**
**Formula:**
```
E*ₜ = β · τᵥ,ₜ · Aₜ
```
#### "Half-Life" Under Constant Burn and No Emissions (Illustrative)
If actions are steady and `Eₜ = 0`, supply declines linearly. Time to reduce supply by half:
**Half-Life Formula:**
```
T₁/₂ = S₀ / (2 · Bₜ) = S₀ / (2 · β · τᵥ,ₜ · Aₜ)
```
## Token Training Distribution
### Rewarding Data Contributors
**Future Enhancement**: A portion of consumed \$LAM may be distributed to trainers who provided the action branches/trees used in executed workflows.
When users train the LAM by demonstrating actions (e.g., creating an AWS EC2 instance), they contribute to the Action Tree. When workflows use these trained paths, contributors earn rewards.
**Example Flow:**
1. 1,000 users train "Create EC2 Instance" action
2. Enterprise workflow uses this action path
3. Training distribution portion flows to those 1,000 trainers
4. Rewards proportional to contribution quality
**Benefits:**
* Rewards quality training data
* Incentivizes rare/complex actions
* Creates passive income for trainers
* Improves model accuracy
**Distribution Formula:**
```
Trainer Reward = (Quality Score × Usage Count) / Total Contributors
```
## Action Model API (Developers)
### Building with the Large Action Model
Unlike LLMs that output text, the LAM outputs **actions**. Each API call returns the next GUI action to execute, not generated content.
### Fundamental Differences
| Aspect | OpenAI API (LLM) | Action Model API (LAM) |
| ---------------- | ------------------- | ------------------------ |
| **Input** | Text prompt | Environment state + goal |
| **Output** | Generated text | Next action to execute |
| **Pricing Unit** | Input/output tokens | Actions performed |
| **Use Case** | Content generation | Task automation |
| **Billing** | Per token | Per action |
### Traditional LLM Flow
**Request:**
```json theme={null}
{
"prompt": "Write me a blog post about coffee",
"tokens": 7
}
```
**Response:**
```json theme={null}
{
"text": "The best coffee in the world is...",
"tokens": 1000
}
```
**Pricing (GPT-4):**
* Input: \$2/1M tokens
* Output: \$8/1M tokens
* Total cost: Based on combined token count
### LAM API Flow
**Request (Environment State):**
```json theme={null}
{
"goal": "Configure an AWS EC2 instance",
"history": ["logged_in", "dashboard_open"],
"screenshot": "base64_image",
"html": "",
"dom_elements": ["button#create", "input#name"],
"context": {
"instance_type": "t2.micro",
"region": "us-east-1"
}
}
```
**Response (Next Action):**
```json theme={null}
{
"action": "click",
"target": "button#create-instance",
"coordinates": {"x": 450, "y": 320},
"confidence": 0.98,
"tokens_consumed": 0.1
}
```
**Pricing:**
* LAM-1: \$0.01 per action
* No separate input/output costs
* Predictable automation expenses
### Quick Start
**1. Initialize Client:**
```javascript theme={null}
const LAM = require('@actionmodel/lam-sdk');
const client = new LAM({
apiKey: 'your-api-key',
preloadTokens: 1000 // Pre-purchase $LAM
});
```
**2. Execute Workflow:**
```javascript theme={null}
const result = await client.executeWorkflow({
workflowId: 'aws-ec2-setup',
parameters: {
instanceType: 't2.micro',
securityGroup: 'web-servers'
}
});
```
**3. Monitor Usage:**
```javascript theme={null}
console.log(`Actions used: ${result.actionsConsumed}`);
console.log(`Tokens spent: ${result.tokensUsed}`);
console.log(`USD cost: $${result.usdCost}`);
```
## Long-Term Economic Benefits
### Why \$LAM Creates Sustainable Value
**Predictable Costs for Business**
Customers think in actions and USD, not token volatility. The floating token model ensures:
* Fixed USD cost per action
* No surprise bills from price swings
* Easy budgeting for enterprises
* Seamless B2B adoption
**Counter-Cyclical Demand**
As \$LAM price changes, token consumption auto-adjusts:
* Price rises → Fewer tokens needed per action
* Price falls → More tokens needed per action
* USD revenue remains stable
* Natural price discovery mechanism
**Usage = Value**
Every action permanently removes supply:
* 34% burn rate compounds over time
* Millions of daily actions = massive burns
* Supply decreases while demand grows
* Mathematical path to appreciation
**Earn Real Value, Not Speculation**
Creators receive cash-equivalent rewards:
* 33% of action value in any market
* Income tied to usage, not price
* Incentivizes quality over hype
* Sustainable creator economy
## Why \$LAM is Different
### Comparing Token Models
| Feature | \$LAM | Traditional Tokens | Meme Coins |
| -------------------- | ---------------------- | -------------------- | ------------------- |
| **Utility** | Powers every AI action | Often minimal | None |
| **Demand Driver** | B2B usage + API calls | Speculation | Hype only |
| **Supply Mechanism** | Deflationary (burning) | Usually inflationary | Fixed/Inflationary |
| **Revenue Model** | Real business revenue | Token trading only | None |
| **Value Backing** | Automation demand | Project promises | Community sentiment |
## Getting Started with \$LAM
Start training the LAM and earning your first tokens
Deploy AI agents that consume \$LAM to automate tasks
Build automations and earn from every usage
***
**\$LAM isn't just a token. It's the fuel for the automation revolution.**
**Every action builds value. Every burn increases scarcity. Every holder owns the future.**