This is not another generic “AI hype” meetup.
The Prague AI-Driven Software Meetup is launching with a bold thesis: LLM-driven software represents a historic opportunity for Europe — and specifically, for European builders who understand that intelligence in software isn’t just about speed or scale, but about depth, nuance, and human understanding.
On Monday, January 26th from 7:00 PM to 9:00 PM CET in Prague, we’re bringing together founders, engineers, product leaders, and researchers for a conversation about where software is heading — and how we can actively shape that future.
Europe’s Moment: Why Our “Disadvantages” Are Actually Strengths
For years, the conventional wisdom has been that Europe’s startup ecosystem is hamstrung by its fragmentation, its regulatory caution, and its reluctance to move fast and break things. The narrative goes: America has the speed, China has the scale, and Europe… well, Europe has good intentions and a lot of meetings.
But here’s what the conventional wisdom misses: the things that supposedly hold Europe back are precisely the strengths needed to build the next generation of intelligent software.
Europe’s real advantages have always been:
- Depth of thinking — philosophical and intellectual traditions that understand complexity and nuance
- Cultural and linguistic diversity — 24 official EU languages and countless cultural contexts, forcing us to think about localization, context-sensitivity, and human variability from day one
- Social and ethical awareness — centuries of grappling with questions of power, rights, fairness, and what it means to build systems that serve humanity
- Skepticism of simplistic solutions — a cultural tendency to ask “But what if…?” and think through second-order effects
These are exactly the ingredients needed to build software that doesn’t just execute instructions, but genuinely understands, adapts, and interacts in ways that reflect how humans and societies actually function.
From Rules and Workflows to Context and Meaning
The paradigm shift happening right now is profound:
Old software architecture:
- Built on explicit rules, rigid workflows, and deterministic logic
- Requires humans to adapt to the system’s constraints
- Operates in narrow, predefined contexts
- Intelligence lives in the programmer’s instructions
Emerging LLM-native software:
- Works with context, ambiguity, and meaning
- Adapts to human intent and communication styles
- Can reason about psychological, social, and cultural nuances
- Intelligence is embedded in the system’s behavior, not just its algorithms
This isn’t just a technical evolution. It’s a fundamental rethinking of what software can be and how it should relate to humans.
And this is where European thinking becomes a competitive advantage. Building software that truly understands human context, respects cultural differences, operates ethically under ambiguity, and handles psychological complexity requires exactly the kind of intellectual infrastructure that Europe has been cultivating for centuries.
The Big Idea: We Don’t Need All the Answers — We Need Better Questions
At the heart of this meetup is a manifesto (full version at agent-driven.org) about how to think, not what to think.
Most discussions about AI and the future of software focus on predictions: “AI will do X.” “The future will look like Y.” “This technology will disrupt Z.”
But here’s the uncomfortable truth: we don’t know what’s going to happen.
Experts disagree. Black swans arrive. Models fail. Reality shifts. Most important questions about building AI-native products, encoding ethics into intelligent systems, balancing automation with human agency — these don’t have singular “right answers.”
So what do we do when we can’t predict the future but still need to build it?
We need foundational principles — not answers, but guardrails.
The manifesto behind this meetup argues that what we need aren’t confident predictions or rigid ideologies. We need:
- Critical thinking frameworks that work under uncertainty
- Non-negotiable commitments about what we will and won’t build, regardless of what’s technically possible
- Intellectual humility that distinguishes between what we know, what we think we know, and what we’re just guessing at
- The courage to act even when we can’t be certain of outcomes
Think of it like this: you’re navigating a city in fog. You can’t see the destination, but you can still use a compass. You can still follow principles like “don’t walk off cliffs” and “keep track of where you’ve been.” You can’t eliminate the uncertainty, but you can move forward intelligently.
That’s what this meetup is about: building intelligent software in the fog, with a compass.
It’s about asking: When we build software that can understand context, manipulate psychology, and make decisions we can’t fully explain — what are the lines we won’t cross? What are the questions we must keep asking? What does responsible building actually look like?
These aren’t abstract philosophical questions. They’re intensely practical ones for anyone building LLM-native products right now.
What We’ll Actually Discuss at the Meetup
The first Prague AI-Driven Software Meetup on January 26th is built around a panel discussion with leading figures from the software and AI ecosystem. We’re focusing on questions that actually matter:
On the technical side:
- How are LLMs fundamentally reshaping software architecture? What does “LLM-native” actually mean beyond “we added a chatbot”?
- How do you design products where intelligence is distributed and emergent, not centralized in rule engines?
- How do you build, test, and debug software that has behavior you can’t fully predict?
On the human side:
- What does it mean to encode psychological, personal, and societal logic into software?
- Where’s the line between “software that adapts to users” and “software that manipulates users”?
- How do you build systems that understand context without becoming creepy surveillance tools?
On the strategic side:
- Why might Europe actually be better positioned than Silicon Valley to lead this shift?
- What does it take (technically, organizationally, intellectually) to build these systems today?
- How do you move fast without breaking the things that matter?
This isn’t a pitch-fest. It’s not a recruiting event. It’s not a place to promote your AI wrapper startup.
It’s a space for serious, high-quality discussion about where software is heading and how we can consciously shape that evolution.
Who Should Be There
This meetup is designed for people who are:
- Founders and startup builders exploring AI-native products and wondering how to think about product architecture in the LLM era
- Software engineers and architects rethinking how applications are designed when logic becomes probabilistic and contextual
- Product leaders, designers, and strategists working at the intersection of AI, UX, and human psychology
- Researchers and thinkers interested in the philosophical and societal implications of intelligent systems
If you’re someone who reads about AI and thinks “this is technically impressive, but what does it mean for how we should build software?” — this is your meetup.
If you’re tired of breathless hype about “AI agents” and want to have a grounded conversation about what intelligence in software actually means and how to build it responsibly — this is your meetup.
If you believe that Europe’s philosophical depth, cultural diversity, and ethical sensitivity are strengths, not weaknesses — this is your meetup.
Format and Practicalities
- Date: Monday, January 26th, 2026
- Time: 7:00 PM to 9:00 PM CET
- Location: TBD (we’re currently looking for a great venue in Prague)
- Capacity: We’re keeping this intentionally intimate to ensure high-quality discussion
The evening will include:
- Curated panel discussion with invited guests (lineup to be announced)
- Open debate and audience questions — this isn’t a lecture; it’s a conversation
- High-quality networking with people who are building, researching, and shaping AI-driven software
Current attendee count: 98 registered, 85 attending for the first time.
Get Involved
We’re currently:
- Finalizing our panel guests — if you know someone who must be part of this conversation, reach out with recommendations
- Looking for a great venue in Prague suitable for open, thoughtful, and intellectually honest discussion
- Building a community of people who want to shape the future of intelligent software
This meetup is an experiment. An attempt to create a space where we can seriously ask:
- What should intelligent software become — and how do we build it responsibly, deeply, and with real understanding of humans and society?
Europe has spent centuries thinking about these questions in philosophy, politics, and culture. Now it’s time to bring that thinking into code.
If this resonates with you — if you believe that the future of software should be built with depth, nuance, and humanity at its core — join us.
The Work Continues
As the manifesto concludes: “Builders beat critics.”
This meetup isn’t about criticizing Silicon Valley or lamenting Europe’s supposed disadvantages. It’s about building.
Building software that understands context.
Building systems that respect human agency.
Building applications that adapt to people, not the other way around.
Building a community of serious practitioners who want to do this work well.
The Prague AI-Driven Software Meetup is where that work begins.
See you on January 26th.
Learn more and RSVP:
Search for “Prague AI-Driven Software Meetup” on Meetup.com or follow the event directly.
- Read the full manifesto:
https://agent-driven.org — 100 Axioms for Civilization Builders
- Contact the organizers:
Have questions? Want to recommend a panelist? Looking to sponsor or host?
Reach out through the Meetup page or connect with organizer Jakub Bares.
The startup world is moving fast. But speed without direction is just motion. Let’s move with purpose.
