On June 10th, 2021, three founders sketched out a bold idea on a whiteboard. Four years and $7b in processed value later, our automation has evolved into a flexible protocol that empowers builders to automate a wide variety of blockchain operations.
This is Mimic’s journey, a story about how we turned a whiteboard idea into the automation standard for Web3, why it matters, and what got us here.
It’s been a path marked by both trial and error and crucial insights. Each version of Mimic taught us new lessons about decentralization, scalability, user experience, and how best to integrate into the broader blockchain ecosystem. This is our quest towards onchain automation.
Why This Story Matters
This blog post is for anyone curious about Mimic’s origin, evolution, and the hard-earned lessons behind our Protocol. It’s the founder’s-eye view of the product design journey, from MVP hacks to a robust infrastructure serving billions in automated volume. If you're building in Web3 or exploring programmable automation, this one’s for you.
The Early Days of V1: Structured Strategies in Smart Contracts
In the beginning of 2021, Mimic was built around on-chain strategies that were essentially “recipes” for DeFi operations, each one tightly embedded in its own smart contract. It worked well for specific use cases—like a certain lending-borrowing pattern—because everything was predefined: users only had to plug in a few parameters. But that same rigidity was also its weakness. If you wanted to change a step or tweak a condition, you often needed an entirely new contract deployment. Worse, there was no real scheduling or relayer network; users still had to press the “Execute” button at the right time.
This approach proved that onchain automation could handle repetitive DeFi actions, yet it fell short of being truly automated or flexible. We realized that allowing more dynamic configuration, letting users adapt strategies on the fly, would be critical for scaling.
Enter v2: Extracting Configurations & Empowering Users
With that lesson in mind, we took a big leap in 2022 with Mimic v2, by breaking out important parameters and configurations from the smart contracts themselves. Instead of a hard-coded sequence of DeFi steps, users could now define elements like token addresses, thresholds, or triggers at runtime, without redeploying everything. We also introduced the concept of relayers to start automating tasks under simple conditions, though we were still figuring out how best to integrate external data sources like price oracles.
This shift taught us a few things. Granting more control is powerful but can easily become inconvenient if every detail has to be set up from scratch. We also learned that robust validation of external data—think “swap only if the price is below X”—would be essential for safe, dynamic triggers. And perhaps most importantly, we saw the real promise of a network of relayers who could take care of executing tasks entirely, removing the need for users to intervene at critical moments.
Ultimately, v2 was a major step toward letting users shape strategies to their needs, but we still lacked a truly modular system for tasks. We also realized we’d need “connectors”—adapters for specific DeFi protocols—to handle the growing complexity of integrations.
v3 (Present Day): Modular Tasks, Connectors & Relayers
Mimic v3 takes the best of those earlier lessons to create a truly modular and decentralized automation platform.
Building Blocks: The Rise of Standardized Tasks
We introduced a library of common DeFi operations (swapping, bridging, lending, borrowing, rebalancing, etc.). Users choose from these tasks like building blocks. Each task is highly configurable, so you can set parameters, triggers, and conditions.
Connectors: The Key for Protocol Integrations
Instead of hardcoding everything, we use “connectors” as plug-and-play modules to interface with external protocols (like Uniswap, Aave, 1inch, Paraswap, Hop, LiFi, etc). This means tasks remain extensible: if a new protocol emerges, we can develop a connector and slot it right in.
Relayers & Delegation: Automation Without Sacrificing Control
Users can finally delegate the execution of tasks to Mimic relayers, who handle the heavy lifting of sending transactions, monitoring chain states, and verifying oracle data. This architecture also opens up the door for multiple independent relayers (think of them as decentralized operators) who compete or cooperate to ensure tasks get done reliably.
Onchain Security & User Control
All automation logic is enforced on-chain via smart contracts that check user-defined conditions. There’s no custodial risk: Mimic never holds your private keys or takes custody of your assets. Everything is validated by the protocol’s smart contracts.
This structure—customizable tasks, modular connectors, and relayer delegation—gives users an AWS-like automation experience, but in a trustless and decentralized environment.
Building the Protocol: Turning Learnings into Architecture
While experimenting with onchain strategies, user-defined configurations, and the initial relayer concepts, we discovered we already had the essential pieces of a truly trustless system, and in 2024 we decided to start building Mimic Protocol, with components such as oracles, relayers, and user safeguards.
But putting them together into a coherent, scalable framework required a new architectural approach. If we wanted Mimic to evolve into a fully decentralized protocol, opening the door to automated and trustless operations across multiple chains, we needed a tech stack that made sense, was elegant, and did not rely on partial solutions or centralized steps.
After key iterations, we designed a system that boiled down to three core layers:
Planning Layer
This is where functions are defined, combining oracle inputs, user-defined logic, and triggers. It’s also where relayers first come into play, fetching data and determining whether conditions are met.
Execution Layer
Once a function is ready to run, it transforms into an intent and heads to a decentralized environment where solvers compete to execute it. By letting multiple parties submit proposals, we ensure the best fee/latency combination and avoid single points of failure.
Security Layer
Finally, a settler contract verifies that the solver’s execution meets the original safeguards—things like deadlines, slippage limits, or maximum spending caps. Only then does it finalize the transaction onchain, ensuring funds stay secure and under the user’s control.
Together, these three layers offer a fully automated pipeline: from reading real-time data to actually executing and verifying each action on-chain. By adding in economic incentives and staking mechanisms for oracles, relayers, and solvers, we’re buiding a protocol that prioritizes reliability, transparency, and user-defined security—all the lessons we gained from our early explorations in our past versions.
If you are interested in a more technical explanation, here is our whitepaper (opens a pdf link).
What We Learned Along the Way
- Modularity Unlocks Scale: Splitting operations into tasks and connectors avoids the “one strategy = one contract” problem. Users love building custom workflows from standardized building blocks.
- User-Centric Configuration: Letting users tweak parameters in real time was a game-changer. It lowered the barrier to entry and gave non-technical participants more control.
- Incentivized Decentralization: For relayers to be truly decentralized, we needed a staking and slashing mechanism, plus robust oracle/data validation. It took real-world testing to refine these incentives.
- Keep the UX as Simple as Possible: Automation can be complex under the hood, but it shouldn’t feel that way to the user.
What’s Next?
We’re aiming to create a system where tasks are transparently defined, executed, and settled on-chain, all while giving users granular control over what happens and when.
In short, our ambition is to provide an open, modular protocol that anyone can build on, removing the last barriers to full automation for blockchain. By democratizing the tools for scheduling, triggering, and executing onchain tasks, we’re one step closer to a future where users and developers can orchestrate complex operations with ease, all while trusting the integrity of each step.
Conclusion
Mimic’s evolution hasn’t always been a straight line, but it revealed invaluable lessons at every turn. Each iteration revealed what real-world users truly need: flexibility, transparency, and genuine hands-off automation. Today, we’re turning those lessons into a decentralized automation protocol. Yet this is only the beginning. As we complete our decentralized architecture and expand our integration capabilities, Mimic will become even more powerful and user-friendly.
Join the Mimic Protocol Alpha
As onchain automation continues to transform the way DeFi teams operate, Mimic Protocol is building a new standard in programmable, decentralized execution for Web3.
Alpha testing will start soon! If you're a crypto developer or protocol operator, now’s your chance to get ahead of the curve.
Get alpha access to Mimic Protocol by clicking below 👇
Start simplifying how you code, execute, and scale blockchain projects. Let automation handle the busy work while you focus on building.
🐦 X (Twitter) | 📚 Documentation | 📄 Whitepaper | 💬 Discord | 🌐 Website | 🌀 Farcaster | 💼 LinkedIn