Alchemy Crypto device hero image
Origin Story | Alchemy Crypto

Forged in Loss. Started in a Garage. Designed for Control.

A personal story about why Alchemy exists: a security-first trading system and custom hardware created by Robert Evans -- not as a hobby, but as a way to keep going.
Security-first -- keys stay with the user Custom hardware + cloud platform U.S. Patent #12106372 B1

The year the world slowed down

2021 was a difficult year for everyone. COVID disrupted families, routines, and the sense that the future was predictable. For me, it was more than disruption -- it was a collapse of the life I knew.

I'm Robert Evans. For decades I built software at Microsoft -- writing code, leading engineering teams, and shipping systems that had to run reliably at global scale. I worked across products and platforms including Xbox, mobile, and Windows technologies, and later served as the global technical lead for the Windows Developer AppConsult program.

At the height of my career my mother became very ill. I resigned to spend time with her. Then, within about six months, both my mother and -- unexpectedly -- my wife passed away. Grief has a strange gravity: it pulls your attention inward, and it forces you to choose what you do with the hours you have left.

That grief pushed me toward the only thing I knew how to do: build. The first sketches were rough, the first scripts were worse, but building gave the days a shape. It was a way to honor the people I loved by creating something that could protect other people's futures.

"As many developers do in challenging times -- I started creating."

The first principle

I had already been trading cryptocurrency with limited success. Like many people, I watched the market and thought: there's signal in here -- but it's buried under emotion, latency, and bad security.

Most automated trading solutions pushed a dangerous tradeoff: convenience over control. They wanted API keys stored on some cloud server. For me, that was a non-starter. If the keys can be copied, leaked, or misused, then the system is fragile -- and eventually something breaks.

I had seen friends lose sleep and funds because access got sloppy. So I made a promise to myself: if it wasn't secure enough for my own wallet, it wasn't good enough to ship. That promise has guided every architectural decision since.

So I built the first version the way I would build something for myself: local, hands-on, and hardened. A trading engine that could run close to the user, with tight permissions and a design philosophy that treated custody and security as the foundation -- not an add-on.

Early home office server rack processing market data
In the beginning, the "lab" was my home office -- a server rack with terabytes of market data and hands-on access for fine tuning. Today, that heavy lifting is cloud-migrated, but the security philosophy stayed the same.
Device internals showing ARM processor and dedicated AI chipset
The device became more than a computer: ARM compute, dedicated AI capability, and a layout designed for reliability and control -- a purpose-built platform for always-on trading.

When software wasn't enough

The earliest prototype lived on a local machine -- but success has a way of demanding structure. As the engine improved, the system grew: more data, more monitoring, more reliability needs. What started as "a tool" evolved into a platform.

I realized something important: if I wanted other people to trust this, it couldn't be a pile of scripts and a fragile setup. It had to be an appliance -- something you could plug in, understand, and rely on. A device with deliberate design, not accidental complexity.

The garage phase was humbling. There were nights I would turn the lights off, listen to the fans spin down, and wonder if anyone would ever see what I was building. Then the next morning I'd do it again, because that rhythm was the only thing keeping the grief from taking over.

That's when the garage phase became the story. Prototypes. Wiring runs. Soldering. Iterating on internals. Iterating on the external design. And yes -- iterating on lighting (more than once).

Multiple prototypes being built for testing in a garage
Prototypes in progress -- because reliability comes from repetition, not hope.
Workstation at home soldering components
The unglamorous part: soldering and hands-on assembly at the workstation.
Working on the internal wiring of the system
Wiring the internals -- the moment "software" becomes "hardware you can ship."
Working on the lighting system
Early lighting experiments -- dialing in a look that felt premium without becoming a distraction.
Early prototype with lighting that was too intense
One of the early prototypes: the lighting was enthusiastic. Iteration fixes everything.
The current Alchemy Crypto device
The result of countless iterations: a device that looks like a product because it is one.

Proof beats opinions

The first time your system makes money -- real money -- it doesn't feel like "profit." It feels like validation. Not because it's a lot, but because it means the loop closes: data + decision + execution + result.

I'll never forget the early wins. The first test user running successfully. The first tiny profit on a prototype device. A number so small it's almost funny -- and yet it carried an outsized meaning: the machine works.

I kept a sticky note with that first profit taped to the monitor. It reminded me that progress is a series of tiny proofs, stacked slowly, until the doubt no longer owns the room.

First test user up and running and making profit
First test user up and running -- the moment this stopped being "my project" and started becoming "our product."
First profit of $3.21 on a prototype device
The first prototype profit: $3.21. Small number, huge milestone.

A defensible system

Building is one thing. Building something that can survive the real world is another. Over time, the architecture solidified into a repeatable method -- a system and workflow for trading that could be productized without giving up the security model.

That work led to a granted patent: U.S. Patent #12106372 B1 -- "System and Method for Crypto-currency Trading." To me, it felt less like paperwork and more like a birth certificate. A marker that what started in grief and late-night engineering had become something real and protectable.

Writing the patent forced me to put language around what had lived in my head for years. It was strange to see the whole journey translated into diagrams and claims, but also grounding. It meant the work was no longer just personal -- it was permanent.

Robert holding the granted patent document
Holding the granted patent like a proud father -- because sometimes an idea survives long enough to earn a name.

I couldn't do it alone

After the prototypes worked, I ran into the next wall: a familiar founder problem. You can build the core -- but a real company requires depth -- business operations, communication, design, security, advisory, and momentum.

Asking for help was not easy. I had spent years being the person who could figure it out alone. But this wasn't a hobby anymore, and it deserved more than a solo act. I reached out to people I trusted, people who cared about doing things the right way.

So I reached out to people I trusted. Friends and professionals with the experience to help turn a working system into a launchable product. Here are some of the people who stepped in and made Alchemy stronger:

Chief Technical Officer

Robert Evans

Built the core trading system and hardware platform, drawing on decades of large-scale engineering experience and a security-first mindset.

President

Tim Baze

Business leadership and execution -- helping shape strategy, operations, and the practical steps required to scale beyond a prototype.

Executive Director

Mark Lamport-Stokes

Communications, storytelling, and credibility -- decades in journalism and broadcasting brought clarity to how we explain Alchemy to the world.

Creative Director

Adam Sugalski

Brand and experience -- translating complex systems into clean visuals and intuitive product design that users can actually enjoy.

Core Engine Dev Lead

Sarah Berrier

Engine leadership and implementation rigor -- bringing strong math/engineering background and real-world experience from large-scale systems.

Advisory Board Director

Mike Willis

Go-to-market and technical services guidance -- practical experience helping products survive real customers, real constraints, real timelines.

Advisory Board

Mark Edwards

Leadership perspective from global aerospace and technology environments -- helping keep execution disciplined and outcome-focused.

Board | Security Lead

Christophe Nasarre

Security and technical review -- reinforcing the principle that control, custody, and correctness aren't optional when money is involved.

Senior Developer

Dost Muhammad

Deep software experience and architecture support -- expanding the build capacity so the platform can mature quickly without cutting corners.

Advisory Board

Rick Noland

Business consulting and scaling discipline -- bringing decades of executive and financial leadership experience to help optimize growth.

Note: Team role summaries above reflect the public team page descriptions and are phrased for story-flow on this page.

Then we tested the market

Eventually, you have to stop guessing and start measuring. Was this just interesting to me -- or would real people want it?

The answer came fast: we took Alchemy to two trade shows -- one in Miami and one in Acapulco -- and the response was overwhelming. People didn't just ask about returns; they asked the deeper questions: Where do the keys live? Who has custody? What happens when I'm asleep?

I remember standing at the booth, watching faces shift from curiosity to understanding. It was the first time the story moved beyond my own hands. That moment made all the garage nights feel worth it.

When you build from first principles, the story resonates. Not because it's hype -- but because it's the same set of concerns smart users already have.

Miami trade show: Robert Evans with Mark Stokes and Tim Baze at the booth
Miami trade show: me with Mark Lamport-Stokes and Tim Baze -- the booth that turned curiosity into conversations.
People lining up at the Miami booth asking for information
The moment you realize you're not alone: people lining up to ask how it works.
Tim explaining the product to interested attendees
Tim explaining the product -- turning complexity into clarity, one conversation at a time.
Crypto Show recording in Acapulco
Acapulco: recording at Crypto Show -- taking Alchemy's story beyond the booth.

What Alchemy really is

Alchemy isn't just an automated trading engine. It's a philosophy, forged in a season of loss: build something that respects the user, protects custody, and keeps working when life gets chaotic.

Today, the platform combines patented workflows, custom hardware, and cloud-scale analytics -- but the heart of it is still the same promise I started with in my home office: your keys stay yours.

If you're reading this, thank you for being part of the next chapter. The story keeps moving, and I'm grateful for every person who chooses to build it with us.