CarePath: An Agentic Childcare Navigator

Inspiration

CarePath started from a problem I experienced myself.

While on parental leave in Japan, I began researching childcare applications for my son. I quickly realized that applying for childcare is not a single task. Information is scattered across municipal websites and documents, eligibility and procedures depend on the household, and parents need to keep track of nurseries, deadlines, required documents, and application steps at the same time.

What I really wanted was not another search tool or chatbot that would simply answer individual questions. I wanted something I could give a high-level goal to — such as "I want my child to start nursery in April" — and have it help turn that goal into a concrete plan.

That became CarePath.

What it does

CarePath is an agentic childcare application navigator.

A user starts with a childcare enrollment goal. CarePath then coordinates specialized agents and deterministic services to turn that goal into an actionable application plan.

The system can help:

• discover childcare options;
• research application requirements;
• organize required documents and application steps;
• identify risks such as an unverified deadline;
• track progress across tasks; and
• determine the next action the parent should take.

Rather than treating each question independently, CarePath maintains the state of the overall goal. Its dashboard brings that state together so the user can see what has been found, what remains unresolved, and what to do next.

The current MVP retrieves official childcare information from Setagaya City, Tokyo, while the architecture is designed to support additional municipalities through municipality-specific source providers.

How I built it

I built CarePath by combining Google Agent Development Kit (ADK) and Gemini 3.6 Flash with deterministic Python services.

CarePath uses two Google ADK agents where model reasoning is valuable. The Planner Agent interprets the user's high-level childcare goal and proposes an initial plan and tasks. The Application Guide Agent extracts application requirements and steps from official municipal sources.

Other parts of the workflow deliberately use deterministic services. Nursery Discovery retrieves and parses official childcare data, while deterministic services handle validation, task reconciliation, risk assessment, progress calculation, and next-action selection. The overall workflow is orchestrated by CarePath's Python application code.

Cloud Firestore provides persistent storage for goals, tasks, nursery candidates, application requirements, document progress, risks, and source provenance. Rather than producing a one-time answer, the workflow incrementally persists state as it progresses.

I also built a read-only dashboard that turns this persisted state into an actionable view for the user. The dashboard is containerized and deployed on Google Cloud Run, with the container image stored in Artifact Registry.

CarePath retrieves official Setagaya City childcare guides and municipal web pages as its external data sources. Application facts retain source provenance so that users can trace information back to the official source.

For this MVP, official-source retrieval targets Setagaya City, Tokyo. The source-provider architecture is designed so that additional municipalities can be supported by adding municipality-specific source definitions and retrieval logic.

I used ChatGPT and Codex as development partners throughout the project. I defined the product requirements, architecture constraints, safety boundaries, and priorities, while using coding agents to help implement and test the system. An important part of the process was continuously reviewing what the coding agent had actually changed rather than treating generated code as a black box.

Challenges I ran into

One of the biggest product challenges was deciding what not to build.

It was tempting to keep adding capabilities, but childcare applications are a domain where incorrect or outdated information can have real consequences. I therefore separated model reasoning from deterministic state management, preserved provenance, made uncertainty visible, and kept the dashboard read-only rather than allowing the agent to submit applications or make consequential decisions for the user.

I also learned to build incrementally: first establishing the domain model and agent workflow, then persistence, then progress tracking, and finally the dashboard and cloud deployment.

I also encountered a Cloud Run frontend routing issue late in development. Diagnosing it required separating application behavior from infrastructure behavior and systematically checking routing, IAM, ingress, and revision configuration. Rather than letting the issue block the project, I kept the architecture testable in layers and continued validating the workflow, persistence, and dashboard independently.

Accomplishments that I'm proud of

First and foremost, I am proud that I turned an idea born from a real problem in my own life into a working system.

Before tools like coding agents became available, I often had product ideas but did not have enough software development experience to implement an entire application independently. With this project, I was able to go from requirements and architecture to agents, persistence, tests, a dashboard, containerization, and cloud deployment.

I am also proud that CarePath became more than a demo chatbot. It maintains goal state, combines agentic reasoning with deterministic services, persists its work, tracks unresolved risks, and continually answers an important question:

"What should I do next?"

What I learned

The biggest lesson was that coding itself is becoming less of a bottleneck, but knowing what you want to build is becoming more important, not less.

Working with coding agents taught me that I still need to understand what the agent is implementing. I learned to define explicit boundaries — including what an agent must not do — and to constrain model reasoning when deterministic logic is safer or easier to verify.

I also learned the value of iteration. Building the smallest useful version, testing it, reviewing what was actually created, and then deciding on the next increment was far more effective than trying to design the perfect product from the beginning.

Most importantly, I learned that AI-assisted development can allow someone with a strong understanding of a problem — even without being an expert application developer — to turn that understanding into a real product.

What's next for CarePath

The current MVP is only the beginning.

I would like to expand CarePath from childcare applications into a broader agentic navigator for family and local-government procedures: situations where people know what they want to achieve but have to navigate fragmented information, deadlines, documents, and administrative rules to get there.

For CarePath itself, the next step is to close the interaction loop. I want users to be able to enter their own childcare goals and household information, update their progress as they complete tasks or obtain required documents, and have CarePath continuously recalculate risks, progress, and the next best action.

I also want to improve municipal data retrieval, strengthen provenance and freshness checks, and support more local governments. Consequential actions, such as submitting an application, would remain under the user's control.

Ultimately, I want CarePath to make complicated administrative processes feel less like navigating a bureaucracy and more like following a clear path.

Built With

• chatgpt
• cloud-run
• codex
• firestore
• gemini
• google-adk
• google-cloud