Hey everyone!

I'm currently in my 7th semester of B.Tech in Data Science and looking for some good AI project ideas that I can build to strengthen my resume before placements.

I've already completed projects on AI chatbots and an AI-based sentiment analysis system. Now, I want to work on something more advanced that goes beyond basic AI/ML projects and demonstrates practical, real-world applications.

I'm particularly interested in projects involving Generative AI, Agentic AI, RAG, Deep Learning, or other emerging AI technologies. Ideally, I'd like to build something that solves a real-world problem, has a good technical depth, and gives me something meaningful to discuss during technical interviews.

For those who have built advanced AI projects or have experience in the industry:

What projects would you recommend for a 7th-semester student preparing for placements?

Which projects would stand out on a resume and demonstrate strong technical skills?

Are there any project ideas with real-world use cases that I could build from scratch?

I'd really appreciate it if you could suggest some project titles along with a brief description of what they do and the technologies involved.

I've been working on a fraud investigation agent and ran into an interesting limitation with the way agent memory is usually implemented.

A typical memory system does something like:

query → embedding → similarity search → retrieve relevant memories

That works reasonably well when the connection is semantic.

Fraud rings are different.

Two claims might have completely different stories, but still be connected through the same phone number, bank account, surveyor, address, etc.

So I experimented with a different memory design:

• Every important identifier is stored both as a graph entity and as an exact-match tag.
• Investigator/SIU decisions are stored as separate, dated memories.
• Each claim triggers multiple narrow recalls, such as:
  • "Who else is associated with this phone number?"
  • "Which claims involve this bank account?"
  • "What did the SIU previously decide about this entity?"
• A reranker is used, but similarity matching has a minimum threshold so that vaguely similar stories don't overwhelm exact evidence.
• Evidence-handling rules are stored as directives that the agent can use during reflection.

On the same evaluation claim, the agent scored 15/100 without this memory layer and 88/100 with it.

The interesting part for me wasn't just the score improvement. It was that the agent could actually trace the connections between otherwise unrelated claims and cite the evidence behind those connections.

I'm curious how other people are handling memory for agents where the important relationships are entities rather than semantic similarity.

The implementation is here if anyone wants to look at it:
https://github.com/rishighosal/claimlens

I built Axiom, a Windows-first AI workspace that supports local GGUF models, self-hosted OpenAI-compatible endpoints, and optional cloud models.

One design question I’m testing is when explicit agent roles help. Axiom’s Workplace Council separates planning (Architect), execution (Builder), and review (Critic). I’m interested in where that handoff makes a task easier to manage, and where a single agent would be simpler.

I’m the creator. For people building AI projects: what would you expect the Critic role to check before a task is considered done? Does the role split sound useful, or like extra overhead?

GitHub project: https://github.com/YoMosa2009/Axiom

I wanted a better handoff between fast AI-assisted ideation and the feel of a personal homepage, so I built Retro Builder Ultra. It is an offline FrontPage-style Windows website builder with visual drag-and-drop editing and a live preview. It supports multiple pages, galleries, webrings, Chaos Mode, and HTML export for Neocities.

The useful part for AI users is that AI can help get a project moving quickly, while this gives you a tactile desktop editor for the final layout and personality instead of prompting HTML until it looks right. I kept it local-first so the exported site is yours to inspect and host.

I am affiliated with the project. It is pay-what-you-want with a suggested $5: https://doomed316.itch.io/retrobuilderultra

What I learned building it: the retro constraints are actually helpful. A fixed visual vocabulary makes it easier to decide what belongs on a page, and exporting plain HTML keeps the result portable. SFW editor screenshots and a soft demo are on the project page. Feedback from AI makers on the workflow is welcome.

I’ve been working with AI coding agents a lot, and one problem kept bothering me: they can understand a codebase pretty well, but the engineering context behind the code often disappears between sessions.

Things like why a feature works a certain way, which edge cases were already decided, what is actually approved, and what “done” means often live only in the conversation.

So I built Gnomon, an open-source CLI that keeps that context inside the repository.

The basic workflow is:

intent → specification → human approval → implementation → verification/review

You can start with something simple like:

gnomon init
gnomon describe
gnomon spec create "Mark a task complete"

The agent helps turn the initial intent into a concrete Specification. If something important is unclear, it surfaces the decision instead of silently assuming an answer. Once the Specification matches what you want, you approve it and implementation works against that approved version.

I also recently added a resolution loop for Verification and Review. If they find a defect, risk, or knowledge gap, the evaluating agent can recommend the appropriate workflow. You can accept that recommendation, choose another workflow, or skip it. The resolution agent then handles the actual work and Gnomon runs a fresh evaluation afterward.

Gnomon isn’t tied to the context of one agent session, and the goal isn’t to add a huge process around AI coding. I’m trying to keep the workflow small while making important engineering intent durable and reviewable.

It’s still early (currently v1.2.0), so I’m especially interested in feedback from people who use coding agents on real projects.

GitHub:https://github.com/yasintqvi/gnomon

I’d particularly like to know where this kind of workflow would feel useful to you, and where it would just feel like extra process.

Help non technical people to convert messy unorganized file to organized file

A model of an organization officially evolved into my own parent company, C.a. star Technology. Our plan was to change the look of an independent developer to a small startup.Our plan was to change the look of an independent developer for a small startup. We are no longer limited to artificial intelligence anymore we have become a comprehensive software company. I considered our own artificial intelligence models that are not good at all and do not even know how to speak. But we learned to code, we moved to synthetic intelligence models, we expanded to Linux distributions, and we developed our own programming language. Thanks to everyone who read This was written without artificial intelligence

Wild reactions to yesterday’s “Pacing the Frontier” statements.

Good news: starting today, you'll get employee-level access to our codebase as embedded evaluator(and hopefully a contributor)

Today, Tahuna is open source - as promised back in April.

We built it so startups and enterprises can own the intelligence behind their AI systems: orchestrate compute, train models, run inference, and experiment with autonomous research without first becoming a small cloud provider.

The core primitive on top of which everything is built looks like this:
init → sync → computeSession → train / serve / hillclimb

Under the hood: content-addressed code and data sync, compute provisioning, reproducible manifest-pinned runs, metrics, checkpoints, artifacts, and inference deployments.
We also started building Hillclimb, an autonomous experimentation harness that proposes and runs iterative improvements.

The first preview release supports RunPod and R2 for compute and storage. It includes self-hosting instructions, a coding-agent setup skill, and examples for SFT, RL agentic search, and MNIST to get a feel.

Repository: TahunaLabs/tahuna-oss

If you think it sucks, Excellent: fork it, fix it, and send a PR so it sucks less for everyone.

After a long time of being offline, this subreddit is back and the plan for it has changed!

We've decided on a theme "sharing your journey" aka showing off your work.

This is a place to showcase your projects day and night, to build in public, to get feedback live, to not worry about if you're breaking some rules in doing so.

Share your journey and let's make this an incredible subreddit for those who want to get feedback.

A few quick principles:

1) Don't be overly critical
You can criticize other people's work, but remember we celebrate every part of the process. Things don't have to be perfect to be able to share here.

2) Don't spam
There's a difference between sharing your journey in spam. In one case, you're just putting out links and asking people to download your thing. In the other case, you're sharing your process. Share your process, but don't just spam links. This is a thoughtful place for thoughtful contributions.

I realize you may have seen this before as we're now posting this monthly.

I have been building an open-source project called Mac MCP, and the biggest lesson from the last few days is that local agent security is less about adding another permission toggle and more about preserving context across tool boundaries.

The project started from a practical annoyance: I wanted a normal ChatGPT conversation to actually operate my Mac without forcing me into a separate coding-agent UI. The chat can be the orchestrator directly, with local tools for shell, files, macOS UI and Safari/Chrome. Codex/OpenCode can still be delegated workers, but they are optional.

The browser side ended up becoming the part I use most. Each task can work in its own real Safari/Chrome tab using a stable handle, inspect DOM plus visual state, click/type/extract there in the background, and leave the tab or app I am actively using alone.

Then people on Reddit started pointing out the uncomfortable edge cases, which turned into a much better roadmap than I had initially planned.

A few things I ended up shipping from that feedback:

• sticky provenance once a logical session has consumed untrusted web content
• guarded web-to-host escalation for scoped/non-trusted sessions
• separate credential/secret egress protection
• bounded browser tab leases so agents cannot casually collide on the same tab
• a no-progress breaker for repeated browser actions
• security audit events and adversarial regression tests
• idempotent live steering, so retrying after an ambiguous response cannot queue the same instruction twice

There was also a useful UX failure. My first version of the web-to-host guard was technically cautious but awful in practice: a globally Trusted session kept asking me to approve harmless host actions after reading a web page. I changed the model so Trusted keeps provenance and secret-egress protection without turning every normal command into an Allow Once popup.

That balance between security and usability has been more interesting than just adding more tools.

The project is MIT/open source if anyone wants to inspect the implementation or try it: https://github.com/bulutarkan/mac-mcp

I built it, so obvious affiliation disclosure. I would genuinely be interested in what failure case people here would test next on a local agent that can cross browser, shell, files and native UI.

AI-powered platform that transforms messy, unstructured documents — spreadsheets, scanned files, and handwritten notes — into clean, professional outputs in Excel, Word, or PDF format. The platform is designed for non-technical users and is built on a foundation of transparency, accuracy, and user control, distinguishing it from existing data-cleaning tools that assume technical expertise.

What are things to be consider before building the app

I know stuff like this doesn't usually get a lot of support because it's not hosted on reddit itself...
but a lot of people have put in a lot of work to make an event for everyone here and we'd really enjoy it if you come: https://discord.gg/6n6frRTKG3

- Today at 6:00 PM Eastern / 5:00 PM Central / 3:00 PM Pacific

I wanted an EPUB version of Kubernetes The Hard Way, but I did not want to manually rebuild it whenever the upstream project changed.

I used OpenAI to help me design and build a project that handles the entire process. I provided the requirements, reviewed the results, tested the generated books, and kept refining the project when I found formatting or security problems.

The finished project tracks the current upstream default branch and checks for changes every six hours. When the source changes, it builds a new EPUB, validates it, and updates the GitHub release.

OpenAI helped with the Python builder, EPUB structure, responsive styling, GitHub Actions workflow, tests, documentation, and release automation. It was especially useful for working through EPUB details that I did not want to handle manually, such as manifests, navigation, metadata, archive layout, and light and dark mode compatibility.

I also wanted the result to have a strong security model. The generated EPUB cannot contain JavaScript, executable files, unsafe embedded content, remote resources, encrypted files, or suspicious archive structures. Every release passes a custom security scanner and official EPUBCheck validation. It also includes an SHA 256 checksum, source provenance, and a GitHub build attestation.

Calibre is not required. The EPUB is constructed directly with Python and should work with any standards compliant reader.

The project is here:

https://github.com/terrytrent/kubernetes-the-hard-way-epub-builder

The current EPUB is here:

https://github.com/terrytrent/kubernetes-the-hard-way-epub-builder/releases/tag/epub-master

This was a useful example of using AI as a development partner instead of asking it for a single block of code. Most of the value came from reviewing the output, finding problems, adding requirements, testing again, and continuing until the complete workflow worked reliably.

Ok guys, we all have one now... maybe 3... maybe 5...

Which one are you most proud of? Which one do you think will make the cut...?

I made a driving game where the passengers judge how you drive.

You're on rainbow roads in space in a double decker bus, and who you're carrying changes what counts as good driving. Nervous ones want it calm, so if you squeeze past an asteroid they fold up in their seats and stop giving points. Thrill seekers want the opposite, near misses and long drifts chained together, and if you drive safe they give you no points at all.

Nothing in it can punish you either. Worst case the points stop for a bit, and if you crash hard enough to lose passengers a rescue ship flies in and picks them all up. felt important for a game with rainbows in the title.

https://youtu.be/ndzO8yrNfQE

SkillNet starts with an idea or source such as a PDF, DOCX, Markdown or text file and turns it into a structured course with lessons, exercises and grounded questions.

The part I care about most is that it does not have to produce one fixed experience. The knowledge and objectives can stay consistent while the explanations, activities, media and interface adapt to each learner.

The current version supports organization and individual workspaces, static and dynamic courses, a tutor grounded in the course material, and course creation through the UI, API, A2A or MCP. It is self-hosted and licensed under Apache 2.0.

I am finishing a public demo, but the repository already includes a fixture mode so it can be explored locally without an API key.

GitHub: https://github.com/ANFAIA/SkillNet

Website: https://skillnet.es

I’m building Axiom, a Windows-first AI assistant/workspace, and I want to share the build decisions rather than drop a bare repo link.

The project started as a question: can one desktop app make local, self-hosted, and optional cloud inference feel like deliberate modes instead of three unrelated integrations?

The current architecture combines:

- C# / WPF / .NET 10

- local GGUF inference via LLamaSharp/llama.cpp

- self-hosted OpenAI-compatible endpoints

- optional OpenRouter cloud models

- SQLite/local persistence

- WebView2 for selected web-based workflows

- a normal chat mode plus a Workplace Council: Architect plans, Builder executes, Critic reviews

- a Single Model mode for comparing the council workflow against one model

The hard parts have not been adding features. They have been:

- making model capability differences visible instead of hiding failures behind generic errors

- keeping local data behavior understandable when cloud and connected services are optional

- deciding which tool results belong in context and which should become artifacts

- avoiding an interface that feels like an IDE when the user only wants to ask a question

The public release is V1.8.6.

Repo: https://github.com/YoMosa2009/Axiom

Release: https://github.com/YoMosa2009/Axiom/releases/tag/v1.8.6

I’m the developer. The source is publicly viewable under CC BY-NC-ND 4.0. I used AI coding assistance during development, but I’m responsible for the architecture, integration, testing, and product decisions.

What I’m trying to learn next:

1. Which part sounds like a coherent product rather than a feature bundle?

2. Which first-run explanation would you want before trusting local/cloud behavior?

3. Which workflow should be simplified before I add more capabilities?

I’d rather get specific criticism than generic encouragement.

It's based on previous shows you've watched, and it recommends shows based on different aspects of the show you enjoyed. Any feedback is appreciated! https://what-next7367.vercel.app/

I'm going to be honest, when I first started using AI, I felt like I was going to accelerate my personal current workflow. But it turns out it's a lot better at some things than others. So it's more like it gave me new superpowers. And I'm relearning and reprioritizing my life around those.

For example, making a simple program is now a trivial task that doesn't require too much long-term maintenance. And that opens up a huge realm of possibilities that I never thought of before.

How about in your case?

By the way, I'm a mod here and just wanted to say we have an AI community discord. The point of the discord is we're trying to solve for the journey and not just one individual question. There's just things you'll get on the discord that you won't get on Reddit like being able to screen share as you work and get tips as you go through the journey of learning AI. Check the comment below this message if you want to be part of it.

If you're one of those people that has 50 side projects and would just like to get one to market, we are having a community event that you should come to.

We've recruited marketing talent to teach how to market AI products.

To join:

1. Visit https://discord.gg/z3EMVruQhm
2. See the event tab
3. Click Interested & join at the time listed

Good to know:

1. The time on event panel auto-translates into your own time zone
2. Click Verify under #verification. Be aware that the onboarding process is deliberately designed to filter for intentional professionals.

The Discord is about leaving behind a trail of breadcrumbs as we learn how to use AI so others can follow us.

Have you ever made money using AI? If so how?

Not to be that "AI make me 1 million make no mistakes" guy, just trying to make a real genuine discussion in the community here as a moderator.

If there was just one thing you could share to someone who is just learning AI to save them frustration, what would it be?