Why AgentE Exists
Virtual economies fail in predictable ways. AgentE prevents those failures autonomously — guided by 60 battle-tested principles.
Virtual economies are not an afterthought. They are the circulatory system of any game, metaverse, or digital world that involves ownership, trade, or progression. When the economy works, players never think about it. When it fails, nothing else matters.
AgentE is an autonomous economic intelligence layer. It observes the state of a live economy, diagnoses emerging pathologies, simulates the consequences of interventions, plans corrective action, and executes adjustments — all without human intervention. But autonomy without constraints is dangerous. These 60 principles are the constraints.
Each principle was born from a specific failure mode: a simulation that spiralled, a game economy that collapsed, a token system that bled dry. They are not theoretical. They are scars.
Architecture
Five stages. One loop. Every tick.
The Observer reads the raw state of the economy — balances, inventories, trade volumes, role distributions, satisfaction scores — and computes derived metrics like Gini coefficients, velocity, inflation rates, and mean-median divergence.
The Diagnostics Engine runs all 60 principles against the current metrics. Each principle is a pure function: metrics in, violation result out. When a principle fires, it reports severity, evidence, a suggested corrective action, its confidence level, and an estimated lag (how many ticks before the correction takes full effect).
The Simulator takes the top-priority suggested actions and runs Monte Carlo simulations (minimum 100 iterations per P43) to predict outcomes. If an intervention makes things worse in simulation, it is discarded before it ever touches the live economy.
The Planner enforces cooldowns (P27), caps adjustment magnitude (P26), and respects the lag principle (P39) — never re-adjusting a parameter before the previous adjustment has had time to manifest.
The Actuator applies the final, validated adjustments to the economy’s tunable parameters: yield rates, fees, costs, reward multipliers, and spawn weights.
How to Read This Document
Each principle follows the same anatomy.
Principles are numbered P1 through P60 and grouped by the economic domain they protect. The numbering is not sequential within groups — it reflects the order in which each principle was discovered during development.
Every principle includes a unique identifier, a short name, and a description explaining what it watches for and why. Where relevant, we explain the corrective action AgentE suggests when the principle is violated, and the estimated lag before that correction takes effect.
Some principles are structural — they are enforced by the architecture itself (the Planner, the Simulator, the config schema) rather than by a runtime check. These still appear as diagnostic monitors that fire when symptoms suggest the structural enforcement might be failing.
Quick Start
Three lines to connect. Your economy data stays in your backend.
import { AgentE } from '@agent-e/core'; const agent = new AgentE({ adapter: { // AgentE calls this every tick. // Return a snapshot of your economy — from YOUR database/API. getState: () => ({ tick: getCurrentTick(), currencies: getCurrencies(), // e.g. ['gold', 'gems'] systems: getSystems(), // e.g. ['crafting', 'arena'] roles: getRoles(), // e.g. ['warrior', 'merchant'] resources: getResources(), // e.g. ['ore', 'wood'] agentBalances: getBalances(), // agent → currency → amount agentRoles: getAgentRoles(), // agent → role marketPrices: getPrices(), // currency → resource → price recentTransactions: getTxns(), }), // AgentE tells you WHAT to change — you apply it setParam: async (param, value, scope) => { applyToYourEconomy(param, value, scope); }, }, // Register YOUR economy's tunable parameters parameters: [ { key: 'crafting_cost', type: 'cost', flowImpact: 'sink' }, { key: 'arena_reward', type: 'reward', flowImpact: 'faucet' }, { key: 'market_fee', type: 'fee', flowImpact: 'friction' }, ], mode: 'advisor', onDecision: (d) => console.log(d), }); agent.start(); // In your game loop: await agent.tick();
getState() pulls from your existing backend — whether that’s 50 players or 5 million. AgentE computes aggregate metrics (Gini, velocity, flow rates) and balances the economy as a whole.
The parameter names are yours. AgentE only cares about the type and flowImpact. Whether you call it craftingCost or forge_fee_multiplier, AgentE understands it as a cost-type sink and adjusts accordingly.
Parameter Registry
The core innovation. You register your parameters with semantic metadata, and AgentE's 60 principles target types — not names.
Every tunable parameter in your economy is registered with three pieces of metadata:
| Field | Purpose | Options |
|---|---|---|
type | What kind of lever is it? | cost, fee, reward, yield, rate, multiplier, threshold, weight, custom |
flowImpact | What does it do to currency flow? | sink, faucet, friction, redistribution, neutral |
scope | Where in the economy does it live? | { system?, currency?, tags? } |
When a principle says “decrease the fee in system_1”, the registry resolves that to your actual parameter name. This is what makes AgentE universal — the same 60 principles work across any economy because they operate on semantic types, never hard-coded names.
Universal by Design
Not a game tool, not a DeFi tool, not a marketplace tool. An economy tool.
The core SDK has zero domain-specific logic. It works for game economies, DeFi protocols, marketplace platforms, or any system with currencies, resources, and participants. The same architecture handles all of them because economic pathologies are domain-agnostic — inflation, hoarding, herding, and monopolization occur in every economy.
Multi-Everything
Multi-System — register multiple sub-systems (crafting, arena, marketplace), each tracked independently. Multi-Currency — every currency gets its own supply, velocity, Gini, inflation, and faucet/sink metrics. Multi-Resource — track resources, roles, pools, and market prices across the economy. Opt-in — only register what your economy has. No pools? Don’t register pool parameters. AgentE won’t touch what doesn’t exist.
Operating Modes
Full autopilot or human-in-the-loop. Your choice.
| Mode | Behavior |
|---|---|
autonomous | Full pipeline — observes, diagnoses, simulates, plans, and executes automatically. Every action is backed by Monte Carlo proof and auto-rolls back if it makes things worse. |
advisor | Full pipeline but stops before execution — emits recommendations for your approval. You review the simulation evidence and decide whether to apply each change. |
In advisor mode, every recommendation comes with the full simulation proof — the predicted outcome, the severity of the current violation, the confidence score, and the estimated lag before the correction takes effect. You approve or reject from the dashboard or programmatically via the event API.
Developer Controls
Lock, constrain, extend, veto. AgentE never overrides your intent.
// Lock a parameter — AgentE will NEVER adjust it agent.lock('your_param_name'); // Constrain a parameter to a range agent.constrain('another_param', { min: 0.5, max: 2.0 }); // Add your own principle agent.addPrinciple(myCustomPrinciple); // Veto specific actions before they execute agent.on('beforeAction', (plan) => { if (plan.parameterType === 'reward' && plan.direction === 'increase') return false; });
Locked parameters are invisible to the Planner — no principle will ever suggest modifying them. Constrained parameters can be adjusted, but only within your defined bounds. Custom principles run in the same pipeline as the built-in 60, sorted by severity alongside everything else. Vetoes fire after simulation but before execution, giving you final say over any action.
How Principles Are Evaluated
All 60 run every cycle. One fix at a time. Context resolves conflicts.
All 60 principles run every cycle against the same metrics snapshot. Every principle independently returns either “not violated” or a violation with a severity score (1–10) and confidence score (0–1). They are never evaluated in isolation or first-come-first-serve.
After all 60 have spoken, the Diagnoser sorts violations by severity descending, with confidence as a tiebreaker — then acts on only the single highest-severity violation per cycle. If P1 fires at severity 8 and P6 fires at severity 5 in the same tick, AgentE fixes P1 and leaves P6 for the next cycle. If P1 is resolved by then, P6 becomes the top issue and gets addressed.
This means principle conflicts resolve themselves through contextual severity. Two principles that want opposite things (e.g. P5 wants to reduce rewards for a crowded role, P37 wants to protect latecomer viability) never deadlock — whichever violation is more severe right now wins. A mild latecomer problem loses to a severe stampede; a critical latecomer crisis overrides a minor crowding issue.
Packages & Roadmap
Zero dependencies. Three packages. Three phases.
| Package | Description |
|---|---|
@agent-e/core | The SDK. Zero dependencies. All 60 principles, Observer, Diagnoser, Simulator, Planner, and Executor. |
@agent-e/adapter-game | Presets for game economies — pre-configured parameter templates for common game economy patterns. |
@agent-e/server | HTTP + WebSocket server for game engine integration. Includes the real-time dashboard at localhost:3100. |
Roadmap
Phase 1 — Game (Live Now): The core economic intelligence engine. 60 principles, 5-stage pipeline, Monte Carlo simulation. Built for game economies that need autonomous balancing.
Phase 2 — DeFi Protocol (Coming Soon): Extending AgentE into decentralized finance. Autonomous liquidity management, yield optimization, and protocol-level economic guardrails deployed directly on-chain.
Phase 3 — Marketplace (Coming Soon): A marketplace for economic intelligence. Share principles, trade adapters, and license battle-tested configurations across every ecosystem.
Security Model
How AgentE protects economies from external threats, internal misuse, and adversarial exploitation — by design, not by policy.
Server-Side Only
AgentE runs entirely within the game studio’s backend infrastructure. There is no client-side code, no player-facing API, no public endpoint. Players interact with the game client; AgentE sits behind the game server, reading economy metrics and adjusting parameters at the infrastructure level. A player cannot reach AgentE for the same reason they cannot reach the database — it is invisible to them. The studio’s existing server security protects AgentE the same way it protects everything else.
Constrain, Lock, Veto
Every parameter AgentE manages can be locked (never touched), constrained to a studio-defined range, or left open for autonomous adjustment. Studios define the boundaries; AgentE operates within them. If a parameter is locked, no principle violation — no matter how severe — will trigger a change. If a parameter is constrained, AgentE can adjust it only within the specified floor and ceiling. Custom principles can be added and any action can be vetoed. The studio retains full authority over what AgentE can and cannot do.
Simulation Before Execution
No action is applied to the live economy without first passing Monte Carlo simulation. AgentE generates 100+ simulated runs of the proposed change, measuring impact across all tracked metrics. If the simulation produces negative outcomes — cascading failures, metric degradation, unintended side effects — the action is rejected before it ever touches the live environment. This is not a safety net; it is the core execution gate. Nothing bypasses it.
Advisor Mode
For studios that are not ready for full autonomy, AgentE operates in Advisor mode. The entire pipeline runs — observation, diagnosis, simulation, planning — but execution is paused. AgentE emits a recommendation with full simulation proof, and a human reviews and approves before anything changes. This allows studios to build confidence in AgentE’s judgment before granting autonomous authority.
Anomaly Detection as Security
AgentE does not need to know how an exploit works. It detects the economic signature of exploitation — abnormal supply spikes, impossible flow rates, sudden wealth concentration — and responds to the effect. Whether the cause is a gold duplication bug, a bot farm, or a clever arbitrage player, the economic anomaly triggers the same diagnostic pipeline. Every principle runs every cycle, so exploits are caught at the speed of the tick interval, not at the speed of a human reviewing a dashboard days later.
Rule-Based, Not Learned
AgentE’s 60 principles are hardcoded, not trained from data. There is no machine learning model to poison, no training pipeline to corrupt, no adversarial inputs that can shift behavior. The principles are static rules derived from real economic failures. An attacker cannot manipulate AgentE’s decision-making by feeding it bad data, because AgentE does not learn from data — it evaluates against fixed rules. This is a deliberate architectural choice: determinism and auditability over adaptiveness.
Data Isolation
The core SDK (@agent-e/core) has zero runtime dependencies and makes no external network calls. Economy data stays in the studio’s infrastructure. AgentE does not phone home, does not transmit telemetry, and does not require an internet connection to function.
Billing Without Data Access
In a usage-based pricing model, AgentE meters its own output — not the studio’s economy data. Every decision AgentE makes is logged in its own audit trail: what principle fired, what action was proposed, whether it was executed or vetoed, and the simulation proof behind it. Billing queries this decision log to count actions taken and principles evaluated. It never reads, stores, or transmits the studio’s raw economy metrics — token prices, player balances, transaction volumes. The studio’s numbers stay in their backend. AgentE counts its own decisions. The billing API needs one number: how many decisions were made this billing cycle.
Cooldowns and Rate Limiting
AgentE enforces cooldown windows between actions to prevent oscillation and over-correction. Even if an attacker attempted to create rapid economic fluctuations to force AgentE into a destructive feedback loop, the cooldown mechanism ensures AgentE waits for the previous action to settle before reassessing. Combined with the simulation gate, this makes it structurally impossible for AgentE to be tricked into rapid-fire harmful changes.
Part II
The 60 Principles
Chapters 11–27 document every principle AgentE evaluates on each tick. They are grouped by the economic domain they protect — from supply chains to live operations.
Supply Chain
The physical flow of resources from extraction to consumption. If this breaks, nothing downstream survives.
If consumers need 10 wood per tick and producers only harvest 8, the economy starves within 20 ticks. AgentE continuously monitors the ratio of consumer demand to producer output across every resource type, flagging any sustained imbalance before inventory buffers run dry. This is the most fundamental check — without production-consumption parity, nothing else matters.
Raw materials appearing in finished-goods markets create noise that corrupts price signals and confuses participants. Each supply chain stage must hand off directly to the next, enforcing clear boundaries between extraction, refinement, manufacturing, and retail. When intermediaries are skipped, the economy loses its ability to price goods accurately at each tier.
A new producer who can’t afford inputs on their first tick is a bootstrap failure — they exist in the economy but can’t participate. Starting capital must cover at least one full production cycle, including input costs, tool fees, and any listing charges. Without this, new entrants are stillborn, and the economy’s ability to replace retiring participants collapses.
If crafters can produce every 3 ticks but materials arrive every 5, they idle 40% of the time. Input delivery rate must always exceed production rate, or the entire downstream chain starves while producers sit around waiting. AgentE monitors delivery-to-production ratios and flags bottlenecks before they cascade into full supply chain breakdowns.
Most player trades are liquidating unwanted surplus, not selling deliberate production. Price signals from disposal trades are fundamentally weaker demand indicators than production-for-sale trades — a player dumping 500 iron ore they don’t need sends a different signal than a miner selling 500 iron ore they specifically produced. AgentE weights these trade types accordingly when computing economic indicators.
Incentive Design
What makes agents choose one role over another. Get this wrong and the entire population herds into a single activity.
Profit formulas that ignore population cause stampedes. If one role pays a flat rate regardless of how many participants share it, the entire economy piles in — destroying margins for everyone and abandoning critical roles elsewhere. Profitability must always be calculated relative to the number of competitors in that role, so incentives naturally balance across the economy.
Any role without inverse-population scaling is a herd vulnerability. One unprotected role becomes the black hole that absorbs the entire economy — if mining pays the same whether 10 or 10,000 people do it, everyone will mine and nobody will craft. Every single role needs a crowding multiplier that reduces individual returns as participation increases.
When specialists exceed 70% of the population, the pot is at sustainability risk. The generalist majority funds the specialist minority through broader economic activity — taxes, fees, and consumption. Without enough generalists generating baseline economic flow, specialist reward pools starve and the entire incentive structure collapses.
If a role dominates above 30%, classify as structural (in dominantRoles config) or pathological. Structural dominance gets no intervention. Pathological dominance gets crowding pressure. This principle absorbs the old P28 — the classification step (structural vs pathological) is now unified here, preventing AgentE from fighting design intent.
Population Dynamics
How agents distribute across roles and how that distribution evolves. Herding kills economies faster than any other failure mode.
Without switching costs, agents oscillate between roles every tick and never reach equilibrium. If more than 5% of the population switches roles in a single period, it signals herd movement — everyone chasing the same opportunity simultaneously. Friction (cooldowns, retraining costs, reputation loss) dampens oscillation and lets markets settle into stable distributions.
When new agents enter the economy, they should fill underserved roles — not pile into whatever’s already popular. Spawn probability must be inversely proportional to current role count, so underpopulated roles naturally attract new entrants. Without this, imbalances compound with every new participant.
Corrections applied only at hard thresholds create delayed, jerky responses. Instead, apply light continuous pressure at all times (gentle nudges toward equilibrium) and strong pressure only at critical deviations (emergency interventions). This creates smooth, invisible corrections that players rarely notice, rather than sudden shocks that feel punitive.
A healthy economy needs Gamers, Traders, Collectors, Earners, and Builders coexisting. When any single persona type exceeds 40% of the population, the economy enters behavioral monoculture — it becomes fragile because everyone responds to shocks the same way. AgentE monitors persona distribution and adjusts incentives to maintain at least 3 distinct behavioral clusters.
Currency & Monetary Policy
Controlling the supply, velocity, and integrity of your economy's medium of exchange. The virtual equivalent of central banking.
Multiple independent currency sources create uncontrollable inflation risk. Just like a central bank controls money supply through one primary mechanism, a virtual economy needs one master dial that controls total currency inflow. Secondary faucets can exist, but they must be downstream of the primary control, not independent sources.
Every prize pool must be mathematically sustainable before it opens. If winRate × multiplier exceeds (1 - houseCut), the pot drains to zero — it’s just a matter of time. AgentE validates pot sustainability formulas before activation and monitors drain rates in real time, flagging any pool trending toward insolvency.
Resource gathering (collecting wood, mining ore) is not the same as currency injection (earning gold). Confusing the two creates accounting errors that make monetary policy impossible. AgentE distinguishes between resource creation, resource transformation, and actual currency injection, tracking each separately to maintain accurate economic models.
Any pool (bank, reward pool) without a cap accumulates infinitely. A pool at 42% of total supply means 42% of the economy is frozen. Cap configurable (default 10%). Violation fires at 2× cap share of total supply. Without caps and decay, pools become economic black holes that drain the circulating supply.
Depleted pool with estimated high staking signals early-withdrawal abuse. This is a symptom detector — the penalty formula is developer responsibility. AgentE flags the conditions; you build the mechanic.
Money supply is meaningless if it’s not moving. An economy can have abundant currency but feel dead if everyone is hoarding. AgentE tracks velocity (transactions per total supply) as a primary health metric — low velocity despite adequate supply signals stagnation, which requires different interventions than actual scarcity.
In barter-heavy economies, no single commodity naturally stabilizes as the universal unit of account. Multiple items rotate as de facto currency, but none locks in permanently. If a standard unit of account is needed for economic stability, it must be explicitly designed and enforced — emergence alone won’t produce one reliably.
Bootstrap & Launch
The first 30 ticks define whether an economy lives or dies. These principles protect the fragile genesis period.
Any intervention before tick 30 is premature. The economy needs time to bootstrap with designed distributions. Early intervention against designed dominance can kill the economy instantly — you would be “fixing” something that was intentional.
The first producer in the economy can’t create products from nothing. Materials must already exist in the world before the first production cycle can begin. This is the economic chicken-and-egg problem — AgentE ensures that world initialization includes sufficient raw materials for at least the first generation of production.
The world must feel abundant on day one. Scarcity is earned through play, not imposed at birth. If consumables are scarce at launch, new players hit walls immediately and churn before they experience the core loop. AgentE validates that initial supply buffers exceed projected early demand by a comfortable margin.
Feedback Loops
The self-correcting mechanisms that keep an economy from running away in either direction. Without feedback, every trajectory is a straight line to collapse.
Without entropy, wealth concentrates exponentially — the rich get richer with no counterforce. EVE Online survives because ships explode. Every stable economy needs aggressive sinks: decay rates, durability loss, maintenance costs, or expiration timers that force resources back into circulation and prevent runaway hoarding.
If 10,000 swords exist but the NPC vendor still sells at the Day-1 price, the market is lying. Prices must reflect total inventory, production rates, and consumption patterns — not static values set at design time. AgentE monitors price-to-supply ratios and flags disconnects where prices no longer reflect economic reality.
Producers who don’t check market conditions before producing create chronic overproduction. Every production decision should consider current supply, demand, and margin — otherwise agents pour resources into goods nobody wants. AgentE ensures production signals incorporate market feedback to prevent wasteful overproduction cycles.
A trade that yields 100 gold is worthless if there’s nobody to buy the output. Theoretical profit that ignores liquidity is phantom profit — it looks great on paper but never materializes. AgentE factors market depth, buyer availability, and transaction feasibility into profitability calculations, not just gross margin.
Agents stuck waiting for resources, market access, or role availability represent a silent bottleneck. If blocked agents don’t experience accelerated wealth decay, they accumulate as invisible deadweight — technically present but economically inactive. Faster decay on blocked agents creates urgency to switch roles or adapt, keeping the economy dynamic.
Regulator Behavior
Rules about how AgentE itself should behave when intervening. The regulator regulating the regulator.
Adjusting sinks to fix inflation is pulling the wrong lever — inflation is a faucet problem, not a sink problem. AgentE maps each economic pathology to its root cause and selects the intervention that addresses the actual mechanism, not just the symptom. Wrong-lever interventions create secondary distortions that are often worse than the original problem.
A 1% adjustment per tick is better than a 10% correction once. Gradual pressure is invisible to players — they don’t notice the economy gently steering itself. Sudden shocks feel like punishment and erode trust. AgentE defaults to continuous micro-adjustments, reserving large interventions only for genuine emergencies.
High churn combined with low satisfaction may indicate oscillation from rapid adjustments. Cooldown enforcement is structural (handled by the Planner). This principle acts as a symptom detector — when the diagnostic fires, it signals that recent adjustments may have been too frequent or too aggressive.
Merged into P8. The classification step (structural vs pathological) is now part of P8’s check. A designed dominant role should not trigger population suppression. AgentE distinguishes between roles that are dominant by design and roles that took over unexpectedly.
High churn may indicate unexplained changes. Logging enforcement is structural (handled by DecisionLog). This principle flags high churn as a signal to review recent decisions — if players are leaving, the first question is whether they understood why things changed.
Market Dynamics
The sweet spot between scarcity and abundance. Too little and players leave frustrated. Too much and there's nothing to strive for.
The ideal economic state is maximum demand from supply being just scarce enough to worry about — but not so scarce that it frustrates. When demand drops, the economy has oversupply and feels dead. When frustration rises, there’s undersupply and players leave. AgentE continuously searches for the sweet spot where scarcity drives engagement without crossing into frustration.
A static scarcity threshold combined with player progression means players will inevitably outgrow the challenge. As participants get stronger and more efficient, the scarcity threshold must shift upward to maintain tension — otherwise the economy becomes trivially easy and all engagement evaporates.
With N tradeable items, there are (N-1)N/2 relative prices to track. With thousands of items, no single agent — human or AI — can monitor them all. Economies with large item catalogs must be designed for distributed self-organization through market mechanisms, not centralized pricing by a regulator. AgentE focuses on aggregate health metrics rather than trying to manage individual prices.
Measurement & Monitoring
You can't fix what you can't see. These principles define what AgentE watches and at what resolution.
Time-to-currency and currency-to-items ratios are the fundamental anchor values of any economy. When 1 hour no longer equals X gold, or X gold no longer buys Y items, the economy has drifted. AgentE tracks these anchor ratios continuously and raises alerts when any drift exceeds 20%, signaling that the core value relationships are breaking down.
A crisis visible at per-tick resolution may be completely invisible at per-100-tick resolution, and vice versa. AgentE monitors at three time scales simultaneously — fine (per-tick), medium (per-10-tick), and coarse (per-100-tick) — using ring buffers. When metrics diverge across resolutions, it signals a hidden crisis that single-resolution monitoring would miss entirely.
A virtual economy is never in true equilibrium — it oscillates around it. The aggregate arbitrage window across all relative prices serves as a live health metric. Rising arbitrage signals destabilization (prices are diverging from fundamentals), while falling arbitrage signals recovery (markets are correcting toward equilibrium). AgentE uses this as an early warning system.
Non-market exchanges — gifts, charity trades, social signaling, guild transfers — contaminate price signals if included in economic calculations. A player gifting a rare sword to a friend at zero cost doesn’t mean the sword is worthless. AgentE filters gift-like and below-market transactions before computing economic indicators, using trade-price-to-market-price ratios to detect non-market exchanges.
Wealth & Distribution
Inequality is inevitable. The question is whether it comes from skill or from the system itself.
A Gini coefficient of 0 is boring — everyone has the same and there is nothing to strive for. Healthy inequality from skill and effort is fine. Inequality from money (pay-to-win) is toxic. Below 0.10 Gini means the economy is too flat; above configurable thresholds means oligarchy. AgentE watches the Gini coefficient to ensure inequality stays within the productive range.
Resource Management
Resources are the physical substrate of the economy. Their lifecycle — creation, use, and destruction — determines economic health.
Nothing permanently lost means inevitable inflation — the economy endlessly accumulates until everything is worthless. EVE Online thrives precisely because ships explode, removing value from the system. Every stable economy needs aggressive sinks: item durability, repair costs, failed crafting, PvP loot destruction. Without destruction, creation becomes meaningless.
If resource respawn rate merely matches consumption (1×), the economy drifts toward permanent depletion — any demand spike causes a shortage with no buffer. At 2× replacement, there’s breathing room for spikes, seasonal events, and population growth. AgentE monitors replacement-to-consumption ratios for every resource and flags any that drop below the 2× safety margin.
Concentrated idle wealth (Gini above 0.55, top 10% holding over 60%, velocity below 5) signals hoarding. AgentE raises transaction fees as a proxy holding tax when these conditions are met. Decay, storage fees, and item expiry are developer-implemented mechanics — AgentE detects the conditions; you build the response.
System Design
Meta-principles about the economic system itself — how different mechanics interact and where complexity should be bounded.
When one system is deterministic (crafting always succeeds) and another is probabilistic (combat has random outcomes), players feel betrayed by the random side. The expectation mismatch creates perceived unfairness even when the math is balanced. AgentE detects these friction points between deterministic and probabilistic systems and flags them for design review.
A game can have hundreds of economic dials, but AgentE should only tune 20 or fewer at once. This is not a limit on the game — it’s a limit on AgentE’s autonomous scope. Each additional parameter creates interaction effects with every other (20 params = 190 two-way interactions, 30 = 435). Beyond 20, AgentE fires a warning to prune low-impact parameters but continues operating normally.
Participant Experience
The economy exists to serve the player. These principles ensure the economic layer enhances gameplay rather than undermining it.
If a new player can’t reach economic viability within a reasonable time window, they’ll churn before experiencing the core loop. Every economy must define a maximum time-to-value and ensure latecomers can reach it, even as the economy matures and early movers accumulate advantages. Without latecomer protections, the economy slowly dies as it loses all new blood.
When time-to-value exceeds 30 ticks with satisfaction below 55, the economy is demanding too much from its participants. This is a proxy metric — it does not measure individual available time, but signals when the collective experience suggests excessive grind. AgentE flags these conditions so developers can tune progression curves or add catch-up mechanics.
When the median spender’s power exceeds 2× the median non-spender’s power, free players leave permanently — the game feels rigged. AgentE targets a maximum 1.5× ratio, where spending provides meaningful but not decisive advantage. Above 2.0×, the economy enters pay-to-win territory and hemorrhages its free player base, which also collapses the paying player experience.
Statistical Methods
How AgentE handles data. Averages lie, samples are too small, and outliers corrupt everything.
When (mean - median) / median exceeds 0.30, the mean is a lie. A few high-balance agents raise the mean while most agents have low balances. AgentE switches to median-based calculations for all health metrics when mean-median divergence exceeds this threshold, ensuring that decisions reflect what the majority of participants actually experience — not the distorted average inflated by whales.
Wild inflation swings (above 30%) may indicate insufficient simulation data. The minimum iteration count is structurally enforced by the Simulator. As a diagnostic, this principle detects large inflation rate oscillations that correlate with decisions made on too little data. AgentE applies conservative corrections when it suspects simulation noise.
Economic Dynamics
Time is the hidden variable. Every intervention has a delay, and impatience is the regulator's worst enemy.
Total intervention lag is 3–5× the observation interval. An adjustment made at tick 100 won’t fully manifest until tick 115–125 (assuming 5-tick observation windows). AgentE never re-adjusts a parameter before its estimated effect tick, because premature re-adjustment guarantees overshoot — you’re correcting for a correction that hasn’t landed yet.
Open Economy
When your economy connects to the real world — tokens, real-money trading, blockchain bridges — entirely new failure modes emerge.
When net extractors exceed 65% of total participants, the economy requires external subsidy to survive — it’s consuming more than it produces. AgentE triggers a yellow warning at 50% and red at 65%. Below 50% extractors, the system is self-sustaining. This metric is especially critical for economies with real-money bridges where extraction means actual cash leaving the system.
When intrinsic utility divided by market value drops below 0.30, the asset is speculation-dependent — its price is driven by expected future value, not current usefulness. Below 0.10 is critical: a price correction kills the economy because there’s no utility floor to catch the fall. AgentE monitors utility-to-price ratios as an early warning for speculative bubbles.
When correlation between gameplay currency and external markets exceeds 0.50, insulation has failed — your in-game economy now rises and falls with Bitcoin, stock markets, or other forces completely outside your control. AgentE monitors external correlation and flags any economy whose internal currency has become a proxy for external market movements. The response mechanism raises internal transaction fees to dampen arbitrage between internal and external markets.
Live Operations
The economy after launch. Events, content drops, seasonal mechanics, and the slow fight against entropy.
Healthy live operations show a “shark tooth” pattern: revenue spikes with each event, valleys that hold their floor between events. When peaks start shrinking or valleys start deepening, it signals event fatigue — the content pipeline is failing to maintain engagement. AgentE monitors peak-to-valley ratios across event cycles to detect fatigue before it becomes terminal.
High completion (above 90%) combined with low satisfaction (below 60) suggests activities are not creating perceived value. Players are going through the motions without feeling ownership or attachment. This may indicate a missing endowment effect — the psychological phenomenon where people value things more simply because they own them.
Free completion rate of 100% means zero monetization pressure — there’s no reason to spend. Below 40% completion is predatory — it frustrates the majority and damages trust. AgentE targets the 60–80% sweet spot where most free players can complete events with effort, but spending meaningfully accelerates progress for those who choose it.
Low velocity (below 2) combined with low satisfaction after tick 100 signals supply stagnation. This is an advisory signal for the developer to audit content freshness — the economy may have run out of new things to discover, and the content pipeline needs attention.
Every new item injection shatters existing price equilibria. When a new rare sword drops, players must re-price every other sword in the economy — arbitrage spikes as the market digests the new information. AgentE builds cooldown windows for price discovery after content drops, waiting for markets to stabilize before measuring post-drop economic health. Judging the economy during the shock itself produces misleading readings.
Principle Index
All 60 principles at a glance, grouped by economic domain.
Ready to plug in?
Start in advisor mode, register a handful of parameters, and watch AgentE diagnose your economy in real time. Three lines of code, zero risk.
AgentE — Animoca Labs • v1.8.0