Nexgent 2.0: A New Open-Source Era Begins

Building Through the Volatility

The last few weeks in crypto have been… lively.

Prices have pulled back hard, sentiment flips every other day, and timelines are full of uncertainty again. For a lot of people, that’s unnerving. For me, it’s the best possible environment to build.

When the noise dies down and the spotlight moves elsewhere, you get breathing room. No hype cycles to chase, no pressure to rush half-finished features out the door - just time to focus and ship. So while things may have looked a little quiet from the outside, I can promise you it has been anything but quiet on my end.

Behind the scenes I’ve been heads down working on the next evolution of Nexgent - thinking deeply about how we:

• remove any reliance on custodial models

• make the platform accessible to anyone

• keep it cheap and simple to run

• and set Nexgent up to scale for years, not months

The outcome of all that thinking is a pretty big move:

We’re open-sourcing the Nexgent trading engine.

This isn’t a small tweak or a marketing angle. It’s a complete re-architecture of how Nexgent works and what role we play in the ecosystem. It gives users full control, removes custodial risk, lets anyone build on top of our work, and unlocks live trading in a way that’s safe and sustainable.

It is, without question, the biggest technical and strategic undertaking we’ve ever attempted - and it will lay the foundations for everything that comes next.

Why Open Source?

From day one, Nexgent has had a simple goal:
build powerful, modern tools for on-chain trading.

We never set out to become a broker, a custodian, or a financial institution. We don’t want to hold your funds. We don’t want to execute trades on your behalf. We want to give you the technology so you can run your own system, on your own terms.

But as the platform grew more advanced - especially edging towards live trading capabilities - a problem emerged: the more we hosted and operated centrally, the more it blurred the line between “software provider” and “service provider”.

So instead of trying to tiptoe along that line forever, we’ve chosen a cleaner, more powerful path.

This means:

• You run the platform yourself - on your machine or in the cloud.

• You connect your own wallets.

• You decide which signals to listen to.

• You control every aspect of your setup.

Nexgent’s role becomes very clear:

• We build the open-source trading framework.

• We provide high-quality, proprietary trading signals for those who want them.

• We do not control your funds, infrastructure, or execution.

This shift turns Nexgent from “a website you log into” into a piece of public trading infrastructure that anyone can deploy, extend, and build on.

What’s Actually Being Open-Sourced?

To understand this move, it helps to separate Nexgent into two major components:

1. The Trading Engine – what you see today at app.nexgent.ai

2. The Signal Generation Engine – our proprietary AI-powered signal layer

These two pieces will now take different paths.

1. The Trading Engine: Open Source, Self-Hosted

Everything you interact with in the current Nexgent dashboard is being open-sourced:

• The full frontend (Next.js / React)

• The backend API

• Trade execution logic

• Logging and replica ledger

• Webhook and signal ingestion

• Simulation tools

• DCA and risk controls

• Wallet management (non-custodial)

• RPC / data ingestion layer

• The entire trading UI and control surface

In short: you’ll be able to run the entire Nexgent trading engine yourself - locally or in the cloud.

This open-source engine becomes the backbone of Nexgent’s long-term ecosystem.

2. The Signal Generation Engine: Proprietary & Token-Gated

What does not become open source is the Signal Generation Engine - the intelligence layer that:

• ingests large amounts of on-chain data

• analyses millions of DEX trades over time

• tracks liquidity and volume patterns

• monitors holder distribution and volatility

• and produces the buy/sell signals Nexgent is known for

This system is built on proprietary data pipelines, continuously tuned with replica ledgers, and enhanced over time with more advanced logic and ML. It represents the core IP of Nexgent and remains closed-source.

Access to these signals will continue to be unlocked via $NEXGENT, exactly as intended from the start.

The engine is yours.
The intelligence is optional - and premium.

How the Self-Hosted Edition Works

A natural follow-up question is:

“If Nexgent isn’t hosting the trading platform for me anymore, how do I actually run it?”

The good news: we’re designing this to be as painless as possible.

1. Get the Code

Once the repository is public on GitHub, you’ll be able to:

• clone it

• fork it

• customise it

• run it locally

• or deploy it straight to cloud infrastructure

The repo includes:

• frontend

• backend

• worker processes

• simulation engine

• execution logic

• database schema

• configuration templates

Essentially, you’ll be downloading the same engine that powers app.nexgent.ai today - just without relying on our servers.

2. Run It Locally (Great for Testing)

You’ll be able to spin up the entire stack on your own machine with:

• a basic Postgres instance

• minimal environment configuration

• a couple of setup commands

This is perfect for:

• experimenting with strategies

• modifying the code

• testing integrations

• running in full simulation mode

For live trading, though, a desktop setup isn’t ideal. Your computer would need to stay on 24/7, with consistent internet. A router reset or power outage becomes your single point of failure.

So while local mode is highly useful, it’s more of a sandbox and test-bed than a final destination.

3. Deploy to the Cloud (The Recommended Path)

The real goal is to make running Nexgent in the cloud feel almost trivial.

We’re working towards:

• one-click deployments for the frontend (e.g. Vercel)

• one-click deployments for the backend

• copy-paste setup scripts

• step-by-step video walkthroughs

• minimal configuration required

The engine is intentionally lightweight so that many users can:

• run it on free tiers, or

• use very cheap “hobby” servers that cost just a few dollars a month

The aim is simple:
If you can follow a short guide, you should be able to deploy Nexgent.

Where Does the Data Come From?

A trading engine is only as good as the data feeding into it. This was one of the trickiest challenges to solve for the self-hosted model.

Internally, Nexgent uses licensed low latency (and expensive!!) RPC and indexing providers to access:

• real-time price updates

• DEX trade streams

• other on-chain signals

We can’t simply rebroadcast those paid streams directly into thousands of user-hosted instances - that would breach the agreements we have with those providers.

So the self-hosted edition gives you two clear options.

Option A: Bring Your Own RPC / Data Provider

You’ll be able to connect the engine to any compatible Solana provider, such as:

• QuickNode

• Helius

• Triton

• Everstake

• or your own node

Most of these offer entry-level plans in the ballpark of $40–$50/month that are more than capable of handling a trading bot’s workload.

This path gives you complete independence.

Option B: Use Our Partner’s Data Streams (Free for Signal Subscribers)

This is the part I’m particularly excited about.

We’ve partnered with an emerging blockchain indexer that specialises in low-latency, high-throughput price and market data. As part of that partnership:

• Anyone subscribed to Nexgent’s official signal feed

• Will receive free access to this partner’s real-time price streams

• Which will plug directly into the open-source trading engine

That means:

• no extra RPC subscription

• no complex data setup

• no hidden infra costs

• just plug in your API key and go

We’ll share full details about the provider and integration closer to launch, but the goal is clear:
if you’re using Nexgent signals, you shouldn’t have to worry about separate data bills just to support them.

Signal-Agnostic by Design

Although Nexgent will offer its own signal feed, the open-source engine is deliberately signal-agnostic.

You’ll be able to:

• plug in Nexgent’s official signal webhooks

• integrate third-party providers

• feed in your own scripts and strategies

• use alerts from other platforms

• read from REST or WebSocket feeds

• run internal indicators or cron-based systems

If something can emit a signal, you can wire it into the engine.

Nexgent becomes one high-quality source of intelligence - not a gatekeeper. You get to choose what powers your agents.

Simulation First, Then Live

Just like today’s hosted version, the self-hosted engine will support two core modes:

Simulation Mode

• No real funds at risk

• Perfect for making sure everything is wired up correctly

• Let you confirm signal behaviour and execution patterns

• Compare multiple strategies

• Inspect logs and execution flows

This is where you’ll likely spend most of your early time, especially when experimenting with new signals or strategies.

Live Trading Mode

Once you’re comfortable:

• flip the engine into live mode

• connect your real wallet

• let the engine receive signals

• fetch swap quotes

• execute trades

• and write everything into the ledger

You retain full control at all times - and Nexgent never touches your keys or funds.

Why This Is Such a Big Engineering Lift

On the surface, “open source the engine” sounds like flipping a switch. In reality, it’s closer to rebuilding the platform as a public framework.

And to be fully transparent: I’m doing this as a solo developer.

I work full-time in fintech. Nexgent is what I work on after hours and on weekends. So when I say this is a big project, I really mean it.

A few reasons why it’s such a major undertaking:

• A lot of the system needs to be re-architected so it can run independently of our internal infrastructure.

• Proprietary components must be separated cleanly from open-source ones.

• Execution flows have to be redesigned so they’re modular, inspectable, and extendable.

• Deployment has to be drastically simplified - no one wants a 40-step setup.

• WebSockets, workers, and data ingestion need to be efficient and cheap enough for hobby hardware.

• The stack needs to be robust enough that people with zero infra experience can still run it.

• Every line of code needs to be clean, secure, and ready for public eyes and community contributions.

I’m not just turning a product into a repo. I’m building an open framework for AI trading on Solana.

That takes time - but the direction is now very clear, the architecture is strong, and progress is moving quickly.

What Does This Mean for $NEXGENT?

Naturally, the next question is:

“If the trading engine is open source, what happens to the token?”

The short version:
$NEXGENT’s role is unchanged - and, if anything, more clearly defined.

Utility Has Always Been About Signal Access

The true value of Nexgent has never been “you can log in”. It has always been:

Access to Nexgent’s proprietary trading signals.

Those signals come from the closed-source Signal Generation Engine - the part that reads the chain, learns from huge numbers of trades, and produces actual entries and exits.

That signal engine remains:

• closed source

• continually improved

• and token-gated

The open-source trading engine doesn’t replace that - it gives those signals a more powerful place to live.

A Clearer Focus: Signals, Not Hosting

Once the open-source engine is out in the wild, Nexgent as a project can focus almost entirely on:

• improving signal quality

• building new classes of signals

• refining risk profiles

• tuning models over larger data sets

• and adding new tiers of intelligence

Think of it a bit like TradingView:

• the charting platform is widely accessible

• the premium indicators and tools are what people pay for

In our case, the “charting platform” is a full trading framework - and the premium layer is an evolving, on-chain AI signal engine.

Tiered Access & Exclusivity

We’re currently exploring a three-tier model for signal access, likely something along the lines of:

• Basic – baseline signals

• Plus – higher quality, lower frequency, more nuanced logic

• Premium – most advanced signals, with stricter access and higher token requirements

Each level would require a different amount of $NEXGENT to unlock.

However, there’s an important practical constraint with good signals:

You can’t give the same high-value signal to 1,000 people at once

Too many participants:

• worsen entries

• increase slippage

• and degrade performance

So Nexgent will always remain relatively exclusive by design. Token requirements, capped seats and staking will help ensure that signal distribution remains controlled, fair, and high-quality.

Staking as a Priority Mechanism

We’ve talked in the past about staking, and that remains very much on the table - not just as a “yield” mechanism, but as a priority system.

Staking could help determine:

• who gets which signals first

• how access queues are managed

• how long-term holders are rewarded

• how bursts of new users are smoothed out

It’s not something that will launch on day one of the open-source release, but it’s almost certainly going to play a key role in how premium tiers and signal priority work over time.

Community Input Still Matters

As always, none of this is “set in stone” without community input.

Once we have a concrete proposal for:

• tiers

• token requirements

• and potential staking mechanics

we’ll bring it to the community, share the logic behind it, and gather feedback. $NEXGENT holders will have a real say in how access is structured.

Wrapping Up

To recap:

• The Nexgent trading engine is being rebuilt as a self-hosted, open-source framework.

• You’ll be able to run it locally or in the cloud, customise it, and plug in any signal source you like.

• We’re solving the data problem through “bring your own RPC” and a new partnership that will offer free real-time price data to Nexgent signal subscribers.

• The Signal Generation Engine - our core AI intelligence - remains proprietary and is still accessed via $NEXGENT.

• This shift lets Nexgent focus entirely on producing the best signals possible, while the community gains a powerful, flexible, and permissionless trading framework.

• It’s a huge engineering lift for one person, but it’s the right move - and it sets Nexgent up for long-term success.

This is the next chapter for Nexgent:
not just a platform, but public trading infrastructure anyone can build on, powered by signals that $NEXGENT holders unlock.