Most current AI applications treat AI prompts as a simple plugin. You have a form, a prompt, and a linear workflow to generate text or assets.

However, I believe this is not enough. The future of software is not just about generating content. It is about Agents that can think, plan, and coordinate tasks. I built this boilerplate to explore that future.

What do I mean by “Agentic”?

There is a lot of buzz around the word "Agent." Let me clarify my definition.

It is not just a chatbot: A chatbot just replies to text.

It is not just a workflow: A workflow is a static path (A to B to C).

To me, a true Agent must be "alive." It needs state to know its current status. It needs memory to remember context. It must make decisions on its own. Finally, it must have the ability to call other agents to help solve complex problems.

Core philosophy of this boilerplate

I built this system based on three main principles:

Agent-first, not feature-first Usually, we build features (like an "Export to PDF" button). In this boilerplate, we build an Agent that knows how to export a PDF. The agent is the core capability, not the UI buttons. 1.

Conversation-first, no dashboards Complex internal tools often have messy dashboards. I believe the best interface is a conversation. You talk to the system, and the system acts. The UI should focus on the chat, not on static tables and charts. 1.

Explicit orchestration (state machine over magic) I do not like "magic" loops that run forever without control. I prefer explicit orchestration. I use state machines to define exactly what the agent can and cannot do. This makes the system predictable and easy to debug.

High-level architecture

I wanted a stack that is modern, fast, and scalable. Here is the architecture:

FastAPI: This serves as the API and the runtime environment for the backend.

LangGraph: This is the brain. I use it to orchestrate the agent’s logic and manage the state.

SSE (Server-Sent Events): We don’t use simple request/response. The backend pushes events to the frontend in real-time.

Frontend as a “Viewer”: It acts as the communication interface. It focuses on interacting with the user through messages, prompt cards (Generative UI), tool calls, and errors.

What this repo gives you (and what it doesn’t)

What it gives:

• Clean skeleton: A solid structure for an agentic system.
• Orchestrator pattern: A clear way to manage how agents talk to each other.
• Structured design: A specific place to add your sub-agents and tools.
• Event-driven execution: A full model for handling real-time events.

What it doesn’t:

• No UI framework: It provides a basic viewer, not a UI component library.
• No prompt magic: You still need to write good prompts.
• No SaaS features: It does not include billing, user management, or subscription logic.
• Not a chatbot starter: If you just want a "Hello World" bot, this is overkill.

Who this boilerplate is for

This is for you if:

• You are building a Personal Agent, an internal AI tool, or Enterprise AI.
• You want full control over your agent’s logic and flow.
• You hate "prompt spaghetti" (messy code mixed with prompts).

This is NOT for you if:

• You are a low-code user.
• You just want a standard chatbot running in 5 minutes.

How I’m using it (or planning to)

I am using this boilerplate as the foundation for my Personal Agentic Hub. My goals are:

• Journaling / Bookmarking Agent: An agent that organizes my notes and links automatically.
• Long-running Agents: Agents that can keep memory for days or weeks to help me track long-term projects.

Repo & next steps The code is open-source and available here: 👉 https://github.com/chnghia/agentic-boilerplate

My Roadmap:

• Adding support for Sub-agents.
• Implementing long-term Memory.
• Optimizing for Local-first models.

I would love to hear your thoughts. Feel free to leave feedback, start a discussion, or open a Pull Request!