I design multi-agent systems in LangGraph — the kind that reason about which path to take before acting — then wrap them in a native Flutter/Android app with Django or Firebase underneath. Below is the actual routing logic behind one of my agents.
I work at the intersection most teams split into two hires: the person who builds the agent that makes decisions, and the person who builds the Android app people actually open. Doing both myself means the handoff between "the agent decided X" and "the user sees X on screen" never gets lost in translation.
My agent work is built on LangGraph — routing logic, conditional tool calls, and multi-agent coordination, not single-shot chatbot prompts. My app work is Flutter for native Android, backed by Django or Firebase depending on what the project needs.
Real projects, broken down the way I actually approached them: the problem, what I built, and what came out of it.
Parents can't watch a live feed all day, and raw activity predictions from a model aren't useful on their own — someone still has to decide what's actually worth an alert.
Trained ML models classify child activity in real time. A LangGraph multi-agent system takes those classifications, applies decision logic, and autonomously triggers parental alerts — no human in the loop deciding what counts as urgent. A Django backend serves the ML inference engine and connects to a Flutter/Kotlin Android app.
An end-to-end system where the agent, not the parent, decides when something needs attention — turning raw model output into a context-aware alert inside a native Android app.
Most study tools give everyone the same static notes regardless of what they already know, and a quiz that isn't graded against what the person actually learned defeats the point of studying.
Built the LangGraph agent visualized at the top of this page: it first decides whether a topic even needs outside research, then routes between Wikipedia for basic topics and Tavily search for advanced ones, generates notes from whatever it finds, and finishes by writing and auto-scoring a quiz on those notes.
One agent that adjusts its own research depth per topic instead of following a fixed script, then closes the loop by testing and scoring what the user actually learned.
Understand the task, the user, and where autonomous decision-making actually helps versus just adds complexity.
Design the agent's routing logic and tool calls, or the app's screens and data model — on paper, before code.
Develop in short, testable cycles — agent logic, backend, and Flutter UI in parallel, not in sequence.
Deploy the backend and push the app toward the Play Store, then support and iterate post-launch.
Whether it's an agent that needs to make real decisions, an Android app, or both working together — let's talk about it.