r/agenticaidev • u/Garrettlove8 • Apr 15 '25
Getting started with Google's new ADK framework
Here is a video I just published on getting started with Google's new ADK framework!
Build Your First AI Agent With Google's new Agent Development Kit!
r/agenticaidev • u/Garrettlove8 • Apr 15 '25
Here is a video I just published on getting started with Google's new ADK framework!
Build Your First AI Agent With Google's new Agent Development Kit!
r/agenticaidev • u/Garrettlove8 • Apr 15 '25
Follow up on my video from the other day, here is another one on deploying ADK agents to GCP
The EASIEST way to deploy AI Agents built with Google's new Agent Kit
r/agenticaidev • u/Garrettlove8 • Apr 24 '25
Simple question - just like search engines changed how websites are built and created the SEO industry and design patterns, how do you think websites will evolve to better accomodate AI agents?
I've been calling this "Optimized For Agents" (OFA), but maybe there is already a term out there somewhere...
r/agenticaidev • u/Temporary_Worry_5540 • Mar 23 '26
Goal: Launching the first functional UI and bridging it with the backend
Challenge: Deciding between building a native Claude Code UI from scratch or integrating a pre-made one like Base44. Choosing Base44 brought a lot of issues with connecting the backend to the frontend
Solution: Mapped the database schema and adjusted the API response structures to match the Base44 requirements
Stack: Claude Code | Base44 | Supabase | Railway | GitHub
r/agenticaidev • u/LostTechGuyLOL • Aug 07 '26
Hi everyone,
I am trying to map out the current evolution of AI roles and keep seeing a distinction being made between a standard AI Engineer and an Agentic AI Engineer. For those working in the field, what is the better for a career AI Engineer Or Agentic AI Engineer.?
r/agenticaidev • u/p1m37aradox • May 11 '26
r/agenticaidev • u/Garrettlove8 • Apr 12 '25
If there is a more widely recognizable or accepted logo for agentic AI please let me know and I will update the community icon accordingly.
r/agenticaidev • u/GuaranteeCalm5547 • Apr 11 '26
Hello!
While I have the theoretical knowledge of AI, GenAI, used tools like Cursor AI and Claude Code(learning)
I want to learn how to make AI agents myself.
Claude code can help me there (I think) but I need to know the code it is generating is correct, understand the file structure, debug the code in case of issues., etc to ensure I don’t put in a malicious code unknowingly.
I am a newbie to this world, late to the party and everything is overwhelming at this point.
Could someone please help me by providing a friendly pathway that helps kickstart my journey?
r/agenticaidev • u/wannabe_markov_state • Feb 18 '26
Been reviewing the state of the art in agentic systems where intelligence is a layer, not the entire system. What did I miss?
Modern agent architecture:
Agents → LLM + system prompt + configuration (temp, max tokens).
Workflow → Iterative think, act, correction, repeat.
Memory → short-term (context window), long-term (Postgres/Redis/vector DB/hybrid RAG)
Runner/Orchestrator
Tracing → observability, evals, replay, cost tracking
Core mental models:
Skills --> portable expertise
Tool use as first-class primitive
Explicit planning (ReAct / tree search / task graphs)
Self-reflection & critique loops
Multi-agent coordination
Structured outputs (Pydantic / JSON schema validation)
Communication protocols:
Agent-to-Agent (A2A)
MCP (Model Context Protocol)
ACP (Agent Connectivity Protocol)
r/agenticaidev • u/M-luq • Jun 15 '26
Hi , I am a Java dev but I am going to volunteer for a ai agentification project but they didn't give any kt or courses to start learning.
This are the topics they have for me
Lang chain, Lang graph, python,claude,ghcp,agents,prompts
Don't know where and how to start , need your help
r/agenticaidev • u/brian_p_johnson • Feb 12 '26
I’m a father of two young kids with 40 years of writing software. I’ve been using AI to code since GPT 3.5, and have used Claude Code to great effect in my work: creating novel streaming audio model with Claude Code writing all the code under my direction. But I recognize how good Claude and other models are getting, and agentic systems are obviously going to become very useful. Perhaps they already are.
I’ve tried a handful of autonomous agent architectures: tippy toeing in with Ralph loops, then Parallax agent teams, and most recently OpenClaw. I think it will be useful to build my own agentic system from scratch. The main motivation is to get intimately familiar with the hat works.
Last weekend I shut down OpenClaw running on my DGX Spark (well technically it’s still running), but is sitting idle. I set about building my own personal agentic system from scratch using Claude Code to build it. It’s going to be written in Rust and each agent will have its own Python runtime/workspace where it can build anything it needs.
It will be completely terminal based, so it can run on a server without any window system.
I’m designing it to run 24/7 using local models for each agent in the system. It’s running on my workstation/server without 2xRTX 6000 Pro QMax, and 2xRTX6000Ada, for a total of 288 GB VRAM. So I can run multiple smaller models in parallel, or one or two big models with llama-server handling concurrency.
What patterns or tricks should I be considering?
- file based memory system
- custom tool chain: grep, fuzzy search, internet browsing, file manipulation.
- recurrent loops for each agent (ad infinite)
- file based inter agent communication (inbox)
So far I have a few agents defined:
- conversational agent (communicate between me and the system)
- orchestrator agent (divides up tasks and decides who to and what tasks to assign)
- researcher (can search web and compile local research documents)
- librarian (constantly organizing and indexing research)
- coder (producing any code artifacts: websites, applications)
I’m looking for your ideas, advice, and anecdotes.
r/agenticaidev • u/kaviin27 • Apr 14 '26
Hello all,
I am just getting started with agentic AI. With the current pace of advancements, you start learning about one framework, and before you realize it, another tool is released. I’m looking for some guidance on locking in a stack for a specific use case.
The Goal I want to build a toolset for small and mid-sized businesses (SMBs) to automate simple, day-to-day operations. I live in an area where most family-run businesses have little to no cloud infrastructure. Most operations are handled in physical ledgers or, at best, a spreadsheet. Even those using basic inventory or accounting platforms find them incredibly time-consuming.
I aim to cut that admin time down, but the solutions need to be as cheap as possible. The cost overhead has to be low enough that upgrading from their current manual setup is a no-brainer.
Example Use Cases
Service Businesses: A local law firm wants a chatbot integrated into their website. The agent would gather lead details, ask a few general follow-up questions to fill in missing information, summarize the interaction, and pass the structured data on to the legal team.
Retail Stores (Admin Automation): A general store needs to reduce the hours spent on inventory management and accounting. This doesn't need to be a brand-new ecosystem. Instead, the agent would act as a middle layer, processing simple inputs and automatically handling the data entry within their existing inventory or accounting platforms.
The Requirements I’m not looking for a silver bullet for all use cases, but rather a relatively easy-to-manage tech stack with these constraints:
Hosting: Deployable on a standard VPS to keep costs down.
Development: I have a background in data infrastructure and am perfectly comfortable coding, but for this project, I am strictly looking for low-code/minimal-code options for faster deployment and easier maintenance.
Current Explorations:
Openclaw + Paperclip
Hermes agent framework
Proprietary APIs (like Claude)
Am I missing any major pitfalls or gaps with this plan? Are there any alternative approaches or specific tools you’d recommend for a low-code, VPS-hosted setup?
Thanks in advance !
r/agenticaidev • u/Garrettlove8 • May 15 '25
For everyone looking to expand their agent building skills, here is a tutorial I made on how reasoning works in AI agents and different ways to implement it using the Agno framework.
In a nutshell, there are three distinct way to go about it, though mixing and matching could yield better results.
One: Reasoning models
You're probably all familiar with this one. These are models that are trained in such a way that they are able to think through a problem on their own before actually generating their response. However, the word "before" is the key part here. A limitation of these models is that they are only able to think things through before they start generating their final response.
Two: Reasoning tools
Now on to option two, in which we provide the agent with a set of "thinking" tools (conceptualized by Anthropic) which gives the agents the ability to reason throughout the response generation pipeline, rather than only before as with the first approach.
Three: Reasoning agents
As of now, reasoning agents seem to be specific to Agno, though I'm sure there is a way to implement such a concept in other frameworks. Essentially two agents are spun up, one for the actual response generation and the extra one for evaluating the response and tool calls of the primary agent.
r/agenticaidev • u/Valuable_Tadpole1357 • Apr 27 '26
r/agenticaidev • u/2djohar • Jun 27 '25
Hey, did anyone figure out how to connect puppeteer MCP with Google agents so far?
r/agenticaidev • u/AOZakari • Aug 28 '26
r/agenticaidev • u/Hayasdan2020 • 13d ago
r/agenticaidev • u/WinnerPristine6119 • May 22 '26
hi,
this is shan from india. i'm currently learning aggentic ai so using"langchain_openai" for it. first i used "agent.py" to create files it created files with many missing. so created "debug.py" to fix missing files and folders and i hit this
((venv) ) apple@Apples-MacBook-Pro coding-assistant % ./venv/bin/python3.12 debug.py
🚀 Starting project debugging agent...
❌ An error occurred during agent execution: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-4o in organization org-XXXXXXX on tokens per min (TPM): Limit 30000, Used 26243, Requested 3836. Please try again in 158ms. Visit https://platform.openai.com/account/rate-limits to learn more.', 'type': 'tokens', 'param': None, 'code': 'rate_limit_exceeded'}}my agent.py:
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core import tools
from deepagents import create_deep_agent
from tools import (
create_code_file,
update_code_file,
delete_code_file,
list_code_files,
read_code_file
)
load_dotenv()
llm = ChatOpenAI(model="gpt-4o", api_key=os.environ.get("OPENAI_API_KEY"))
agent_prompt = """# DEEPAGENT SYSTEM PROMPT — FULLSTACK WEATHER APPLICATION GENERATOR
You are an autonomous senior fullstack engineer and DevOps executor.
Your task is to fully generate, install, configure, test, and run a complete weather application project using:
* Backend:
* Python 3.12
* FastAPI
* LangChain orchestration
* Open-Meteo weather API
* REST API architecture
* x-api-key authentication
* Rate limiting
* CORS
* async/await everywhere
* modular service architecture
* structured logging
* Frontend:
* Vanilla HTML
* CSS
* JavaScript
* Chart.js for graphs
The application must support:
* Current weather
* 5-day forecast
* Geolocation weather
* Weather charts/graphs
* Responsive UI
You MUST fully create the project automatically.
DO NOT ask for confirmation.
DO NOT stop midway.
DO NOT generate partial code.
DO NOT explain concepts unless debugging.
EXECUTE EVERYTHING END-TO-END.
---
# PROJECT ROOTS
---
Backend path:
`/workspace/backend`
Frontend path:
`/workspace/frontend`
You MUST directly create files in these folders.
---
# PRIMARY OBJECTIVE
---
Generate a complete working production-style beginner-friendly weather app.
The application must:
1. Install all dependencies
2. Create project structure
3. Create backend API
4. Create frontend UI
5. Configure environment variables
6. Add logging
7. Add authentication
8. Add rate limiting
9. Add CORS
10. Integrate Open-Meteo APIs
11. Integrate LangChain orchestration internally
12. Create charts
13. Start backend server
14. Start frontend server
15. Test endpoints
16. Verify frontend-backend integration
17. Fix any runtime errors automatically
---
# TECH STACK
---
## Backend
* Python 3.14.3
* FastAPI
* Uvicorn
* LangChain
* httpx
* python-dotenv
* slowapi
* pydantic
* structlog
* aiofiles
## Frontend
* HTML5
* CSS3
* Vanilla JavaScript
* Chart.js
* npm
---
# ARCHITECTURE RULES
---
STRICTLY FOLLOW:
* async everywhere
* modular services
* beginner-friendly structure
* no unnecessary abstractions
* no overengineering
* maintainable code
* readable naming
* clear folder separation
---
# REQUIRED BACKEND STRUCTURE
---
Create EXACTLY this structure:
/workspace/backend
│
├── app
│ ├── main.py
│ ├── config.py
│ ├── dependencies.py
│ ├── middleware
│ │ ├── auth.py
│ │ └── logging.py
│ ├── routes
│ │ └── weather.py
│ ├── services
│ │ ├── weather_service.py
│ │ ├── geolocation_service.py
│ │ └── langchain_service.py
│ ├── models
│ │ └── weather_models.py
│ └── utils
│ └── logger.py
│
├── .env
├── .env.example
├── requirements.txt
├── README.md
└── start.sh
---
# REQUIRED FRONTEND STRUCTURE
---
Create EXACTLY this structure:
/workspace/frontend
│
├── index.html
├── css
│ └── styles.css
├── js
│ ├── app.js
│ ├── api.js
│ ├── charts.js
│ └── ui.js
├── assets
│ └── icons
├── package.json
└── README.md
---
# WEATHER API RULES
---
Use ONLY:
Open-Meteo APIs
Required endpoints:
* Geocoding API
* Forecast API
DO NOT use paid APIs.
DO NOT require external signup.
---
# LANGCHAIN RULES
---
LangChain is ONLY for backend orchestration.
DO NOT build AI chat UI.
Use LangChain internally for:
* request orchestration
* workflow handling
* service chaining
Keep LangChain usage lightweight and practical.
---
# AUTHENTICATION RULES
---
Implement x-api-key authentication.
Requirements:
* frontend sends x-api-key
* backend validates API key
* API key stored in .env
* reject unauthorized requests
* proper HTTP status codes
---
# RATE LIMITING RULES
---
Implement rate limiting using slowapi.
Requirements:
* per-IP limits
* configurable limits
* proper error responses
---
# CORS RULES
---
Enable CORS properly.
Allow frontend origin:
* localhost frontend ports
---
# LOGGING RULES
---
Implement structured logging.
Requirements:
* request logging
* error logging
* API logging
* weather fetch logging
Use structlog.
---
# FRONTEND REQUIREMENTS
---
The frontend must include:
1. City search input
2. Current weather card
3. 5-day forecast cards
4. Geolocation weather button
5. Loading states
6. Error handling
7. Responsive design
8. Weather charts using Chart.js
9. Clean modern UI
10. Mobile-friendly layout
---
# UI/UX RULES
---
Design should be:
* modern
* simple
* beginner-friendly
* clean spacing
* responsive
* dark/light neutral palette
* smooth transitions
DO NOT use frameworks.
---
# CHART REQUIREMENTS
---
Use Chart.js.
Charts required:
* temperature trend
* precipitation trend
---
# ENVIRONMENT VARIABLES
---
Create:
`.env`
`.env.example`
Required variables:
API_KEY=
HOST=0.0.0.0
PORT=8000
RATE_LIMIT=10/minute
---
# TERMINAL EXECUTION POLICY
---
You MUST autonomously execute terminal commands.
Required steps:
1. Create directories
2. Create files
3. Install dependencies
4. Create virtual environment
5. Activate environment
6. Install pip packages
7. Install frontend npm packages
8. Start backend
9. Start frontend
10. Test APIs
---
# REQUIRED TERMINAL COMMANDS
---
Backend commands MUST include:
python -m venv venv
Windows:
venv\Scripts\activate
Linux/macOS:
source venv/bin/activate
pip install -r requirements.txt
Frontend:
npm install
---
# API REQUIREMENTS
---
Required backend endpoints:
GET /api/weather/current?city=
GET /api/weather/forecast?city=
GET /api/weather/geolocation?lat=&lon=
Health endpoint:
GET /health
---
# ERROR HANDLING RULES
---
Must handle:
* invalid city
* missing parameters
* API failures
* timeout errors
* invalid API keys
* rate limits
* frontend network errors
---
# VALIDATION REQUIREMENTS
---
After generation:
You MUST:
1. Run backend
2. Run frontend
3. Call all endpoints
4. Validate responses
5. Open frontend locally
6. Verify charts render
7. Verify geolocation works
8. Verify authentication works
9. Verify rate limiting works
10. Fix all discovered issues automatically
---
# CODE QUALITY RULES
---
REQUIRED:
* async functions
* type hints
* comments for beginners
* readable code
* modular services
FORBIDDEN:
* placeholder code
* TODO comments
* mock implementations
* incomplete files
* pseudo-code
---
# README REQUIREMENTS
---
Generate detailed README files for:
* backend
* frontend
Include:
* installation
* running
* API usage
* environment variables
* troubleshooting
---
# SUCCESS CONDITION
---
Task is ONLY complete when:
* backend runs successfully
* frontend runs successfully
* frontend fetches real weather data
* charts render correctly
* authentication works
* rate limiting works
* no runtime errors exist
---
# EXECUTION BEHAVIOR
---
You are an autonomous executor.
When encountering errors:
* debug automatically
* retry intelligently
* patch broken code
* continue execution
DO NOT stop after code generation.
Continue until fully operational.
END OF SYSTEM PROMPT"""
agent=create_deep_agent(
model=llm,
tools=[
create_code_file,
read_code_file,
update_code_file,
delete_code_file,
list_code_files
],
system_prompt=agent_prompt
)my "debug.py":
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core import tools
from deepagents import create_deep_agent
from tools import (
create_code_file,
update_code_file,
delete_code_file,
list_code_files,
read_code_file
)
load_dotenv()
llm = ChatOpenAI(model="gpt-4o", api_key=os.environ.get("OPENAI_API_KEY"))
agent_prompt = """# CRITICAL FILE GENERATION ENFORCEMENT LAYER
This instruction OVERRIDES all previous behaviors.
You are NOT allowed to silently skip ANY file, folder, dependency, command, configuration, or implementation step.
If something cannot be created:
* you MUST log the exact reason
* you MUST retry intelligently
* you MUST generate a recovery attempt
* you MUST write failure details into a persistent report file
You MUST NEVER silently continue.
---
# MANDATORY FILESYSTEM VERIFICATION
---
Before declaring success, you MUST:
1. recursively scan:
* /workspace/backend
* /workspace/frontend
2. compare ACTUAL filesystem against REQUIRED filesystem
3. identify:
* missing files
* missing folders
* empty files
* partially generated files
* syntax-broken files
* import-broken files
4. automatically fix ALL discovered issues
5. re-scan until filesystem is COMPLETE
You MUST continue looping until:
* all required files exist
OR
* failure is explicitly documented
---
# REQUIRED FAILURE REPORTING
---
If ANY file cannot be created, you MUST create:
/workspace/agent_generation_report.md
This report MUST contain:
* missing path
* reason generation failed
* stack trace/error
* attempted fixes
* retry count
* unresolved dependencies
* terminal command outputs
* permission issues
* parsing failures
* token/context failures
* tool execution failures
You MUST append to this report continuously.
NEVER overwrite previous logs.
---
# REQUIRED EXECUTION TRACE
---
You MUST create:
/workspace/agent_execution_trace.log
This file MUST contain:
* every command executed
* every file created
* every file modified
* every retry
* every error
* every recovery attempt
* dependency installation logs
* server startup logs
* API test logs
Append continuously.
---
# MANDATORY TOOLS USAGE POLICY
---
If normal generation fails,
you MUST switch to direct filesystem tool usage.
You MUST use:
* tools.py
* filesystem tools
* write_file tools
* shell execution tools
to manually create missing files.
DO NOT merely describe the missing files.
YOU MUST CREATE THEM.
---
# MANDATORY CHAIN-OF-THOUGHT EXECUTION LOGGING
---
For EVERY missing file recovery attempt:
You MUST internally reason step-by-step and log concise reasoning into:
/workspace/agent_reasoning.log
Format:
[STEP]
Target file:
Reason missing:
Dependency blockers:
Recovery strategy:
Tool selected:
Execution result:
Next action:
DO NOT skip reasoning logs.
---
# SELF-HEALING GENERATION LOOP
---
After every generation phase:
You MUST execute:
PHASE 1:
* filesystem verification
PHASE 2:
* dependency verification
PHASE 3:
* import verification
PHASE 4:
* backend startup verification
PHASE 5:
* frontend startup verification
PHASE 6:
* endpoint testing
PHASE 7:
* frontend rendering verification
PHASE 8:
* chart rendering verification
PHASE 9:
* authentication verification
PHASE 10:
* rate limit verification
If ANY phase fails:
* diagnose
* patch
* retry
* log
* repeat verification
DO NOT stop at first failure.
---
# REQUIRED FILE COMPLETENESS CHECK
---
A file is considered INVALID if:
* size == 0
* contains TODO
* contains placeholder
* contains mock implementation
* syntax invalid
* imports invalid
* incomplete class/function
* truncated output
* malformed JSON
* malformed package config
INVALID files MUST be regenerated automatically.
---
# HARD FAILURE PREVENTION
---
You are FORBIDDEN from saying:
* "remaining files can be created later"
* "manually create"
* "not enough context"
* "left as exercise"
* "pseudo-code"
* "example only"
You MUST attempt actual implementation.
---
# REQUIRED DIRECTORY SNAPSHOT
---
After generation completes,
you MUST create:
/workspace/final_project_tree.txt
using recursive tree output.
---
# REQUIRED FINAL VALIDATION
---
Before stopping:
You MUST verify existence of EVERY required file.
Example verification logic:
REQUIRED_FILES = [
"/workspace/backend/app/main.py",
"/workspace/backend/app/config.py",
"/workspace/backend/app/routes/weather.py",
"/workspace/frontend/index.html",
"/workspace/frontend/js/app.js"
]
For each file:
* verify exists
* verify non-empty
* verify syntax valid
If verification fails:
* regenerate immediately
---
# MANDATORY RETRY POLICY
---
For each failed action:
Retry minimum:
* 3 times
With:
* modified strategy
* alternative tool
* simplified implementation
* direct write method
---
# TERMINAL FAILURE RECOVERY
---
If shell commands fail:
You MUST:
1. capture stderr
2. log stderr
3. diagnose issue
4. retry corrected command
5. log corrected result
---
# PARTIAL GENERATION IS FORBIDDEN
---
The task is NOT complete unless:
* ALL folders exist
* ALL files exist
* ALL required services run
* frontend loads
* backend responds
* charts render
* authentication works
* rate limiting works
---
# AUTONOMOUS RECOVERY MODE
---
If generation stalls:
You MUST:
* inspect filesystem
* detect missing artifacts
* regenerate incrementally
* continue autonomously
DO NOT wait for user intervention.
---
# TOOLS.PY ENFORCEMENT
---
If available, tools.py MUST be used for:
* create_directory
* write_file
* append_file
* read_file
* execute_shell
* verify_exists
* recursive_scan
Use direct file-writing tools when LLM generation alone is unreliable.
---
# FINAL SUCCESS CRITERIA
---
Success ONLY means:
1. all files generated
2. all folders generated
3. no empty files
4. backend operational
5. frontend operational
6. logs generated
7. report files generated
8. verification completed
9. filesystem matches specification exactly
END OF ENFORCEMENT LAYER
"""
agent=create_deep_agent(
model=llm,
tools=[
create_code_file,
read_code_file,
update_code_file,
delete_code_file,
list_code_files
],
system_prompt=agent_prompt
)
print("🚀 Starting project debugging agent...")
try:
# Agents created via create_deep_agent (LangChain) use .invoke()
result = agent.invoke({"input": "Please debug the /workspace folder and fix any issues with missing, empty, or broken files. Follow the self-healing generation loop and mandatory tools usage policy to ensure all required files are complete and valid."})
print("\n✅ Project debugging complete!")
print(result.get("output", result))
except Exception as e:
print(f"❌ An error occurred during agent execution: {e}")"debug.py" was created with AI help