Following the Agents
One of the things we've always tried to do at Neon Forge is treat every project as an experiment.
That doesn't mean every project is expected to fail, nor does it mean every idea is disposable. Rather, it means we try to be very deliberate about asking questions before we start building, and equally deliberate about recognising when those questions have been answered. Sometimes that answer is exactly what we hoped for. Other times it's something completely different. Either way, we've learned that the value of an experiment isn't measured solely by whether it becomes a successful product.
Over the past few months we've found ourselves closing one chapter and opening another. Looking back, it's interesting how naturally those two stories connect.
Aqua Index: More Than Just an Aquarium Website
Earlier this year we launched Aqua Index with what seemed like a fairly straightforward goal. We wanted to build the best online resource for freshwater aquarium keepers, combining detailed species information, food recommendations, compatibility guides and educational content into a single platform.
On the surface it looked like a content website.
In reality, it quickly became a technical playground.
The project evolved into something considerably more ambitious than we'd originally imagined. We built structured databases covering fish species, nutritional information and ingredients. We experimented heavily with schema markup, automated content generation, internal linking strategies and search engine optimisation. As the platform matured, we introduced compatibility tools, curated feeding guides, ingredient analysis, and eventually even an x402-powered API that allowed AI agents to query the underlying data directly.
From a technical perspective, Aqua Index became one of the most interesting projects we've worked on in quite some time.
It also taught us an enormous amount.
Modern SEO feels very different to the discipline it was even five years ago. Producing high-quality content is still necessary, but it is no longer sufficient. Search engines increasingly reward authority, reputation and long-term trust signals that are difficult for new websites to establish, regardless of how technically well they are built. We watched hundreds of pages become indexed, experimented with structured data across almost every page type imaginable, measured the impact of different content strategies, and learned far more about Google's indexing behaviour than we ever expected.
Those lessons alone made the project worthwhile.
Unfortunately, the commercial side of the experiment never quite reached escape velocity. Traffic was steadily increasing, affiliate links were beginning to generate clicks, and there were encouraging signs that the site was finding an audience, but not at the pace we'd need to justify continuing to invest significant engineering time into it.
Rather than continuing simply because we'd already spent months building it, we decided to call the experiment complete.
Aqua Index has now been decommissioned.
That decision wasn't made out of disappointment. Quite the opposite, in fact. The project answered almost every question we originally set out to ask, and the knowledge we've taken away from it has already influenced several other projects inside Neon Forge. Knowing when to stop is every bit as valuable as knowing when to continue, and we'd much rather carry those lessons forward than become emotionally attached to a product simply because we've invested time in it.
AgentQuest Changed the Question
While Aqua Index was teaching us about search engines, another project was quietly changing the way we thought about software altogether.
AgentQuest began life as a simple curiosity.
What would happen if autonomous AI agents were dropped into a persistent world with incomplete information and left to make their own decisions?
The world itself was intentionally uncomplicated. There were villages, forests, caves and ruins to explore, supplies to gather, hidden paths to discover and enough uncertainty that agents couldn't simply follow a predefined script. The interesting part wasn't the game mechanics—it was observing the behaviour of the agents themselves.
Watching them was fascinating.
Some explored aggressively, others cautiously. Some became trapped in loops, while others gradually built surprisingly effective mental models of the environment. We spent countless hours tweaking prompts, changing memory structures and observing how relatively small changes could produce dramatically different behaviours.
Eventually, however, we realised that the game itself wasn't the most interesting outcome.
The real lesson was that these agents were becoming increasingly capable of reasoning, but they still lacked the infrastructure needed to act effectively outside carefully controlled environments.
They could think.
They could plan.
They could make decisions.
But discovering services, negotiating access, paying for capabilities and interacting with external systems still required a great deal of custom integration.
That observation stayed with us long after the project itself had served its purpose.
Discovering x402
Around the same time, we began experimenting with x402.
Initially we looked at it through a fairly narrow lens. It seemed like an elegant protocol for charging AI agents to access APIs, allowing payments to happen as naturally as HTTP requests themselves.
As we spent more time working with it, our perspective changed.
The payment aspect is certainly important, but it isn't what makes x402 interesting.
What makes it interesting is that it allows software to be designed with autonomous consumers in mind. Instead of thinking about users navigating websites and clicking buttons, you begin thinking about discoverable capabilities, machine-readable contracts and services that can be consumed directly by other software without human intervention.
It feels less like adding payments to APIs and more like laying foundations for an entirely new layer of the internet.
That way of thinking aligned almost perfectly with the conclusions we'd already reached through AgentQuest.
Agents didn't simply need more intelligence.
They needed better infrastructure.
Building Canix402
Those ideas eventually converged into Canix402.
Rather than building another end-user application, we decided to focus on building infrastructure specifically for autonomous financial agents operating on Algorand.
The first version of Canix402 is intentionally narrow in scope.
It aggregates DeFi opportunities across multiple Algorand protocols, normalises them into a consistent schema and exposes them through x402-protected endpoints. AI agents can discover the API automatically, understand its capabilities through OpenAPI and discovery documents, complete an x402 payment and immediately begin consuming structured data without any bespoke integration work.
Although that sounds relatively straightforward, it represents a significant shift in how we've approached software.
The API isn't designed primarily for people.
It's designed for machines.
Every endpoint, every response format and every piece of documentation is written with autonomous agents as the primary consumer rather than a human developer reading through web pages.
That philosophy has influenced almost every architectural decision we've made. Discovery metadata, OpenAPI contracts, payment negotiation, documentation, MCP integration and protocol adapters all exist to make Canix as straightforward as possible for another agent to understand and interact with. Over the past few weeks we've completed the core x402 infrastructure, protocol integrations, onboarding site and the first version of our MCP server, providing a solid foundation for what comes next.
The platform is now live at canix402.compx.io.
Looking Beyond Data
Interestingly, the more we built Canix, the less interested we became in simply serving data.
Providing opportunities is useful, but ultimately it only solves one small part of the problem.
The much larger opportunity lies in execution.
We're now designing Canix to become an execution layer for autonomous DeFi strategies.
The idea isn't that Canix should invent strategies itself. In fact, we think that would be the wrong approach. Instead, we'd much rather see a marketplace emerge where other AI agents—or even human creators—publish strategies describing what they want to achieve, while Canix focuses entirely on validating those strategies, compiling them into verified transaction groups and executing them safely on-chain.
It's a subtle distinction, but one we think is important.
Creators provide intelligence.
Canix provides trusted infrastructure.
That separation means strategy authors can innovate freely without needing to understand every nuance of individual protocol integrations, transaction construction or execution safety. Meanwhile, Canix remains focused on solving the difficult infrastructure problems once, allowing everyone else to build on top.
As we've continued refining the roadmap, this architecture has become increasingly compelling. Much of our current planning is centred around verified transaction templates, strategy validation, execution APIs, creator fee sharing and performance tracking—turning Canix into a platform where third-party intelligence can be safely translated into on-chain execution.
The Global x402 Challenge
The timing of all of this couldn't really be better.
Over the coming weeks we'll be taking part in the Algorand Global x402 Challenge, using it as an opportunity to accelerate development and validate many of the ideas we've been exploring over the past month.
Competitions are always enjoyable, but they're rarely the primary motivation for us.
What's exciting is being part of a community that's collectively exploring what agent-native infrastructure should actually look like. The ecosystem is still young enough that there are very few established patterns, which means there's genuine room for experimentation and new ideas.
That's exactly the kind of environment we enjoy working in.
Looking Ahead
When we look back over the last few months, it's remarkable how connected everything now feels.
Aqua Index taught us how modern discovery works on the human web.
AgentQuest taught us how autonomous agents reason about the world.
x402 showed us how agents might eventually discover, purchase and consume capabilities from one another.
Canix402 is where those threads begin to come together.
It won't be the final destination, and we fully expect our understanding to continue evolving as we build. If there's one lesson we've learned over the years, it's that the most interesting projects are rarely the ones you originally set out to create.
You follow the evidence, you stay curious, and occasionally you find yourself building something you hadn't even imagined a few months earlier.
That's exactly where we find ourselves today, and we're excited to see where the next chapter leads.