AGORA

• 

  landing page

Inspiration

The idea for AGORA started from something we noticed about using AI for learning: AI is really good at giving us answers, but that doesn't necessarily mean we're getting better at thinking.

We wanted to try something different.

Instead of building another AI tutor that explains things to students, we wanted to build something that could actually challenge them. That's where the idea of debating historical figures came from.

Imagine having to defend your argument against Socrates, respond to his counterargument, and then have another AI tell you where your reasoning was weak.

The historical figures make it fun, but the real goal is critical thinking. We wanted students to actually practice forming arguments, handling counterarguments, and looking at an issue from another perspective.

What it does

AGORA is basically an AI debate arena.

You pick a historical figure, choose a topic, and start debating them. The AI tries to stay in character and actually challenge your arguments instead of just agreeing with everything you say.

After the debate, a separate AI judge looks at your responses and gives you feedback across seven different reasoning dimensions.

You can then try again, see where you improved, and even use Switch Sides to argue the opposite position.

So the basic loop is:

Debate → Get challenged → Get feedback → Try again → Switch perspective

The idea is that instead of AI doing the thinking for you, it gives you something to think against.

How we built it

We built AGORA as a web application using Next.js and TypeScript, with AI powering both the debate and evaluation.

One thing we specifically wanted to avoid was having one AI do everything.

So we separated it into two main roles.

The first is the Historical Figure Agent Its job is to act as the historical figure, stay in character, and challenge the student's arguments.

The second is an independent Judge Agent. Its job is completely different: it looks at the student's reasoning and evaluates it using our seven-part rubric.

We also use structured outputs so the evaluation isn't just a huge paragraph of AI-generated text. We can turn the results into scores, feedback, and progress that the student can actually see.

We also added a deterministic demo mode because we didn't want the entire hackathon demo to depend on an API request working perfectly at exactly the right moment.

Challenges we ran into

Probably the biggest challenge was getting the AI to actually argue

It's surprisingly easy to make an AI that sounds smart but just agrees with whatever the user says. That's not very useful for a debate.

We had to work on the prompts and the structure of the interaction so the historical figure would actually defend its position and push back on the student's arguments.

The other big challenge was the judging system.

At first, it would have been easy to just ask an AI, "Rate this argument from 1 to 10." But that doesn't tell the student much.

We wanted the feedback to answer something more useful: What exactly was weak about my reasoning?

That's why we ended up breaking the evaluation into different dimensions and giving students more specific feedback.

Accomplishments that we're proud of

We're proud that AGORA became more than just a chatbot where you can talk to historical figures.

We managed to turn it into an actual loop where you can:

• Debate a historical figure
• Get challenged
• Receive reasoning feedback
• Retry your argument
• Track your progress
• Switch sides and argue the opposite position

We're also pretty happy with the two-agent setup. Having the AI that is debating you separate from the AI that evaluates you made the whole idea much more interesting to build.

Most importantly, we like that the project has a simple idea behind all of the technology:

Use AI to make people think harder, not think less.

What we learned

One of the biggest things we learned is that building an AI project isn't just about getting a model to generate a good response.

A lot of the work is actually in designing what the AI is supposed to do and how the user interacts with it.

We also learned that giving an AI a specific role and structured output makes a huge difference. A model can produce a really convincing paragraph, but turning that into something consistent enough to actually use in an application is a different problem.

And we learned that the most interesting part of AGORA wasn't actually the historical-character roleplay.

It was the loop around it:

You make an argument → someone challenges you → you get feedback → you try again.

That's what made the project feel like an actual learning tool rather than just an AI demo.

What's next for AGORA

Right now, AGORA is still a prototype, so there's a lot we'd like to explore.

We'd like to add more historical figures and topics, make the debates more adaptive to the student's level, and eventually let teachers create their own debate scenarios.

We'd also like to experiment with classroom or multiplayer debates, where multiple students can take different sides of the same issue.

Another direction we're interested in is making the evaluation more rigorous over time, so that the system can actually show how someone's reasoning changes after repeated debates.

For now, though, the main idea we'd like to keep is simple:

AI shouldn't just make it easier to get an answer. Sometimes it should make you work harder to find one.

Built With

• agent
• aiagent
• css3
• nextjs
• tailwind