In August 2026, Lablup joined the JunctionX Korea hackathon as a track partner alongside FuriosaAI. Junction is Europe's largest technology hackathon, created in 2015 by Aaltoes (Aalto Entrepreneurship Society), the student entrepreneurship community at Finland's Aalto University. Aaltoes is also the birthplace of Slush, one of the world's largest startup conferences, and Junction, which grew from the same soil, is closely tied to the startup scene.

Junction had invited Lablup to its Asian and Korean events before, but the timing never worked out. This year was different. JunctionX Korea 2026 would be held at POSTECH in Pohang, and several members of Lablup's leadership spent their undergraduate or graduate years there, so the location carried personal meaning. I had my own attachment to Junction as well: back when the nonprofit SHIFT was running Junction, I handled event organizing as its HR Head. So despite a crowded calendar of overlapping events, we decided this was the year to stretch a little and go. Around the same time, word came from the Junction organizers that FuriosaAI was looking for a company to co-present a track. Lablup and FuriosaAI had just finished validating Backend.AI on RNGD and published a joint whitepaper, so there was no reason to hesitate. The two companies signed on as track partners together.

Once the decision was made, the mood became 'if we're doing this, we're doing it properly,' and we ended up assembling a somewhat extravagant delegation: our CEO, our CTO, and the director of our research lab all headed down to Pohang.

Choosing the Track Challenge

Deciding to participate was the easy part, but the track challenge itself was the first real problem. Junction is a team hackathon at its core: participants enter in teams of four, with clearly divided roles across planning, development, and design. Even if those boundaries are blurrier in the AI era than they used to be, the challenge still has to let each specialty contribute.

Lablup and FuriosaAI both work on deep, unfamiliar problem domains, and both are primarily B2B companies. A challenge framed as 'help us solve our enterprise problem' does not work at this kind of hackathon, and reaching for some vague grand cause felt just as wrong. After going back and forth for a while, we changed the approach and focused on where the AI market is moving right now.

The main consumers of AI tokens are shifting from people to agents, and agents use a lot of tokens. As of February 2026, agents had already overtaken humans in token consumption; the figure now exceeds five times human usage and keeps climbing. Tokens translate directly into cost, so using AI economically is becoming as important as using it well. There is also a visibility problem: unless a person watches the whole time, it is hard to know exactly how an agent does its work. As more agents call subagents and delegate work to them, how transparently you can look into that structure is emerging as a challenge of its own.

So Lablup and FuriosaAI set this mission: build an agentic squad that solves benchmarks across multiple domains at the lowest possible cost, running on AI:GO, Lablup's personal desktop agentic AI platform, with intelligence supplied by FuriosaAI's RNGD inference. From the participants' side, instead of trillion-parameter models like Anthropic's Claude Fable, they would work with 32B, 120B, and 236B models running on Furiosa's NXT RNGD Server, hardware close enough to touch, and solve benchmark problems at high accuracy for the lowest cost. Over the 48-hour hackathon, each team had to produce two deliverables.

![deliverable criteria] (https://cdn.lablup.com/2026_08_27_125508_88a45a9c37.png)

The first was the problem-solving agent squad itself. Lablup and FuriosaAI provided three models with different pricing schemes: K-EXAONE-236B-NVFP4, gpt-oss-120b, and Qwen3-32B. Using AI:GO's squad feature, participants had to work out how to compose agents that solve the problems. That meant understanding the characteristics of the three models, finding which model assigned to which kind of agent would score highest on the benchmarks, and at the same time designing base prompts that let the agents arrive at correct answers.

The second was a dashboard visualizing how the squad solves problems. With visibility into agentic workflows mattering more and more, each team had to pick a target persona and build a dashboard showing how their agents work and what they did along the way. The intent was a structure where planners and designers talk with developers, understand how the agents operate and divide up work, and build the most legible interactive visualization they can. That way the hackathon belongs to the whole team, each contributing their own expertise, not to the developers alone.

A Hackathon to Prepare for the Hackathon

Preparation meant a lot of back-and-forth with FuriosaAI to pin down realistic specifications. Furiosa worked out from the head count how many servers were needed, in what form to provide them, and which models to serve. Lablup built a hub on Continuum Suite so the LLMs participants used could be monitored in one place. We also ran a range of benchmarks to find the right reference points, built a small practice benchmark set that participants could run in a short time along with the final evaluation set, and made a submission system so teams could do trial runs themselves. The submission system was still unfinished on the morning of the event, and an engineer kept working on it the whole way down to Pohang. But everyone pulled together, and by the time the hackathon opened it was, miraculously, ready to run.

Another Hackathon to Keep the First One Running

When the hackathon started, I worried about how many teams would pick our track. The worry did not last. We introduced the challenge, ran onboarding for AI:GO and Furiosa RNGD, and the first day was under way; from then on, participants streamed in with questions. The travel team's plan to explain the track and slip out to an early dinner fell apart. Our CTO and engineer took the technical questions, I took the ones about UI/UX and visualization, and we stayed at the venue until nearly 2 a.m., answering teams and issuing accounts for the submission system.

AI:GO met plenty of real-world issues during the hackathon too. One participant's laptop username ran past 20 characters and broke a path; another brought a Samsung Chromebook and tried to install AI:GO in Linux compatibility mode. These are the kinds of issues an in-house test environment does not easily surface. Participants also asked for more than we had anticipated, from exposing the CLI management API publicly to making AI:GO itself operable by agents. Between fixing bugs and adding the features participants wanted, the travel team ended up running the hackathon right alongside them. AI:GO had been built on the assumption that a human operates it; thanks to these requests, the first pieces of an agent-operable AI:GO fell into place. Somewhere along the way, the Junction hackathon had turned into a large-scale testbed for Continuum Suite and AI:GO.

Once teams got deep into development, a few smaller problems surfaced. One participant reported that the benchmark queue wasn't moving. A benchmark that should have finished in 20 minutes had been running for over two hours, the queue backed up behind it, and the performance metrics we were monitoring deteriorated within minutes. Lablup and Furiosa each attached additional capacity from their own resources to clear the bottleneck. Participants were using tokens far more heavily, and far more actively, than we had planned for. (We will cover participants' and agents' token usage in a later post on the Lablup tech blog.)

We had spent a lot of time worrying whether the challenge was too hard, so the level of the questions coming at us was a surprise. Some teams read our intent early and went almost straight to a near-optimal approach. Others held onto us and asked question after question until they had settled on their path. One team split all three tracks among its members, developed them in parallel, then fleshed out whichever result was strongest and submitted that; the strategy stuck with me.

Judging by how heavily teams leaned on gpt-oss-120b, the model participants used most, many seem to have reached the same conclusion: below trillion-parameter scale, letting one large model handle a bit of everything beats building many small-model agents when you are squeezing out benchmark performance. Too many errors crept in while a planner handed work down to small agents. And in the pricing scheme we set up, K-EXAONE was priced steeply in proportion to its size, so using it sparingly was the cost-efficient move.

The visualization entries were even more varied. One team used characters to show what each agent was doing, aimed at consumers handling a fully agentic system for the first time; another borrowed from dating-sim UI and staffed its squad with a student, a senior, and a teacher; a third built around RPG Maker-style gamification. One team even 3D-printed a physical controller for driving the agents, and there was also a team that built a classic, by-the-book visualization dashboard. Some teams provided thorough logs and some deliberately did not, and both sides had clear reasons. It was also striking how the split between newcomer-oriented and expert-oriented targets changed the entire direction of the visualizations.

Judging combined a qualitative UI evaluation, a quantitative token evaluation, and the benchmark results, weighted on clearly stated grounds. Once the scores came together, first and second place had gone to teams that approached the problem from completely opposite directions.

First Place (Track Winner): Demo Day Care

The winning team built an observation tool that visualized three metrics, benchmark score, efficiency, and total tokens, as a 3D plot. It tracked each benchmark's score (SWE, math, generic) turn by turn and compared aggregate scores, and traced per-run tokens and model calls, giving each function the chart form that fit it best. A timeline replay let you rewind how the agents had behaved during an actual run, and the interactive view, where you click and rotate the plot to explore the data you want, was implemented in WebGL, which impressed us.

Excerpts from the judges' comments:

"Strong presentation structure and demo polish. Every element of the UI had a clear intent, which made it easy to follow."

"Clearly identified the limits of OSS and replaced it with a universal implementation, which was impressive. Excellent overall."

"Handled the technical overview best: a classic visualization plus logs and records, so the output could be examined in multiple forms."

Second Place: Sacabambaspis

The runner-up rendered agents working together as a pixel-art office scene. The space is divided into an office and five rooms, and dot characters, separated by role, walk around doing their work. A panel shows what each agent is working on at the moment, the reasoning process appears in speech bubbles, and the final report comes with its supporting evidence. They made it possible to submit custom missions beyond the hackathon problems, and in the little time they had, they even added background music, which did not affect the judging but was fun to see.

What impressed me was that they polished the UI without giving up substance: the intermediate steps and the results were all reported in full.

Excerpts from the judges' comments:

"Stated the problem they wanted to solve clearly, and explained the solution process scientifically and precisely."

"The UI was creative, yet its rules and intent were clear enough that nothing felt superfluous."

After It Was Over

This JunctionX event mattered inside Lablup as well. Through the hackathon, we watched participants push AI:GO to its limits at scale, all toward the same goal, and collected a wide range of feedback on the software along with operational data for Continuum Suite. The model-usage data gathered through Continuum Hub also showed us how individuals drive their agents and how they use AI in their development process. And as the contact person for the partnership, I was glad to see the recent collaboration with Furiosa carry on all the way to a hackathon.

Talking with participants from many fields and many roles, students through working professionals, we learned a great deal ourselves. I had worried about the topic before we started, but what stays with me is the crowd of participants coming over with questions and, step by step, sharpening the task as they caught the points we had intended and the ones we had not. I had only ever organized hackathons, never entered one, so watching participants come to the track partner to get unstuck, and watching them form hypotheses, hit walls, and try angle after angle to break through, felt genuinely fresh.

A hackathon is a time-compressed event: scout what is possible, focus on an MVP within the time limit, implement the minimum feature set, and still deliver a presentation at the end. What I felt firsthand is how much it matters to iterate fast and close that loop several times over. After it ended, participants came by to talk. Several told us it was meaningful to learn about a domain they had known nothing about. We had barely slept for the two days before heading to Pohang and barely slept on site while supporting teams, so those words landed with real weight.

The Age of Agents, and Where People Stand

One question kept circling in my head while we prepared this hackathon: how far can people go with AI? The era when agents consume more tokens than people is already here. The share of problem-solving that humans touch directly keeps shrinking, and structures where agents divide and delegate work among themselves are becoming ordinary. So what is the human role amid this shift? My own answer is ownership. The moment an agent's judgments, and the path it took to reach an answer, become a black box, the human loses the seat of final judgment. Being able to see all the information, and to bring out your intent at any time and change direction: that, I think, is what has to remain with people in the agentic AI era. As tools grow more capable, what stays behind is the goal itself, held clearly. Nobody yet knows how problem-solving will change in that era. I hope this hackathon gave us, and the participants, a good occasion to think it through.

Our thanks to FuriosaAI for joining us as the hackathon track partner.