Giving AI assistants eyes: Reflecting on my Symfony Mate talk at SymfonyLive Berlin
Two weeks ago I stood on stage at SymfonyLive Berlin and introduced Symfony Mate to the community. It was two intense days of conversations. About Mate. About Sulu. About AI. And about everything that ties those three together.
I’ll be honest. I was a bit nervous walking on stage. There had already been a lot of strong talks. I opened with a short story about my kids — and a small jump. Not quite the dancing that was jokingly suggested the night before, but close enough. It broke the tension, got everyone’s attention — and from that moment on, I could just enjoy the talk.
The feedback afterwards was more than I had hoped for. In the hallway. During dinner. In the late-night conversations. Thank you. This post is my attempt to share the talk itself and what happened around it.
Why Mate exists
A bit of context before I get into the talk itself. Mate is a private initiative. I started it on my own time, and I am still the one driving it forward today — with a growing circle of contributors and supporters around it, but not as part of any company's roadmap.
AI coding assistants are powerful, but they are still blind to what your application is actually doing while it runs. Mate gives them access to the right runtime information, so they can stop guessing and start diagnosing.
That was the opening line of the talk. It is also the whole point. Everything else — the architecture, the extension story, the MatesOfMate organization — exists to serve that one idea.
Familiar faces in the hallway
What made Berlin special was not only the talks. It was the people, and the fact that so many of them already feel like old friends.
Nils, an old friend and right now probably one of the worst-sleeping PHP developers I know. Everything happening in the security world is keeping him up. Catching up with him is always a small masterclass.
Chris Hertel, Oskar Stark, and Tobias Nyholm. My fellow fighters in symfony/ai, and the ones who have had Mate's back from day one.
Roland, our "techfluencer", who always brings a different angle.
Nicolas, who let me pitch Mate to him one more time in the hallway. I think — and hope — he actually got excited about it.
And Eloïse, who again pulled off a wonderful conference. None of this happens without her.
Talks that tied directly into mine
One of the things I love about a single-track conference is that the talks start to echo each other. Three of them tied directly into Mate.
Nicolas Grekas on "Reconfiguring Symfony in real time with sidekicks"
The headline feature was sidekicks, but the deeper point was statelessness: PHP's request model means every request starts from zero. His punchline — "PHP can't listen, it can only ask" — fits AI assistants almost perfectly. Each conversation starts from zero. They have no memory of the last request. They can only ask. The real question is what they are asking, and who is answering. Without Mate, they ask your files. With Mate, they can ask the profiler, the container, the logs — things that actually know.
Dave Liddament on "AI Writes Code. PHPStan Keeps It Honest".
Dave walked through his AI-assisted coding workflow and how he uses PHPStan and similar tools to keep quality high when the AI writes more of the code. He was very interested in Mate afterwards, and his pyramid even made it into my slides. Code review on top. Plan mode below that. Then CLAUDE.md, Skills, Agents. And at the very base, deterministic checks like tests and static analysis.
Mate lives at the interface between agents and that deterministic base. It is the layer that lets the agent reach down into things that do not guess — the profiler, the container, the logs — and pull the answer back up. Everything above only works because the base is solid, and because the agent has a clean way to ask it.
Tobias Nyholm on "Make your AI useful with MCP"
Right after my slot, Tobias went on stage with "Make your AI useful with MCP" — a deep-dive on the protocol itself. That pairing was not an accident. My talk was deliberately light on MCP internals because Tobias was about to go deep on them right after me. I showed what you can do with a well-designed MCP server for PHP; Tobias showed why MCP as a protocol is the right layer for it. Seeing the audience move straight from my demo into his talk was one of the most satisfying parts of the day.
The other talks I enjoyed the most
Not every great talk had to connect to Mate. A few stuck with me purely because they were excellent.
Pauline on "Git, But Better: An Introduction to Jujutsu (jj)".
A brand-new topic for the whole room, and Pauline delivered the internals, the tool itself, and the why with so much energy that she could probably have sold bananas to the same audience. It was one of those talks where you walk out genuinely interested in something you had never heard of an hour earlier.
David on "Simultaneous editing: Easy mode with Symfony UX".
Turbo, Stimulus, Mercure. David reminded the whole room how little code you actually need to build reactive UIs in Symfony if you lean on the components that are already there. It is the kind of talk that quietly changes what you reach for in your next project.
Chris Hertel on "Symfony AI in Action".
A perfect overview of the last months of the AI initiative. It is honestly a little wild to see how far we have come since July 2025 — Platform, Agent, Store, Mate, community extensions, real adoption. Chris has been holding it together from the start, and the talk made the trajectory visible in a way no single contributor ever sees from the inside.
Magda on "AI culture in open source: the Sylius way"
A thoughtful, refreshingly honest look at how the Sylius team builds an AI-aware culture inside an open source project — what they try, what they deliberately do not do, and what it takes to make AI tooling help a community rather than pull it apart. As a maintainer of another Symfony-based open source project, I took a lot of notes. I also share her broader view. The load on developers is going up, not down. A big part of that comes from how fast our jobs are changing right now. New tools. New workflows. New expectations. All at the same time. It is easy to frame that as exciting — and it is — but it is also a lot. We all need to look after ourselves and each other. Thank you, Magda, for putting that on stage.
A lovely Sulu cameo in the evening
One of my favourite moments of the conference did not happen during the official schedule at all. On the evening of the first day, our long-time friend Karsten Frohwein walked up and did a spontaneous lightning talk about Sulu. No slot in the program, no elaborate preparation — just Karsten, the community, and a few minutes of genuine enthusiasm for the project. What made it even more fun: during a break earlier that day, I had quickly thrown together a handful of slides for him that he had never seen before. He rolled with it on the fly, as only Karsten can. It was warm, it was fun, and it was exactly the kind of thing that reminds you why you keep showing up to these events. Thank you, Karsten.
What I took home from the feedback
People stopped me at the coffee break, at dinner, in the train-station-spontaneous-discussions we all know from conferences. Some of those conversations were quick — the kind you can answer in two sentences and a link. Others went deeper, into the design questions you only really feel once you have tried to build a tool yourself. I do not have one-line answers for most of those. I came home with a notebook full of them.
But the feedback I am most grateful for is the kind that does not fit in any notebook. The quiet "I think this solves a problem we didn't even think of." The half-sentences that hint at a project already forming in someone's head. The thank-yous that come back hours later, once a thought has had time to settle. Those are why I keep building this.
Embedding Mate deeper in the Symfony ecosystem
Beyond the familiar-faces part, I had long, focused conversations with several Symfony core members about how to anchor Mate and the MCP-for-PHP story more firmly in the broader ecosystem.
The clearest direction we kept coming back to: bring Mate, and the MCP-for-PHP story behind it, closer to and more closely integrated with the core components of Symfony. Not as a side track that lives next to the framework, but as something woven into the parts of Symfony that developers already touch every day. That is the main direction — everything below is a concrete step on the way there.
Some of the topics we worked through:
- PHAR distribution to eliminate the last dependency-conflict class of problems, so Mate can be a true drop-in dev tool for any PHP project.
- Knowledge extensions — RAG-powered, provider-agnostic documentation search as an MCP tool, starting with Symfony docs and opening up to any third-party library.
- Reusing and patching `symfony/flex` for the gluing work. Instead of inventing our own wiring layer, we want to lean on `symfony/flex` and extend it where needed. Agent configuration, extension instructions, and MCP wiring should show up in a project the same way Symfony developers already know. Less plumbing on our side. A familiar workflow on the user side.
- Aligning `symfony/ai` and Mate as one story. Same naming. Same package structure. Same configuration patterns. Same release cadence. So "your app uses AI" (Platform, Agent, Store) and "AI uses your app" (Mate) feel like two halves of the same toolkit, not two neighboring projects. A Symfony developer reaching for AI-assisted development should find the same vocabulary and the same mental model on either side.
These are not announcements yet. They are directions. But the fact that there is real alignment with the people shaping the ecosystem is what gave me the most confidence coming out of Berlin. Mate does not have to be a lonely side project. It can be a piece of a larger, coherent story the Symfony community tells about AI-assisted development.
The talk itself: what I showed on stage
If you were not in the room and want the technical core of the talk, here it is in four short sections — the problem, the demo, the thesis, and the architecture. If that is not your thing, feel free to skip ahead to "What is next".
The blind search problem
The talk opened with a very normal prompt: "This page is slow, find the performance problem." Without runtime access, a typical AI assistant starts reading files — the controller, the entity, the repository, the Twig template — trying to reconstruct the execution path from code alone. Every file costs tokens, most turn out to be noise, and the search is non-deterministic: ask the same question twice and you may get two different answers. Worst of all, you cannot optimize random guessing.
One tool call instead of ten file reads
For the demo I used a tiny Symfony blog app with a classic N+1 problem: every post triggers a separate query for its comments, which adds up to about 100 duplicate `SELECT ... FROM comment WHERE post_id = ?` queries on every page load. I ran it twice. First without Mate — Claude Code guessing its way through files. Then, live on stage, three commands:
composer require --dev symfony/ai-mate
vendor/bin/mate init
composer require --dev symfony/ai-symfony-mate-extension
Same question, same codebase, same model. This time the assistant went straight to a profiler tool and got back something compact and actionable:
{
"query_count": 101,
"total_time_ms": 1.56,
"duplicate_queries": [
{
"sql": "SELECT ... FROM comment WHERE post_id = ?",
"count": 100,
"total_time_ms": 1.22
}
]
}One call. 101 queries, 100 duplicates. Diagnosis in seconds. The assistant was not smarter — same model, same knowledge. It just had runtime data instead of having to infer it. A well-designed tool gives the smallest useful truth; the AI does not need your full codebase, it needs the right signal at the right moment.
The thesis: better context, not more context
Running the demo back to back made the argument almost visual. Yes, tools cost tokens — descriptions, calls, and responses all take up context. But the real cost is not having a good tool: without one, the AI burns thousands of tokens on files that do not matter. Tools are deterministic, they return the same shape of answer every time, and you can optimize them over time. Random file reading cannot get better.
That is why MCP — the Model Context Protocol — matters, and why we built Mate on top of the PHP MCP SDK, which itself is a joint effort between Symfony, the PHP Foundation, and the MCP project.
Under the hood, in one paragraph
I walked the audience through three design decisions — Mate builds its own DI container (so it keeps working even when your app's container is broken), it uses Composer-based extension discover* in the same spirit as PHPStan or PHPUnit, and the core is framework-agnostic with Symfony, Monolog, and Sulu living in optional extensions. On top of that, every extension ships an `INSTRUCTIONS.md` that teaches the assistant when to call a tool — which is what quietly makes the whole thing token-efficient. The details are in the slides and the docs; what matters here is that all three decisions exist to let the ecosystem grow without a central bottleneck.
What is next
The roadmap is pragmatic. PHAR distribution to solve dependency conflicts once and for all. Replacing our Composer plugin with `symfony/flex` for project setup. Knowledge extensions as a first-class concept — project and framework-specific knowledge bases, richer context beyond just tools. And, above all, growing the MatesOfMate ecosystem: the more extensions the community builds, the more useful Mate becomes in real projects.
If you want to dig in:
- Slides, speaker notes, and the full demo app: github.com/wachterjohannes/symfony-mate-berlin
- Mate docs: symfony.com/doc/current/ai/components/mate.html
- symfony/ai: github.com/symfony/ai
- MatesOfMate community extensions: github.com/MatesOfMate
- The MCP spec itself: modelcontextprotocol.io
Thank you
Mate did not appear fully formed. It came from discussions, shared curiosity, and people willing to build in public. The folks who carried it with me know who they are — I told them in Berlin, and I will keep telling them. Thank you also to the wider Symfony community for the questions, the pushback, and the conversations that made the trip worth it.
If you have an idea — for a tool, an extension, a component — find the people who share your excitement and just do it. And if your idea fits Mate, I would love to hear about it.
