# Beyond Infrastructure: Smart Systems Architecture | Łukasz - Mimic

- Channel: [Ethereum Denver](https://streameth.org/ethereum-denver)
- Date: 2026-03-09
- Duration: 08:55
- Topics: ETHDenver, Crypto, Web3, Blockchain, Event, Conference, ETHDenver 2025, ETHDenver 2024, Bitcoin, Ethereum
- Watch: https://streameth.org/watch/yt-8W5TXZDPLvs
- YouTube: https://www.youtube.com/watch?v=8W5TXZDPLvs

## Description

Many onchain systems still rely on custom scripts, server-stored keys, or cron jobs, creating silent single points of failure. This session explores how trustless execution removes these risks and enables safer, more resilient onchain systems without added complexity.

## Transcript

All right. Our next speaker is Lucas Stoinsky, head of go to market at Mimic Protocol. He's going to be talking about beyond infrastructure smart systems architecture. Please welcome Lucas. The light is brutal. uh GM Denver. Uh excited to be here. It's uh my fifth time here at Eve Denver. First time presenting on this stage. So super excited. Um I hope you're all uh doing well. So yeah, what we're going to be talking today about is uh the infrastructure, how um the web infrastructure uh uh has matured, but unfortunately the execution and design systems have not. Um, five years ago, uh, infrastructure was the bottleneck in web 3. RPCs were unreliable, indexing was painful, and crosschain just didn't exist. Um, today, uh, that's not the case anymore. Um, infrastructure has matured, but something else hasn't. Uh, execution design and system architecture. And this is what we're going to be, uh, talking about today. Um so we in general we've gotten very good at smart contracts uh writing audits are better tooling is much better patterns are well known and developers got really uh good at it but although we got much worse at designing systems around it uh because they're not equally good as uh the contracts that we're writing and in production it's the system um that is actually what runs and not just the contract. Um so why teams still spend more time wiring infrastructure than building? If infrastructure has matured, why is it still taking them so much time? Where is the time actually going? And um that's the question that a lot of teams have already know the answer to. Infra is no longer the bottleneck as uh we've established already. We have crossing execution. We have mature indexing and data layers. We have reliable RPC providers, bulletproof oracles, smart wallets, great tooling, testing, uh everything is there. So if velocity is still slow, um infrastructure is not the constraint anymore. So where does the time actually go? Um instead it goes mainly to wiring and gluing the infrastructure services together. maintaining hardbe script scripts, retrying logic, monitoring um ma maintaining permissions and um uh safeguards. The glue of connection of all of this together is the real system, but we don't treat it treat it like a proper architecture. This works until it doesn't. Especially as the logic grows, the more complex logic, the higher the the larger the attack surface. um any logic changes require redeployments. The operations is super heavy for the teams to maintain all of that infrastructure. Usually we have off-chain logic that no one really audits because everyone focuses on the onchain logic and then users trusting bots not code. Um offchain glue becomes critical infrastructure. Um we build the trustless core and then we trust everything around it. That's the architectural mismatch that we're facing today. So what is a smart system? A smart system is permissioned. So every action is executed with an explicitly detailed authority boundaries uh that limit what can be and what cannot be done. It's declarative. Uh it defines that what should happen uh under specific conditions rather than hard- coding imperative execution paths. It's deterministic in outcomes. While the uh while conditions may change, the infor the informs constraints and guarantees ensure predictable and bounded results. It's observable. System behavior and execution outcomes can be monitored, expected, and verified in real time. And finally, it's upgradable, so logic can evolve without redeploying core contracts or compromising guarantees. This is how modern systems, how modern distributed systems are built. Um but in web three we skip this layer. So look at this stack. So usually you have a front end or you know application UI that connects you directly with smart contracts and protocols to execute transactions on chain. What's missing? It's the system layer. The execution layer that orchestrates everything. We jumped straight from contracts to infrastructure and we left gap where system behavior should live. Developers should be able to define what should happen under which conditions and with what constraints. Execution reli reliability should be abstracted. Intent and execution should be separated and this is where mimic fits. Mimic provides uh deterministic execution of um appde defined logic condition and time based triggering permission execution with scope authority observable and verifiable execution flows and separation between logic and onchain policies. Mimic is an execution layer for smart systems. It abstracts execution without abstracting guarantees. You define the logic, you define policies and execution becomes the infrastructure and not just one piece of the whole infrastructure. So um where mimick fits in um in this example. So you have the application logic the declarative logics um lives on top then we have a policies on chain um execution sits between whenever the logic evolves the guarantees remain invariant. This separation is what reduces risks and increases velocity when building applications. So uh building a smart system with mimic in three steps. So first of all step one define the logic your conditions your strategies your thresholds your frequency. Then you define your onchain policies limits caps allowed protocols um emergency controls and lastly you abstract execution. The logic evolves the uh guarantees remain invariant. um this is the system infrastructure uh that um every application should be applying to. So let's put it into an example. Um let's say if you want to have an onchain asset management flow, you want to uh let's say rebalance when your allocation drifts more than 5% of what you've defined. So you define the logic, then the protocol monitors the market conditions. When your triggers and conditions are met, the protocol will try to enforce it. But first, it will check against the onchain policies. If it um fits the onchain policies, the exe uh the logic will get executed. If um the on if the logic [clears throat] fails, the guarantees hold. So the policies are the safeguard that you need on top of any logic um that you try to execute. That's the difference which mimic provides versus the the what we call legacy systems. So what changes for the teams? Uh smaller smaller contracts, reduced attack surface, uh fewer redeployments, smaller immutable surface area and faster iteration cycle. Uh execution becomes infrastructure and not the glue code. Why this matters for developers? Less glue, less wiring of the infrastructure means fewer redeployments means fewer 3 a.m. alerts. More time spent designing system, not babysitting scripts and bots and making sure that the systems that you've built are um performing as you've as as intended. So what's the key takeaway here? So if your production logic lives in bots and scripts, your smart contract is not your system. The teams that win won't write more contracts. they'll design better execution systems and better execution models. Um, so this is uh where where Mimic fits in. Um, we're live in production. You can start using uh mimic permissionlessly at protocol.mmic.fi and uh yeah start executing your logic securely and efficiently on chain. Uh thank you very much. Uh we have five more minutes so if there are any questions happy to answer them. Okay, cool. Thank you very much.