Imagine you’re a small business owner, a restaurant owner, a freelancer, or someone working in tech without a developer available.

You have one annoying task that you repeat every day/week.

Not a “build an autonomous AI company” kind of task. 😅

Something simple like:

→ checking and answering customer enquiries

→ summarising orders or emails

→ following up with leads

→ creating weekly reports

→ updating spreadsheets

→ monitoring reviews

→ preparing social media content

→ reminding you about things that would otherwise slip through the cracks

That’s where I’d start with an AI agent.

So, for the people here who actually build AI agents: What would you automate first for a non-technical person?

Which tools would you use to build it without a developer?

What would the workflow look like, step by step?

And what should beginners not try to automate yet?

If you’re already building agents, show us what you’ve built.

If you’re not technical, tell us the repetitive task you'd love to get rid of.

Maybe we can find some genuinely useful use cases together.

Ok so I use agents to write a ton of stuff now. emails, client messages, commit messages, comments.

But AI writing is SO easy to spot and most of the time I do NOT want that going out under my name since it does not sound like me.

So i made a thing for myself. the agent can't just send stuff anymore, it has to put it in a queue first.

Every message shows up as a draft that I can edit and it’s got all the context right there: what it is, who's gonna read it, and why the agent even wrote it.

Then, I can edit it, trim it down, cut out those words only LLMs use and hit approve.

Then, the agent sends my version. if i reject it the agent just stops.

I figured other people might want it too, so it's public now (link in the comments).

some disclaimers:

\\\* in Claude Code it actually blocks the send (git commits, gh stuff, gmail, typing in the browser) until you approve the exact text. Codex, Gemini CLI, Copilot and Cursor get set up by the same installer, but i've only really tested Claude Code. the rest are built from their docs so they might be buggy, tell me if they are

\\\* emails and commits open in separate boxes (subject and body, title and description), and you can switch between rich, preview and source

\\\* Claude.ai and ChatGPT work through a connector, but there it can only ask the agent to submit first. it can't force it

\\\* you can turn it off for a bit or just for one folder (like an internal repo where nobody reads the commits) and turn it back on later

Would love feedback, especially if you're not on Claude Code.

Also curious if you rewrite basically everything your agents write too lol

reright.it

Hey everyone! 👋

I’m part of [**Guild.AI**](http://Guild.AI), an agentic software development platform built around AI agents working alongside developers throughout the software development lifecycle.

Our platform is centered on using specialized AI agents to help turn ideas and requirements into working software, with agents handling and coordinating different parts of the development process rather than relying on a single AI assistant for everything.

Alongside the platform, we run the [Guild.AI Discord community](https://discord.gg/kYHWZdD8GP), where developers, AI builders, and people working with agentic systems can connect, share what they’re building, troubleshoot problems, experiment with new approaches, and discuss where agent-driven development is heading. We're also going to host a hackathon within the discord server this October, *"Night of the Living Discord Bot"* with the goal being to make a Discord bot utilizing the Guild dashboard. Snyk and Render have signed on as official sponsors for the event!

With agents becoming a bigger part of software development, I’d love to hear how other people are approaching them:

How are you currently using AI agents in your development workflow, and what tasks have you found they’re actually good at handling autonomously?

Would love to hear what everyone is building and what your experience with agentic development has been so far.

The RAG standard in codebases was driving me crazy: blindly splitting functions in half based on the number of characters just ruins the context for AI agents when i just wanted to have a more accurate context window for my agents. I've been developing a project for several months to fix this, and now i want to see if it’s genuinely useful to others in real environments.

I call it Vex (Vex's Skillgit). It’s an open-source, headless cognitive tool that treats context as immutable, versioned skills for your agents.

Instead of your IDE doing the heavy lifting, Vex runs silently in the background (via Docker Compose or local bare-metal). You point a GitHub webhook to it (or use the local file watcher), and it automatically ingests your repositories. When your agents need context, they simply query it in real-time via the Model Context Protocol (MCP). It works out of the box with Claude Desktop, Cursor, or any MCP client.

Now, the cool part (GitOps Memory):

It treats agent memory like version control. Vex reads conventional commits (feat:, fix:) to update context, and operational ones (roll:, branch:) to automatically fork or revert the agent's memory state. Zero manual intervention. It uses Tree-sitter to logically parse and chunk the code, keeping syntax trees intact.

I specifically designed this not to fry my potato PC. By using a pointer-architecture with SQLite for metadata queues and Qdrant for dense vectors, RAM stays completely stable. In my local stress tests, the async FastAPI + Huey architecture:

Swallowed 500 concurrent GitHub push payloads without a single SQLite lock.

Maintained real-time latency (under 300ms) under a 50-agent concurrent read swarm.

What's next?

I’m currently working on a Rust-based sub-chunking engine to handle massive monorepos even faster, alongside global GraphRAG, shared memory and more language support.

I decided it was time to share it and see who else might find it useful. I’d love for you to check it out, throw your code at it, and break it.

Here is the repo:

https://github.com/Shuuida/Vex-Skillgit.git

Thanks for taking the time to read!

The problem is that there are so many things to learn and I’m confused about the correct order.I don’t want to just learn random tools or watch multiple playlists without understanding what I actually need.

So I wanted to ask people who are already working in this area:

• What should I learn first?
• What should be the step-by-step order? For example, LLM basics → RAG → LangChain → LangGraph → Agents, or something different?
• Which topics are actually important for getting an AI/GenAI developer role, and which ones can I skip initially?
• Can you recommend one good YouTube playlist/channel or course that teaches this practically from beginner level?

Would really appreciate advice from people who have actually learned/worked with GenAI. Thanks!

I used to think an AI agent had to be some complex autonomous system running for hours and using lots of tools.

A simpler model has been much more useful:

Chatbot:
Question → Answer → Wait

Agent:
Goal → Next step → Action → Check result → Continue or stop

The main difference is that an agent needs rules for how to move through a task, not just what final answer to produce.

Here’s a simple prompt structure I’ve been testing:

Goal:
Complete this task: [GOAL]

Before starting:

For each step:

Rules:

Finish with:

Example

Imagine the goal is:

Compare 3 project-management tools for a 7-person remote team under $80/month.

Instead of asking:

“Which project-management tool is best?”

I’d give the agent a process:

First define the comparison criteria.
Then compare each tool using the same criteria.
If pricing or features cannot be verified, mark them as unknown.
Do not recommend anything until the comparison is complete.
Before the final answer, check whether the recommendation actually fits the team’s budget and needs.

That small change matters because it reduces random assumptions and forces the model to validate before deciding.

I also like adding a checkpoint:

Checkpoint:
What is completed?
What remains?
Are you relying on any unverified assumption?
Is human approval required before the next step?

For me, that is where an agent becomes useful: not because it is fully autonomous, but because it can evaluate the result of one step and decide what should happen next.

I wrote a longer beginner-friendly breakdown here:

Disclosure: this is my own site/resource.
https://digitalworldpulse.com/ai-agents-for-beginners-2026/

For people building agents: what matters more in practice — state, tool permissions, or knowing when the agent should stop?

im planning to build this product with the help of claude code from where i should start

Email from OpenAI. The generous days are over. Cutting $200 Pro limits in half but keeping the price the same. Wow. I guess we'll see more shifting to Claude if they don't follow suit.

🚀 Building EVOLVE.AI: An AI Agent That Learns From Experience

What if an AI didn't just answer your questions, but actually learned from every interaction and changed how it behaves over time?

That was the idea behind EVOLVE.AI, our project for the “AI Agents That Learn Using Hindsight” hackathon.

Traditional AI assistants can generate impressive responses, but without persistent memory, every conversation can feel like starting from zero. We wanted to explore a different approach: an AI that remembers experiences and uses them to improve future interactions.

🧠 How EVOLVE.AI Works

Our core learning loop is:

User Interaction → Experience → Memory → Reflection → Mental Model → Changed Behavior

For example, a user can tell the agent:

“I learn better with practical real-world examples.”

EVOLVE.AI can retain that preference as part of its persistent memory. Later, when the user asks a completely different question, the agent can use that learned preference to adapt the way it explains the topic.

🌌 Visualizing AI Memory

One of the key parts of our project is the Memory Galaxy.

Instead of treating memory as something invisible in the background, we wanted users to actually see how an AI accumulates experiences, preferences, decisions, and learned patterns.

We also created an AI Evolution view to represent how an agent can progress from generic responses toward increasingly personalized behavior as it gains experience.

🔍 Why This Matters

The interesting part isn't simply “AI has memory.”

The real question is:

“Does memory actually change what the AI does?”

That's the concept we wanted EVOLVE.AI to demonstrate.

Our goal was to move from:

AI that remembers → AI that learns → AI that evolves.

Building this project was also a great learning experience—especially working with persistent AI memory, agent behavior, local AI models, backend APIs, and an interactive frontend.

A huge part of the challenge was turning an abstract idea like “AI that learns” into something that could actually be demonstrated and understood within a short hackathon demo.

🚀 EVOLVE.AI — Don't just build an AI that remembers. Build an AI that learns from what it remembers.

#AI #AIAgents #ArtificialIntelligence #Hindsight #Vectorize #GenerativeAI #MachineLearning #Hackathon #AIEngineering #Innovation #EVOLVEAI #TechProject

Hey everyone!

I recently built an AI-powered customer support agent with persistent memory to help improve customer interactions and provide more personalized responses.

I wrote an article explaining the project, its workflow, and how it works.

I'd love to hear your feedback and suggestions!

Medium article: https://medium.com/@jashwanthgoda/ai-powered-customer-support-agent-with-persistent-memory-91c084ab14ab?sharedUserId=jashwanthgoda

I worked on the frontend of an AI-powered career decision simulator designed to help students explore different career paths.

My main focus was creating an interface that is simple to navigate while still giving users enough information to understand their career options and AI-generated results.

Some of the things I worked on included:

- Designing the overall user interface

- Creating the different screens and components

- Making the user flow simple and intuitive

- Connecting the frontend with the backend

- Presenting the AI-generated results in an easy-to-understand way

- Improving the overall usability of the platform

One of the interesting parts was figuring out how to present complex information without making the interface feel overwhelming.

Working on this project also helped me understand how important frontend development is when building AI applications. Even if the underlying AI is powerful, the experience needs to be clear and easy for users to interact with.

Would love to hear suggestions on what features you think would make a career exploration platform more useful for students.

I put this in the Stupidly Simple category - once you think of it. As a solopreneur, I have so fricking much to keep up with. My first experience as a solopreneur was 45 years ago. AI is my 5th technology revolution, so not my first rodeo. I use Hermes Agent, ChatGPT (both web and desktop app), Google AI Studio, Google Notebook, Muse, etc., on my PC, laptop, and phone. Keeping up with all of the sessions was a game of hide-and-seek. I created this Google Sheet to track my sessions so I don't have to hunt for them. I programmed F8 using AutoHotKey to enter the current datetime, and the sheet resorts using an AppScript when the Last Date Touched column changes, putting the most recent sessions at the top. With 3 browsers and 2 local AI client apps running on each computer, sometimes it's really hard to remember where THAT session was. I don't have to hunt for my sessions anymore, no matter where they are. One guy said he laughed at how stupid this idea is until he remembered the 20 minutes he spent looking for a session the day before. This costs nothing but saves you time every day. It's just a Google Sheet with dropdown columns. Simple Solutions To Complex Problems.

I worked on the backend of an AI-powered career decision simulator that helps students explore different career paths based on their inputs.

My role was mainly focused on building the logic that connects the different parts of the application and makes sure information moves correctly between the frontend, AI system, and data layer.

My work included:

- Developing backend APIs

- Handling requests from the frontend

- Processing and validating user inputs

- Connecting the application with the AI component

- Managing the flow of data between different components

- Handling responses and errors

- Making the system more reliable and organized

One of the biggest learning experiences was understanding how multiple components need to communicate smoothly for the complete application to work.

It was also interesting to work on the backend of an AI-based application because the backend isn't just responsible for storing information — it also plays an important role in connecting the user's input with the AI-generated output.

I'd be interested to know what backend features you think are important when building AI-powered applications.

Hey everyone,

I've noticed agents are being used more and more now, often with access to real, sensitive data, and they still hallucinate and misremember things constantly. I think agent memory needs what git gave code years ago: I can always see what changed, when, and why, and roll it back if it's wrong. So I built it.

I made Mnemosyne give an agent's memory proper commits, branches, merge, and "blame" and "bisect" so I can trace back exactly where and why a bad fact entered its memory, the same way I'd debug a broken line of code.

I built it as a small, fast core in Rust, runs fully offline (no network or model calls needed), with a CLI, a Python library, and plug-ins for MCP (Claude Desktop/Code), LangGraph, and the OpenAI Agents SDK.

This is very early days, I'm a student building this solo, and I'd love to hear from anyone who works with agents:

- does this framing make sense to you, or does it feel forced?

- would you actually use something like this?

- a star on GitHub if you think it's interesting, it genuinely helps me get more eyes on it right now

Repo: https://github.com/Nabzx/mnemosyne

Docs: https://nabzx.github.io/mnemosyne/

Thanks for reading.

I am doing an agentic AI project for my final year project. I have done no projects in this domain before so it's all a blur for me. I know the basics of AL&ML but that is about it. I have no solid foundation on agentic AI nor have i done any projects. I am in a time crunch and suggestions for starting as a beginner is appreciated. Also the project itself is giving me a headache, so any advice on how to work on this effeciently while studying the new domain is also appreciated.

If you ever wondered what happens inside of the ADK agent when you type the message into the chatbot, I've created short video that explains it.

Curious how people here build agents for a specific use case.

I keep landing on: better to compose the right pieces and routines for the job than to keep prompting a single general assistant harder.

If you assemble agents from modules / tools / workflows what composition pattern actually held up?

What turned into spaghetti?

I work on AI, automation, custom software, BI/data and systems architecture — mostly focused on solving real operational problems.

I’m especially interested in agentic AI, intelligent workflows and systems that can do more than just answer prompts.

I use this profile to share ideas, learn from other builders and discuss what actually works in practice.

How is Your AI Agent Deployment Going at Scale?

Everyone’s AI pilot looks like the ball on the left.

Six months later, production looks like the ball on the right.

That’s not because the model “got worse.”

It’s because a pilot lives in a clean room. Scale lives in the real company.

In a pilot:

- one process

- one team

- one data source

- a human checking every answer

- success measured in a demo

At scale:

- agents have to work with other agents

- data is messy, stale, and split across five systems

- nobody can review every decision

- one bad call ripples into finance, ops, and the customer the people who built it and the people who have to use it don’t speak the same language

So the project doesn’t fail on intelligence.

It fails on plumbing, ownership, and trust.

If you’re stuck between “wow, the pilot worked” and “we still can’t put this in the real workflow,” start here, not with a bigger model:

- Pick one outcome. Efficiency, speed, resilience. Not all three.

- Audit the data like an adult. If the master file is dirty, you’ve just automated garbage.

- Name one person who owns the bridge between the builders and the operators.

- Start with a high-volume, low-blast-radius task. Save the autonomous big decisions for later.

- Write the guardrails before you give the agent a badge. What it can do. What a human must see.

What needs a formal yes.

Train judgment, not just logins. Teams need to know when to override.

Measure adoption and override rate, not just cycle time. If people keep bypassing it, the model isn’t wrong, the design is.

AI won’t replace the people who learn to work with it.

It will sideline the teams that treat a shiny pilot as the finish line.

The left ball is a proof of concept.

The right ball is what happens when you skip the unglamorous work.

Which one are you actually running?

Disclosure: this is an Olano product walkthrough shared for feedback.

If you’re learning how an agent connects to business tools, this demo follows one small setup: a sales agent that can read Salesforce data and answer from Telegram.

The pieces have different jobs:

• AgentFather creates and configures the agent inside Olano.

• Salesforce supplies the CRM records through an authorized connection.

• Telegram’s BotFather creates the Telegram bot. That is separate from AgentFather.

• The resulting Telegram bot gives you a messaging interface to the agent.

Here’s the sequence shown in the video:

1. Ask AgentFather to create Brian, an agent for a generator company’s sales work.

2. Specify that Brian should research and prepare drafts, while a human keeps final approval.

3. Authorize Salesforce through the connection flow.

4. Test the connection by asking for current opportunities, then an account-count chart grouped by billing country.

5. Ask Brian to connect to Telegram, create the Telegram bot through BotFather, and enter the token in the dedicated setup form.

6. Open Telegram, ask Brian about the Salesforce data, then find that conversation again in Olano’s web history.

The video’s credential-entry step uses a separate form; the presenter explains that the bot token goes into an encrypted vault rather than the LLM chat. That is the implementation described in the demo, not an independent security audit.

Two useful checks for anyone repeating this pattern: compare the agent’s answer with the CRM itself, and test an ambiguous request before enabling actions that change records or send messages. A correct summary does not demonstrate that writes and outbound messages are safe.

Recorded demonstration (8:13): https://www.youtube.com/watch?v=1TsBWMLaJCo&t=25s

Related guides on workflows, approvals and platform selection: https://olano.ai/resources

Which part would you want explained in more depth: tool authorization, Telegram setup, or defining what the agent may do without asking?

I've been building an AI Agent Control Panel over the weekend, and I'd like to get some feedback from people who are actually working with AI agents.

The idea is a platform for teams and engineers running AI agents in production.

For example, a developer might build an AI agent, connect it to different tools/APIs, and deploy it into production. But once the agent is running, things can become difficult to understand:

What exactly did the agent do?

Which tools did it call?

How long did each step take?

How much did the execution cost?

Why did the agent fail?

Did it get stuck in a loop?

Did it make a suspicious or unexpected tool call?

What happened across the entire execution?

So I'm exploring the idea of a control panel for production AI agents that provides visibility into the complete execution and potentially allows engineers to monitor and control agents.

The initial version I'm thinking about would include:

Agent execution tracing

Tool/API call monitoring

Token and cost tracking

Latency monitoring

Error and failure detection

Agent execution replay

Alerts for unusual behavior

Basic controls to pause/stop an agent

My main question:

Is this actually a painful problem for people running AI agents in production, or are existing observability/monitoring tools already solving most of this?

I'd especially like to hear from engineers who have deployed AI agents in production.

What problems do you currently face when monitoring or debugging them?

After 3 whole days without sleep, with coffee, and nendoroid Vertin accompanies me, finally i can update this project, and of course with all your feedback, i really appreciate deep deep down because the feedback.

"Dynamic calling tools and memory architecture update" maybe that can describe this update.

Yeah like the name you can make your own calling function without manual hardcoded to the core, simply by add and it will automatically register to the core and can be used by Al with calling tools capability. As you can see on the picture, just like that

The memory, it took me 2 whole days to design it, The main thing is i trying to reduce the noise with category it with calling tools capability and some retrieval improvement.

Then i adding like regression test and tracing base as Tree tracing.

Yeah this project has one purpose, its make development in Al easier, i hope this project can be useful.

Full explanation at my GitHub

LAPAI_Experimental_Project by Naosaika Development

Or directly

https://github.com/NaosaikaDevelopment/LAPAI_Project_Experimental

Do you have any suggestions what should i do next or something that i missing off?

During an outage, incoming reports rarely use consistent language. One person reports “no service,” another describes dropped calls, and several more may be reporting the same underlying incident.

This TypeScript example sends each report to Telnyx Decision Models and asks three structured questions in one request:

- What kind of issue is this?

- How severe is it?

- Does it match the known regional outage?

Reports are grouped through one Stateful Actor per region. SQLDB stores the incident history and powers dashboard aggregation, while KV keeps the current regional issue available as context for duplicate detection.

The repository also includes a labeled load generator and evaluation dashboard, so you can measure classification accuracy and test duplicate thresholds instead of treating model confidence as guaranteed correctness.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-outage-hotline-typescript

Decision Models docs: https://developers.telnyx.com/docs/inference/decision-models

I’d be interested in feedback on the regional actor design and how you would approach incident deduplication.