How We Won ETHGlobal with a Project Called “Shawarma Orchestrate”
How We Won ETHGlobal with a Project Called “Shawarma Orchestrate”
It all started in a pretty normal way, sitting at a lecture in Skopje about zero-knowledge proofs, not really expecting anything life-changing, when the speaker, Jordan Stojanovski, casually mentioned that he’s “retired” and now just spends his time going to hackathons around the world. That one sentence stuck in our heads longer than anything else from the talk, and at some point the idea just came up naturally—why don’t we try one ourselves?
We didn’t spend too much time overthinking it, and since ETHGlobal is one of the biggest names in the space, we figured it made sense to jump straight into something serious instead of easing into smaller events.
The team itself came together pretty organically, since most of us already knew each other in some way, even though we had never actually worked as a full team before. Three of us are based in Skopje, and Andrea, who’s from Italy, is an old friend and former colleague, so there was already some level of trust and understanding before we even started building anything.
Everyone had a slightly different path into blockchain, which actually helped a lot once we got into the hackathon. Dushan had been exploring things on his own, building small projects and learning step by step while studying at FCSE and working as a full stack developer. Oliver brought a mix of design and engineering experience, especially from working on DeFi products, which made a big difference when it came to making things look clean and usable. Gorjan started out through trading and gradually moved deeper into the technical side, getting into smart contracts, automation, and more advanced topics like MEV and high-frequency trading strategies. Andrea added another layer with his background in both economics and software engineering, along with experience in Web3 and hackathons, which gave the team a bit more direction when things got intense.
Going into the hackathon, we already had a rough idea in mind, something related to market research and automation, although once the event started it quickly evolved into something more practical and more interesting to build within such a short timeframe. That’s how we ended up with a multi-agent system for DeFi, where instead of relying on a single bot or script, multiple agents work together, analyze information, and collectively decide whether an action should be taken.
We didn’t really sit down and choose the 0G track in a strategic way, it just happened naturally since their compute and storage solutions fit perfectly with what we were trying to build, so we leaned into that without forcing anything.
The name of the project is probably the least serious part of the whole story, since it came up completely randomly while we were creating the repository. Someone said “shawarma,” someone else added “orchestrate,” partly inspired by Andrea, and we just went with it without thinking too much, which somehow led to a project with one of the most unserious names winning first place.
When it comes to what we actually built, the idea sounds complex on the surface, although the core concept is quite simple once you look at it from the right angle, since everything revolves around coordination instead of a single smart component trying to do everything alone. Each agent in the system runs in a loop where it observes the current state, decides what to do next, uses tools if needed, and then feeds the result back into the system, which creates a continuous cycle of reasoning instead of a one-time response.
The orchestration layer sits on top of that and is built using a graph-based approach, where flows define how agents move through different steps, and a supervisor component keeps everything aligned by deciding what happens next, reusing context when needed, and shaping the final outcome. This supervisor acts like a coordinator that prevents the system from drifting and makes sure all parts are working toward the same goal.
On the backend side, we kept things simple in structure so we could move fast, using Node.js with TypeScript and a plain HTTP server, although the logic itself became quite layered. The system exposes endpoints for running agents, handling approvals, discovering providers, and even integrating with Telegram so that you can interact with it outside the main interface. At the same time, updates are streamed in real time using server-sent events, so you can actually see what the system is doing instead of waiting for a final result.
For the AI part, everything runs through 0G Compute using an OpenAI-compatible setup, with an additional layer that handles request routing and processing behind the scenes. Storage is handled separately through 0G as well, where results are uploaded dynamically, which fits nicely with the way the system produces data during execution.
One of the more interesting parts is how agents interact with tools, since every tool is defined with a clear structure, which means agents operate within known boundaries instead of making random calls. When outputs become too large, they are summarized and fed back into the system, which keeps everything running smoothly without losing important information.
The final decision-making step is based on a voting system, where multiple agents contribute their opinion, and only when enough of them agree does the system move forward. This makes the outcome more reliable, since it avoids relying on a single perspective. Once a decision is made, the system can actually execute actions, like performing trades through Uniswap, which turns it from an idea into something that can interact with real-world systems.
On top of everything, we built a frontend in React that visualizes the workflow, so instead of trying to explain the system with words, you can actually see how agents move, think, and interact, which made a big difference during the demo.
The hackathon itself had a really good atmosphere, with people being open and easy to talk to, whether they were other participants or sponsors, which made the whole experience feel more like a shared building environment than a strict competition. We managed to get a bit of sleep each night, around four to five hours, which felt like a good balance between staying productive and not completely losing energy.
At no point during the event did we seriously think we were going to win, since the focus was mostly on building something that works, making it look clean, and being able to explain it clearly.
Finding out that we actually won happened in a way that matched the rest of the experience, slightly chaotic and completely unexpected. Andrea was watching the livestream and realized what happened, although in the process he missed his train stop and almost missed his flight, while the rest of us were trying to figure out a ticket machine in France. Somewhere in the middle of that, we got the message that we had taken first place, and it didn’t really feel real at the time.
Looking back, a big reason the project stood out is probably that it was fully working and accessible, with a clean interface and a clear demo, so it wasn’t just an idea, it was something people could actually try and understand.
So how does it actually work?
If you ignore all the technical details and just look at the big picture, the system works like a loop where agents think, share information, and slowly move toward a decision together.
It starts with a shared state, which holds everything the system knows at that moment, and each agent looks at that state and decides what to do next, whether that means pulling market data, analyzing trends, or checking risk. Since each agent focuses on a different angle, the system ends up exploring the problem more deeply than a single agent would.
As agents produce results, a supervisor component coordinates everything, deciding which step comes next and making sure the process stays on track, while also combining outputs into something meaningful.
Once enough information is gathered, the system moves into a decision phase where agents effectively vote, and only if the combined result passes a certain threshold does the system take action.
At that point, execution happens, which can include real operations like trades, while results are stored and streamed to the interface so everything is visible in real time.
Why this approach matters
What makes this interesting is not just that it works, although the way it works, since instead of building one very smart agent, we focused on coordination between multiple agents, which opens the door to more flexible and reliable systems.
It’s a small step, although it points toward a future where systems are less about single outputs and more about structured collaboration between different components.
Final thoughts
The biggest lesson from all of this is how important it is to have a team that works well together, especially in an environment where time is limited and pressure is high, since good collaboration makes everything easier.
We also realized how large and active the builder community is, with many people creating things simply because they enjoy it, which makes the whole space feel more open and motivating.
As for what’s next, we’re still figuring it out, although this experience definitely made us want to keep going, join more hackathons, and continue building.
If there’s one simple piece of advice we would give, it’s to choose your team carefully and enjoy the process, since that combination tends to lead to the best outcomes.
