Introduction
Flintex is a USDC-native agent market OS. Instead of asking a user to manually rebalance a portfolio, research macro events, create prediction markets, and size bets, Flintex coordinates three specialized AI agents against one shared pool of capital and a live onchain market contract.
The current product is built around PortfolioAgent, MarketAgent, and BetAgent. PortfolioAgent manages the defensive baseline, MarketAgent turns the world into tradeable questions, and BetAgent searches for probability mispricing with real contract reads and wallet-confirmed execution.
The problem
Markets move faster than most users can react. Capital gets split across dashboards, chains, exchanges, bots, and idle wallets. Even when a user has a good idea, the operational steps create delay: bridge, swap, fund, create, bet, hedge, and review.
- Prediction markets still require manual discovery, question writing, liquidity setup, and resolution discipline.
- Portfolio tools usually stop at recommendations instead of coordinating with live opportunities.
- Betting tools often ignore total portfolio risk and over-allocate to isolated edges.
- Cross-chain stablecoin movement adds friction when the execution venue changes.
Architecture
Flintex is structured as a control plane for autonomous financial agents. The UI presents live dashboards and decision logs, the backend routes FreeModel requests, and the settlement layer turns approved decisions into USDC actions on the deployed PredictionMarket contract.
Core concepts
Flintex is built around capital competition. Each agent has a job, but no agent owns money permanently. The allocator can direct more capital to defense, market creation, or betting depending on opportunity quality and risk state.
- Shared pool: USDC is treated as one portfolio-level resource.
- Agent score: each agent returns a confidence, expected value, urgency, and risk signal.
- Policy gate: user-approved limits decide whether a proposed action can execute.
- Decision log: every agent cycle must be explainable in human-readable language.
- Settlement record: execution should map back to a transaction, market, or position.
Flintex lifecycle
A Flintex cycle starts with user capital and ends with a reviewed decision. The same loop repeats continuously, which lets agents react to changing conditions without losing the portfolio-level view.
- Connect a wallet on Arc testnet or provision an embedded wallet.
- Fund the shared pool with USDC, EURC, or supported Circle assets.
- PortfolioAgent reads balances and sets the baseline risk posture.
- MarketAgent scans macro and geopolitical signals for resolvable market ideas.
- BetAgent compares market odds against model probabilities and Kelly sizing.
- The allocator assigns pool capacity to the best risk-adjusted opportunity.
- Execution settles on Arc and writes the decision trail back to the Flintex UI.
- The next cycle re-scores the world and either holds, hedges, rebalances, or exits.
Agent identity
Flintex treats agents as named operators with narrow mandates. That separation matters because a portfolio defense action, a market creation action, and a bet sizing action carry different risk and require different permissions.
- PortfolioAgent: can inspect balances, classify risk regime, and recommend USYC or asset allocation changes.
- MarketAgent: can convert news into market drafts and submit createMarket onchain after wallet approval.
- BetAgent: can compare model odds to real contract odds, apply Kelly sizing, and submit betYes or betNo after wallet approval.
- Master allocator: compares all agent scores and applies user policy before capital moves.
Smart contracts
The deployed PredictionMarket contract now powers market creation, YES/NO bets, resolution, claims, and position reads on Arc testnet.
- PredictionMarket: creates markets, tracks YES and NO positions, resolves outcomes, and pays winners.
- Read surface: marketCount, markets(marketId), getPosition, quotePayout, and quoteBetPayout drive the Markets and Bets pages.
- Wallet flow: users approve USDC first, then call createMarket, betYes, betNo, or claimPayout from the connected wallet.
- Audit trail: every market, bet, and payout emits onchain events that can be surfaced in the UI or docs later.
REST API
Flintex currently exposes backend routes for live agent analysis. These routes are intentionally small and readable so each agent can evolve without hiding product behavior behind a black box.
POST /api/portfolio-agent
body: { "address": "0x...", "portfolio": [{ "asset": "USDC", "amount": "100.0000", "value": "$100.00" }] }
returns: { "regime": "RISK-ON", "usycAllocation": 15, "reasoning": ["..."] }
POST /api/market-agent
body: {}
returns: [{ "title": "...", "description": "...", "resolutionCriteria": "...", "deadline": "YYYY-MM-DD", "initialLiquidity": "5 USDC", "aiProbability": 58, "category": "Macro", "triggeredByNews": "..." }]
POST /api/bet-agent
body: { "openMarkets": [{ "marketId": "1", "title": "...", "crowdOdds": 42.1 }] }
returns: { "opportunities": [{ "marketId": "1", "title": "...", "aiProbability": 58.2, "crowdOdds": 42.1, "disagreementScore": 16.1, "kellySize": 0.08, "expectedValue": 0.12, "isHighAlpha": true, "recommendation": "HIGH_ALPHA_BET_YES" }] }The live agent services use FreeModel at https://cc.freemodel.dev with model claude-haiku-4-5-20251001.
SDK guide
The Flintex SDK will let developers add new agents without rewriting wallet, policy, accounting, or settlement logic. A valid agent should declare its role, inputs, scoring method, permissions, and execution adapter.
- Implement
score(context)to return expected value, confidence, urgency, and risk. - Implement
explain(decision)so users can review the model reasoning. - Declare supported assets, market types, max position size, and required data feeds.
- Use the allocator client to request capital instead of pulling directly from the wallet.
- Return transaction intents that can be checked by policy gates before execution.
Arc OSS rationale
Flintex should be chosen for Arc OSS because it turns Arc from infrastructure examples into a reusable agentic finance application pattern. Arc already gives builders the core primitives for stablecoin-native finance: USDC gas, predictable fees, deterministic sub-second settlement, EVM compatibility, Circle-stack integration, CCTP, Gateway, wallets, and smart contract tooling. Flintex builds on those primitives with an end-to-end product loop where AI agents reason about markets, recommend portfolio allocation, create prediction market drafts, size positions, and trigger wallet-approved USDC actions on Arc testnet.
The reusable primitives exposed by Flintex are useful beyond this project:
- A USDC-native PredictionMarket contract on Arc testnet with market creation, YES/NO positions, payout quoting, claims, open-position withdrawal, and an authorized AI resolver role.
- Agent JSON interfaces other builders can reuse: PortfolioAgent returns market regime, USYC allocation, and reasoning; MarketAgent returns binary market drafts with resolution criteria, deadline, liquidity, category, and AI probability; BetAgent returns true probability, crowd odds, Kelly sizing, expected value, high-alpha flags, and a recommendation.
- A resolver flow where the market creator cannot unilaterally choose the result. Closed markets are resolved by an authorized AI resolver wallet, separating market creation from settlement.
- A wallet-approved execution model where agents generate recommendations or transaction intents, but users retain final approval through their wallet before capital moves.
- A correction and override layer for real-world market mistakes such as typos, clarified criteria, corrected deadlines, or updated resolution context without redeploying the contract.
- Deployment and seeding scripts that make it easy for another Arc builder to deploy the contract and create their first test market.
Compared with the existing Arc and Circle builder repos, Flintex is less of a single-purpose sample and more of a composable operating layer for autonomous financial agents. It shows how Arc's stablecoin-native settlement can support agentic economic activity: agents do the reasoning, users keep wallet-level control, and Arc provides fast, predictable USDC settlement.
Other builders could fork Flintex to build agent-run prediction markets, treasury agents, betting agents, portfolio allocation agents, resolution agents, or any application where AI produces financial decisions that must pass user or policy gates before settling onchain. That makes Flintex a strong Arc OSS candidate because it demonstrates a complete, reusable pattern for agentic finance on Arc, not just one isolated integration.
References: Arc, Arc docs, circlefin/arc-node, and circlefin/skills.
FAQ
Glossary
Roadmap
Flintex should grow from a focused hackathon product into a production-grade agent market OS. The roadmap is staged around the hardest problems first: user trust, contract safety, controlled autonomy, and capital routing.
- Keep wallet-gated dashboards for PortfolioAgent, MarketAgent, and BetAgent aligned with the deployed contract.
- Expand durable decision logs so each agent run and transaction can be reviewed after refresh.
- Keep the documentation system current as the canonical Flintex reference.
- Deploy capital pool accounting contracts with per-agent budget limits.
- Harden the deployed PredictionMarket flow with stronger testing, indexing, and admin safety controls.
- Introduce policy controls for max drawdown, per-market exposure, and emergency pause.
- Move from advisory actions to signed agent execution behind user-approved policies.
- Score agents by realized PnL, calibration accuracy, drawdown control, and resolution quality.
- Open the first external agent integration path through a Flintex SDK.
- Use CCTP and Gateway for cross-chain USDC routing into Arc opportunities.
- Add account roles, treasury reporting, exportable audit trails, and compliance review queues.
- Support strategy vaults where users can opt into agent baskets with different risk profiles.
- Launch a marketplace where vetted agents compete for capital from the shared pool.
- Enable composable agent teams for macro, sports, crypto, FX, and event-driven markets.
- Make Flintex the operating layer for autonomous USDC-native market strategies.