This chill feels particularly sharp because the last round of big narratives arrived and dissipated too quickly. From AI hype to on-chain novel assets, to meme-driven extremes, the market seemed to move from euphoria to exhaustion in the blink of an eye. By 2025, most participants quietly recognize a simple fact: we are likely in a phase where narratives no longer “work” the way they used to.
But this isn’t new. The industry has always moved in the same pattern:
In the boom, concepts flood the market, and prices drown out genuine technological progress..
In the freeze, people declare that “nothing works,” while the real direction quietly takes shape.
This mismatch—blind optimism at the top, deep pessimism at the bottom—often hides something more important than price: foundational technologies tend to make their biggest strides in quiet cycles.
Consider the evidence:
In 2018’s bear market, almost nobody cared about NFTs, yet ERC-721 was standardized in that period.
In 2019, “DeFi” wasn’t even a popular term yet, but lending protocols and AMMs were quietly taking form.
Rollup discussions started around 2018, and nearly no one believed it would “own the future.” Yet here we are.
In every cycle, market attention is out of sync with the technology timeline. This isn’t a coincidence; it’s structural. Once price and emotion step off the stage, the capabilities that truly reshape the future finally have space to emerge.
If we bring that lens into 2025, we see a clear, yet often emotionally ignored trend:
the internet is undergoing a structural shift in who its users actually are.
For the past 20 years, almost all internet activity came from humans—clicking, typing, searching, interacting. But in the last two years, something fundamental has changed:
Enterprise automation scripts are exploding in volume.
AI agents are shifting from answering questions to executing tasks.
Model inference services are replacing human workflow distribution.
API-to-API traffic is growing much faster than human requests.
Machine-originated access is becoming a dominant share of web traffic.
These machines don’t tweet, don’t post on social, don’t FOMO. Yet they are quietly taking over a large portion of network activity. They don’t need UI, don’t wait for loading screens, and don’t change behavior because of mood.
The significance of this shift is profound, but easy to overlook—because it doesn’t show up directly in token prices. But for core engineers, protocol designers, and infra builders, the trend is very clear: future network activity will be increasingly driven by machines.
Distribution of bot and human web traffic worldwide from 2013 to 2024, 2025 Bad Bot Report, Imperva, https://www.imperva.com/resources/resource-library/reports/2025-bad-bot-report/
And once the “user” shifts from humans to machines, the requirements placed on the infrastructure change as well:
Payments must be automated and programmable.
Identity must be verifiable and composable.
Access control must not depend on human intervention.
Verifiable execution and auditable records must become defaults.
Data and resources need to be priced per call, not per subscription.
Interactions move to “machine-level” frequency and density.
As AI agents get wired into blockchains and start using Web3’s base layers to execute tasks, it also means the blockchain stack itself must be rebuilt around machine-first assumptions. Two critical starting points for that rebuild are x402 and ERC-8004. They are not just “new narratives” — they are the inevitable consequence of the internet stepping into its next phase.
II. The Agent Economy — Why Machines Will Become Web3’s Next Major Users
This isn’t something you can explain with “AI is hot” and be done. Underneath is a solid technical logic: machines behave in ways that are fundamentally different from humans, and the native properties of Web3 happen to be a very good fit for those differences.
To truly understand why Web3 might find its next S-curve in the age of autonomous machines, we must first deeply comprehend what “machines as users” entails. Their needs shape the direction of future infrastructure, and those needs are not incremental tweaks to existing human workflows, but structural changes entirely.
1. Machines now understand intent and can plan tasks autonomously
Traditional automation simply executed fixed instructions. Today’s AI agents can:
Understand task-level intent;
Analyze contextual information;
Decide which API/tool to call;
Adjust their next steps based on results;
Manage assets, evaluate risk, monitor state;
Orchestrate multi-step, cross-service workflows.
This fundamentally changes the machine’s role on the internet. They are no longer just executing scripts—they can decide what to do and how to do it. That gives them the basic qualification to be independent network “users.”
2. Machines operate at a frequency humans cannot match
A human might trigger a few dozen interactions a day. A machine can send that many requests in a few seconds. A typical agent’s activity density looks like this:
Multiple model inference calls each hour;
Many external API calls per minute;
Continuous monitoring, verification, and state updates each second;
24/7 operation with no downtime.
When user behavior shifts from human pace to machine pace, the required capacity jumps by orders of magnitude:
Waiting on-chain confirmation quickly becomes unacceptable.
Any workflow requiring humans becomes a bottleneck.
High-volume, low-value, high-frequency calls become the norm.
The Web3 stack must be able to handle this density if machines are to become first-class users.
3. Machine behavior models demand fully automated, low-latency execution
Humans are willing to scan QR codes, wait 5 seconds, and retry if something fails. Machines are not. Their behavior models demand fully automated, low-latency execution and provable correctness. What they require is:
Full Automation: Can this task be completed with zero human involvement?
Real-Time Verifiability: Can I get a verifiable, cryptographically secure result in real time?
Granular Payments: Can I pay per call rather than via a misaligned subscription?
Permissioning: Can I obtain and maintain access with zero human confirmation?
Here, Web2 reveals two fatal weaknesses:
Machines cannot independently use the credit card system. They cannot complete KYC, type verification codes, or confirm charges. Subscription models are misaligned with high-frequency calls, and tiny per-call payments are nearly impossible.
Machines lack verifiable trust channels between one another. API keys are not identity. Logs are not credible proofs. Machines cannot use Web2 mechanisms to form trustless cooperation.
This forces the internet towards a “machine-native” architecture — and Web3 is exactly where that architecture can be built.
Why Web3 becomes the natural base layer for machine users:
Web3 offers three capabilities that machines need:
Programmable payments — On-chain assets can be controlled directly by machines, without human approval or centralized intermediaries. This is the starting point of x402.
Native identity (wallet = identity) — A machine can generate and own its own wallet, with persistent identity, without email/phone/KYC. This is what ERC-8004 builds on.
Verifiable collaboration — On-chain records are traceable, verifiable, and tamper-resistant, making them a practical substrate for machine reputation and cooperation.
We are not predicting some distant future here; we’re observing what is already happening:
Traffic reports show a large share of global web requests now come from bots and scripts.
Enterprises are handing more processes to agents.
Model inference is priced per call; machines are the real payers.
Automated trading and monitoring systems are scaling across markets.
Large tech players are actively building “machine user interfaces.”
The Trustless Agent narrative has a simple core: the internet’s primary operators in the future are no longer humans, but the automation behind them. Machines don’t chase narratives, don’t succumb to FOMO or panic. They just keep calling, keep paying, keep executing — precisely the pattern Web3 infra is best at serving.
Why Web3’s next S-curve is likely to be machine-driven
Machines possess three advantages that humans simply cannot replicate:
Extremely high call density;
Infinitely scalable execution frequency;
Persistent, predictable demand for on-chain resources.
A single machine user can generate more on-chain activity than ten thousand humans. Machines don’t rest, don’t leave, don’t drop out because of “education cost,” and don’t rage quit because of FUD. Their demand for on-chain resources is regular, forecastable, and compounding over time.
This suggests that Web3’s future growth is less about human onboarding, and more about scaling automated systems. x402 solves payments; ERC-8004 solves identity and trust. Together they form the basic loop of the machine economy — and that loop is where the next Web3 S-curve is likely to originate.
III. x402 — Re-inventing Payments for Machines
For decades, internet payments were built around humans. Humans can scan, type verification codes, click “confirm,” and navigate redirect flows. Visual prompts, decision points, and manual confirmations are everywhere—and this all made sense, because all traffic was human anyway.
But once the primary “user” becomes an autonomous machine, that logic instantly breaks. Machines can’t “see” a paywall, wait for biometric prompts, or navigate web payment flows. Their behavior model is extremely simple: send request, receive response, continue execution. Any human-in-the-loop step in the payment flow becomes a hard blocker.
This is the context in which x402 becomes structurally meaningful. It’s not “a more user-friendly payment UX,” but a fundamentally different idea:
Make payment a protocol-level semantic, not a UI workflow.
The long-dormant HTTP 402 status code (“Payment Required”) is given real life again. A server can respond with “402: payment required,” stating the conditions for accessing a resource. The calling agent then:
Executes a payment (typically via stablecoins);
Acquires a proof of payment;
Resends the original request with this proof attached.
In this model, payment stops being a messy app-layer flow and becomes part of the language of the internet — like 200 or 404. For machines, this is what they can actually understand, program around, and scale.
On-chain payments are the natural carrier for x402 because traditional payment rails are effectively closed to machines. They depend on human KYC, manual verification, and bank-account-based architecture—all of which exclude autonomous agents. Stablecoins therefore become “machine money” by default: no account opening, no borders, fully automatable; to a machine, they behave more like “CPU time” or “bandwidth credits” than cash.
To make x402 usable in practice, the system still has to hide on-chain complexity: nonce management, gas estimation and optimization, transaction failure and retries, confirmation latency, and sometimes cross-chain routing. The x402 architecture introduces Facilitators, which serve exactly this role. They keep the agent’s experience extremely simple:
From the agent’s perspective: send request, receive result. Everything “on-chain” happens behind the curtain.
This abstraction is crucial to x402 becoming real infrastructure instead of just a spec.
Seen this way, x402 doesn’t fix “payment UX friction” — it fills in a missing primitive of the machine internet: fully automated, per-call, small-value settlement. More and more internet resources—model inference, data APIs, real-time compute, on-chain reads—naturally want to be priced per request. The subscription-based, account-based logic of Web2 simply cannot express that well.
In this sense, x402 is not about incremental improvement; it is about rewriting the unit in which the internet charges for resources:
From “per user per month” → to “per call.”
That aligns perfectly with how machines use the network.
Early projects like PING and PayAI do not represent the full scope of x402, but they do offer the first real-world examples of machines paying per call for services. Their main significance isn’t in creating a hype narrative, but in showing that the mechanism actually works and finds natural footholds in the developer ecosystem.
From a higher vantage point, x402’s value can be summarized in three points:
It demotes payment into a protocol semantic, not a UI flow.
It lets machines perform economic actions independently for the first time.
It lays the lowest settlement layer for the future machine economy.
If machines cannot pay, they cannot truly participate in the internet. x402 is about giving them that missing capability.
IV. ERC-8004 — Identity, Reputation, and Verifiable Cooperation Between Machines
If x402 gives machines the ability to “pay,” ERC-8004 addresses a deeper question: when machines don’t know or trust each other and can be copied at will, how do they collaborate at all?
Human society builds trust via identity, relationships, history, contracts, and legal systems. Machines have none of these. From birth, a machine is just a program:
No natural identity;
No inherent reputation;
Easily copied, migrated, or restarted;
No stable, persistent “persona.”
The default state of the machine world is therefore not “weak trust,” but zero trust.
In a world of scaled machine collaboration, this becomes a serious problem. When one agent calls another:
How does it know the other actually executed the task?
How does it know the result wasn’t tampered with?
How does it distinguish a reliable executor from a throwaway script?
Traditional logging and centralized audit tools are not enough: machines run across domains, chains, and environments. Logs can be altered, siloed, or simply not shared.
ERC-8004 aims at exactly these identity and verification problems — but it does so in a very specific way. It doesn’t try to give machines “human-like roles,” but designs a minimal but sufficient on-chain existence:
Think of it as a machine ID card + standardized behavior proof format, not a personality system.
The key idea is to structure “task execution” as a first-class object and provide a common standard for recording, verifying, and tracking it on-chain. A task can be formally described; its inputs and outputs can be submitted in standardized formats; crucial execution evidence can be committed to the chain. Collaborating agents don’t have to trust each other; they can inspect these proofs.
This changes the basic logic of machine collaboration. What used to be a simple function call becomes an economic action:
Execution happens;
Proof is recorded;
Responsibility is traceable;
History accumulates.
Over time, these records naturally aggregate into machine reputation. It’s not social reputation; it’s cold data:
Completion count;
Success rate;
Dispute or failure history;
Scale and type of tasks handled.
Machines make decisions based on data anyway, not feelings. That makes this type of reputation system almost inherently suited to the machine economy.
To make this identity scheme actually usable, ERC-8004 leans on account abstraction (ERC-4337 and successors): machines can own and sign from dedicated contract accounts.
That means:
Machines can be the direct originators of on-chain actions.
Permissions and behavioral boundaries are governed by contract logic instead of user keys.
“Who executed the task” and “who is ultimately responsible” can be separated in the design.
For the first time, machines can bear on-chain behavior under their own identity and leave a verifiable trail.
At a higher level, ERC-8004 can be summarized this way:
It gives machines a minimal, well-defined identity boundary.
It standardizes how collaborative tasks and their proofs are represented.
It allows machines to accumulate reputations grounded in on-chain data.
It upgrades collaboration from “function calls” to “economic contracts.”
Once identity, reputation, and verification can flow, machine-to-machine collaboration begins to resemble a market: reliable executors naturally get more calls; poor performers are filtered out; new entrants start with low-risk tasks to build a record.
This is an embryonic machine society — an economic structure made of code, evidence, and on-chain data.
That’s why ERC-8004 is not an ornamental standard but a core piece of the machine internet. Without payment, machines can’t obtain resources. Without identity and verification, they can’t cooperate. x402 solves “can they pay?”; ERC-8004 solves “can they be trusted and coordinated?” Together, they give machines the basic conditions to participate in economic activity.
V. x402 × ERC-8004 — The Base Loop of the Machine Economy
Looked at separately, x402 and ERC-8004 seem to solve unrelated problems: payment versus identity/verification. In a “machines become dominant users” context, however, they clearly connect into a single, tight causal chain — a minimal loop that allows machines to function as economic actors.
All collaboration in the machine world can be compressed into a simple formula:
Pay → Execute Task → Verify → Accumulate Reputation → Further Cooperation
Miss any step and a machine-native economy cannot form. x402 and ERC-8004 cover the two most critical edges of this loop: payment and verification. The middle — executors, task structure, reputation scoring — grows naturally on top.
x402 is the starting point for accessing resources. If a machine wants something—model inference, data access, compute, scheduling—it pays. The act of payment grants resource usage rights and establishes an economic relationship: caller versus provider.
But payment alone doesn’t ensure correct execution. An agent that gets paid might not do the work or might cut corners. These risks are amplified in the machine world: agents can be cloned, replaced, or rebooted at will; they carry no innate social responsibility or identity.
This is where ERC-8004 steps in. It makes task execution provable, task boundaries standard, and action logs publicly verifiable. For the first time, machine collaboration has a traceable execution trail rather than being hidden in logs and black boxes.
Combined, x402 and ERC-8004 create a naturally emergent economic dynamic: reliable executors receive more tasks, unreliable ones are filtered out, and new entrants gradually build a record through low-risk work.
From the outside, this looks like a market. Structurally, it’s an auto-forming reputation system:
Payment defines economic relationships;
Verification defines responsibility;
Reputation defines future collaboration.
The result is that a machine ceases to be “just a tool” and becomes a real economic participant. It can initiate tasks, pay for resources, execute external actions, provide services, accumulate history, and use its reputation to unlock higher-value opportunities. A “task market” forms naturally between x402’s settlement layer and ERC-8004’s verification layer.
From a macro perspective, the combination achieves three things:
Gives machines actionable economic rights (they can pay).
Imposes verifiable economic responsibilities (execution records).
Enables structured cooperation based on history (reputation).
This loop is short, clean, and robust. Unlike human economies that rely on emotions, relationships, and institutions, it is built entirely on protocols, data, and automation — which is exactly why it can scale faster. Once a chain, ecosystem, or service starts getting used heavily by agents, the effect of this loop can grow exponentially.
Seen this way, x402 and ERC-8004 are not “growth stories”; growth eventually needs them. Their significance won’t be found in price charts but in the default configurations of future automated systems.
VI. Before the Inflection Point — What the Next 3–5 Years Might Look Like
When we talk about the significance of x402 and ERC-8004, it’s easy to fixate on the technology itself. But what actually determines an industry inflection point is how these technologies seep into real systems over the next few years.
In a quiet, cautious market where narratives feel exhausted and capital is conservative, the easiest thing to miss is this: the internet’s structure is already shifting, slowly but irreversibly, from “humans use the internet” to “machines use the internet.”
The rise of machine users will not look like a single viral app. It’s more like groundwater: slowly rising, barely noticeable at first, until it quietly reshapes the landscape. x402 and ERC-8004 are not the entire story, but they are key bridges that connect:
“Theoretical possibility” → “Engineering feasibility” → “Scalable growth.”
Over the next 3–5 years, this structural migration will likely unfold gradually and be absorbed layer by layer:
From developers → to enterprise systems → to platform services → to the majority of automated workflows.
In the early phases, sectors already heavily reliant on automation will feel it first: data services, model inference platforms, API marketplaces, on-chain monitoring, automated trading, and risk systems. These are already driven by scripts and bots, so “machines can pay” and “machines can be verified” matter more there than anywhere else.
As x402 lets them price calls properly and ERC-8004 makes execution auditable, these sectors naturally shift from human-centric pricing logic to machine-centric logic.
As machine participation increases, the application layer will also be reshaped from beneath. UIs may remain simple, but behind every click may sit a growing fleet of autonomous agents:
evaluating options,
filtering sources,
calling models,
managing assets,
executing trades,
monitoring risk.
To users, it’s still “click button → done.” Under the hood, it’s dozens of chained calls and verification steps.
In this world, Web3 may not become more visible at the UI layer. Instead, its presence strengthens at the infrastructure layer: chains become settlement and reputation layers for agents, not dashboards for humans.
In parallel, stablecoins become even more central. They cease to be just “trading instruments” or “DeFi building blocks” and evolve into the energy unit of machine activity. Every API call, compute operation, and verification step consumes resources; stablecoins are the universal measure for that consumption. As machines scale, stablecoin demand and circulation trend upward—not because of human trading, but because of machine workloads.
The multichain world will also be re-segmented. Instead of “which chain do users like,” the question becomes:
Which chain is best suited for which machine responsibility?
Some chains lean into “payment and settlement,” focusing on stable, fast fund movement.
Some become “execution layers,” handling complex stateful tasks for agents.
Some specialize in “reputation and proofs,” archiving machine behavior and contracts.
Today’s multichain division is mostly about user preference and ecosystem style; tomorrow’s division may be about machine roles.
Centralized exchanges (CEXs) won’t disappear either; they will be critical nodes in the machine economy. To handle large agent-driven flow, they may need more standardized machine interfaces, lower-latency routing, and deeper automated risk systems. Machines don’t open apps. They don’t scroll. They only speak APIs. High-depth, fast-matching CEXs are naturally well-positioned to serve machine flow.
Taken together, these trends point to a single reality: the true inflection point is not when a narrative “comes back,” but when machine users cross a critical mass — in count, call density, and cooperation structures. When machine demand for resources surpasses human demand; when automated services become core revenue; when a large share of on-chain transactions are initiated by agents rather than people — that is when acceleration happens.
To get there, we don’t need sentiment to improve or a new wave of retail. We need time, standardized tooling, and developer consensus on new infrastructure.
From that perspective, x402 and ERC-8004 aren’t just nice-to-haves. Growth will eventually rely on them. Their importance won’t be measured by this cycle’s price action, but by the fact that, one day, they will quietly become defaults in most automated systems.
VII. A Machine-Centric Multichain Layout: Ethereum, Solana, Base and the AI Agent Stack
So far we’ve discussed x402 and ERC-8004 at the protocol and abstraction levels. Now we move to specific chains and ecosystems and ask three concrete questions:
How are different chains preparing for the AI agent era?
Which parts of the machine loop are likely to land on Ethereum, Solana, Base?
How do these moves tie into x402, ERC-8004, and Coinbase’s Payments MCP?
1. Ethereum — Root Registry for Machine Identity and Reputation
In the context of ERC-8004, Ethereum’s core role is increasingly clear:
It is the root domain and public registry for machine identity and reputation, not the primary venue for high-frequency execution.
ERC-8004 lives in the Ethereum ecosystem, giving agents a unified format for tasks and proofs.
Account abstraction (ERC-4337 and successors) lets machines safely and programmably control contract accounts.
ENS, attestations, governance, and DeFi histories collectively form rich “resume data” for agents.
As the chain with the strongest security and most stable consensus, Ethereum is a natural home for high-value task settlement and permanent proof storage.
In an AI-agent-heavy world, Ethereum may not carry the most calls, but it will carry the most critical ones:
Who is this agent?
What has it actually done?
What is its track record?
How is it connected to other entities?
More and more of those answers will live on Ethereum.
2. Solana — High-Frequency Execution and x402 Runtime for Machines
Solana, by contrast, is almost tailor-made for machine demand:
Parallel execution (Sealevel) supports massive concurrent agent activity.
High TPS and low latency match small-value, high-frequency calls.
A strong stablecoin + DEX ecosystem gives data and trading agents instant liquidity.
It is already full of bots (MEV, arbitrage, market making, liquidations) — an early prototype of a machine economy.
In a world where x402 is widely adopted, Solana is a natural contender for:
The high-frequency settlement and execution layer for machines — the place where agents run their daily workloads.
Agents can run high-frequency tasks on Solana, then checkpoint important results and reputation proofs back to Ethereum via cross-chain verifications.
3. Base — Operational and Commercial Home for Agent Products
Base’s positioning is closer to product and business reality.
On one side, it inherits Ethereum’s security while drastically lowering costs as an L2. On the other, it tightly integrates with Coinbase’s wallet stack, compliance rails, and developer tooling, which is a clear advantage for AI agent deployment.
Most notably, Coinbase’s Payments MCP (Model Context Protocol) allows leading LLMs (Claude, Gemini, etc.) to:
Access crypto wallets under scoped permissions and safety policies;
Execute on-chain transactions and stablecoin payments via natural language;
Use protocols like x402 to pay per call;
Participate in DeFi and on-chain flows as agents.
This strongly suggests:
Base is a leading candidate for an “Agent-as-a-Service” operational chain — the place where agent products actually run, charge, manage risk, and interact with users.
On Base, developers aren’t just writing contracts. They are deploying full agent products — from wallet authorization and payment logic, to risk controls and Web2 SaaS integration.
4. Structural Division of Labor: A Machine Internet Infrastructure Matrix
Putting these together, we can think of Ethereum, Solana, and Base as three layers of the machine economy:
Ethereum: Identity layer + reputation & final settlement layer Agents register who they are and what they’ve done here; critical behavior is finalized and made public here.
Solana: High-frequency execution layer + x402 micro-payment engine Dense, performance-sensitive tasks run and settle here, with x402 providing per-call pricing.
Base: Operational layer + commercial chain for agent products AI models connect to wallets and payments via MCP; agent products meet users and enterprises here, in the most compliance- and engineering-friendly environment.
In this view, multichain is no longer about “user preference” but about “machine roles.” Machines don’t care about logos or UI. They care about:
Performance, cost, security, and available tools.
VIII. Conclusion: Machines Becoming Users Is the Inflection Point
Most narratives still assume humans are the center of the internet and of Web3. But the real shift underway is deeper:
The very concept of “user” is migrating from humans to machines.
As that migration reaches payments, identity, collaboration, and reputation, x402 and ERC-8004 stop being “new protocols” and become the grammar of a new world. Ethereum, Solana, and Base stop being just “app chains” and become a structured infrastructure stack for the machine economy.
Looking back from the future, we may realize that the real inflection point was never a single price chart. It was the first time we took seriously a simple question:
If the internet’s primary users are no longer humans but machines, who exactly are we designing the next generation of infrastructure for?
Reference:
Coinbase Developer Platform. x402 – Native payments for AI agents. https://coinbase-consumer.sjv.io/anKdgR
Solana Foundation. What is x402? https://solana.com/x402/what-is-x402
Ethereum Foundation. EIP-8004: Onchain Agent Capability and Reputation Standard. https://eips.ethereum.org/EIPS/eip-8004
Imperva. 2025 Bad Bot Report. https://www.imperva.com/resources/resource-library/reports/2025-bad-bot-report/
The Block. Coinbase unveils tool letting AI agents like Claude and Gemini access crypto wallets. https://www.theblock.co/post/375791/coinbase-unveils-tool-ai-agents-claude-gemini-access-crypto-wallets
Web3Caff Research (Clare Yang). x402 协议 1.7 万字研究报告：当 AI 接管钱包时，“代理经济” 将如何推动 Web3 金融变革演变？ https://research.web3caff.com/archives/37158
IETF. RFC 9110: HTTP Semantics. (includes Status Code 402 – Payment Required) https://www.rfc-editor.org/rfc/rfc9110
Ethereum Improvement Proposals. ERC-4337: Account Abstraction Using Alt Mempool. https://eips.ethereum.org/EIPS/eip-4337
About HTX Ventures
HTX Ventures, the global investment division of HTX, integrates investment, incubation, and research to identify the best and brightest teams worldwide. With more than a decade-long history as an industry pioneer, HTX Ventures excels at identifying cutting-edge technologies and emerging business models within the sector. To foster growth within the blockchain ecosystem, we provide comprehensive support to projects, including financing, resources, and strategic advice.
HTX Ventures currently backs over 300 projects spanning multiple blockchain sectors, with select high-quality initiatives already trading on the HTX exchange. Furthermore, as one of the most active FOF (Fund of Funds) funds, HTX Ventures invests in 30 top global funds and collaborates with leading blockchain funds such as Polychain, Dragonfly, Bankless, Gitcoin, Figment, Nomad, Animoca, and Hack VC to jointly build a blockchain ecosystem. Visit us here.
Feel free to contact us for investment and collaboration at [email protected]
The post first appeared on HTX Square.
