DEV Community: Yashika Kumari Vishwakarma

# 👻 The Code Remembers. Now You Can Ask Who Wrote It. 💻✨

Yashika Kumari Vishwakarma — Fri, 30 Oct 2026 20:14:32 +0000

What if you could have a conversation with the developer who wrote a piece of code five years ago — even if they've long since left the project?

Every codebase has ghosts. 👻

Not the scary kind.

I'm talking about developers who once spent nights fixing bugs, designing systems, writing clever workarounds, and leaving behind thousands of lines of code.

Eventually, they move on. 🚶‍♂️

Their commits remain. Their reasoning gets buried. And someone new inherits a codebase full of decisions nobody remembers making.

Then I started thinking...

💡 What if we could ask those developers about their work?

That question became LastWords.

Welcome to my submission for Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine! 🎃
(https://dev.to/challenges/hacktoberfest-week4-2026-10-26)*

🚀 What I Built

👻 LastWords

Talk to the contributors who built your codebase.

LastWords is a local-first AI tool that brings a codebase's contributor history into a conversation.

It identifies inactive contributors, retrieves their real Git commits, and uses an open-weight AI model to generate evidence-grounded answers in their first-person voice.

It has three main capabilities:

🔮 1. Summon the Contributors

Point LastWords at a Git repository.

It analyzes the commit history, identifies inactive contributors, and calculates how many source-code lines they still maintain.

💬 2. Ask the Ghosts

Ever wondered why a developer implemented something in a particular way?

Now you can ask!

For example:

"Why was this function implemented this way?"

LastWords uses Git blame to identify the contributor responsible for the line, retrieves relevant commits, and asks Gemma to generate an answer based on that evidence.

Every response can include commit-hash references, allowing you to trace the answer back to the actual project history.

🕯️ 3. Build an Ofrenda

LastWords generates a Día de los Muertos-inspired tribute website for contributors.

It displays their names, actual commit messages, and surviving source-line counts.

It's a digital tribute to the people whose work continues to live inside open-source software. 🌼

One important clarification: a "ghost" simply means a contributor who has not committed in a long time. It never implies that the person has passed away.

🎬 Demo Time!

🌐 Live Website (Vercel): https://lastwords-chi.vercel.app/

💻 GitHub Repository:

https://github.com/Vishwakarma-Yashika/lastwords

The live website showcases the generated contributor ofrenda.

The interactive AI conversation runs locally through Python and Ollama.

⚡ Try It Yourself

# 🔮 Summon contributors
python -m lastwords.cli summon ./path/to/repository

# 💬 Ask a contributor about a particular line
python -m lastwords.cli ask ./path/to/repository \
  "Why was this implementation chosen?" \
  --file app.py --line 120

# 🕯️ Generate the ofrenda website
python -m lastwords.cli ofrenda ./path/to/repository \
  --top 6 --out site

🛠️ How I Built It

I wanted the AI to do more than imitate a developer's personality.

It needed to have actual evidence from the repository.

🧰 Technology Stack

Technology	Purpose
🐍 Python	Core application and CLI
🔗 GitPython	Git history and blame analysis
🧠 Gemma 2B (`gemma2:2b`)	Open-weight AI model
🦙 Ollama	Local model inference
🎨 Jinja2	HTML template generation
📊 Sentry	Optional tracing and observability
▲ Vercel	Public static website hosting

🧠 How the AI Works

When someone asks about a particular line of code, LastWords:

🔍 Uses Git blame to identify the contributor responsible for that line.
📜 Retrieves the commit that introduced the line.
🧩 Searches the contributor's history for additional relevant commits.
📝 Constructs a context-grounded prompt from the retrieved evidence.
🧠 Sends that context to Gemma running locally through Ollama.
✅ Validates commit citations against the retrieved commit history.

The most important design decision:

Git history is the source of evidence. Gemma is the conversational layer.

If the available history doesn't contain an answer, LastWords can acknowledge that it doesn't remember rather than inventing a technical explanation.

🌼 The Ofrenda

The ofrenda is deterministic by default.

Its contributor notes come from real commit messages, not fabricated AI biographies. This means the tribute website can be generated without requiring an AI model.

🧪 Testing and Reliability

I didn't want this to remain just a concept or a pretty interface.

The project includes automated tests covering:

Git history and contributor analysis
Commit retrieval and citation validation
Unicode contributor names
Error handling
Tracing and privacy safeguards
HTML escaping
Reproducible website generation

🎯 Final test result: 68 tests passed!

🌍 Why Does Open Innovation Matter?

For LastWords, open innovation is not just about choosing an open model. It directly shapes the architecture.

A Git repository can contain private source code, internal implementation details, and sensitive development history.

I wanted developers to explore that history without sending repository context to a hosted AI inference API.

That's why LastWords uses Gemma through Ollama.

🖥️ The model runs locally, and the repository context used for inference stays on the developer's machine.

Open-weight AI makes this possible:

🔐 Privacy: Repository context is not sent to a hosted AI inference API.
🎛️ Control: Developers can choose and run their own local model.
💸 Accessibility: The core workflow does not require a paid AI API subscription.
🔄 Flexibility: Developers can experiment with different models.
🌱 Independence: The application isn't dependent on a single closed AI provider.

Open innovation gave me the freedom to build something privacy-conscious, customizable, and accessible.

🤖 My Agent Session

I used Claude Code as my development assistant throughout the project.

My workflow included:

🔍 Architecture auditing
🏗️ Incremental implementation
🧪 Automated testing
🛡️ Security and privacy reviews
📦 Release preparation

The important part wasn't simply generating code. It was repeatedly reviewing the implementation, testing edge cases, improving retrieval quality, and ensuring AI-generated responses remained grounded in actual commits.

🕯️ The Spirit of It

There is something strangely beautiful about an old Git repository.

You might find a commit from 2015 that fixed a tiny bug. A refactor that nobody remembers. A developer who spent hours solving a problem that would otherwise have disappeared into history.

Years later, another developer opens that file and wonders:

"Why did they do it this way?"

The code cannot answer everything.

But it can preserve traces of the person who wrote it.

I built LastWords because I believe open-source software is more than code.

It is a collection of human decisions, experiments, mistakes, ideas, and contributions.

The developers may move on.

Their code remains.

And now, you can ask it a question. 👻❤️

🏆 Prize Category

🧠 Best Use of Gemma

Gemma 2B powers LastWords' evidence-grounded contributor conversations through local Ollama inference.

✨ Built with curiosity, open-source technology, and a little bit of ghostly inspiration.

Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine

hf26challenge #hacktoberfest #opensource #AI #Gemma #Ollama #Python #DevChallenge #OpenSourceAI

LazyLoop AI: Let Open-Weight AI Handle Your Digital Chores

Yashika Kumari Vishwakarma — Mon, 26 Oct 2026 06:44:05 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Meet LazyLoop AI — a local-first AI assistant that helps reduce repetitive digital chores.

We all have documents with unclear filenames, notes we never review, and follow-up tasks we keep forgetting. LazyLoop AI aims to make document management easier by using local AI to analyze files and suggest useful actions.

Upload a PDF or TXT file, and LazyLoop AI can:

Suggest a meaningful filename.
Recommend a category for the document.
Generate a short summary.
Extract potential follow-up tasks.

Instead of manually reviewing every document, users get these suggestions in one place.

The idea is simple: less digital busywork, more breathing room.

Demo

Demo status: Currently running locally during development.

A public deployment or demo video is not available yet.

I'll add a demonstration link when one is ready.

Code

GitHub Repository: https://github.com/Vishwakarma-Yashika/lazyloop-ai

The project includes a Next.js frontend and a Python FastAPI backend connected to Ollama for local AI inference.

How I Built It

I built LazyLoop AI using:

Next.js and React for the frontend.
Tailwind CSS for the user interface.
Python and FastAPI for the backend.
Ollama to run an AI model locally.
Phi-3 as the initial model for document analysis.
PyPDF to extract text from PDF files.

The workflow is straightforward:

The user uploads a PDF or TXT file.
The backend extracts the document text.
The text is sent to the locally running Ollama model.
The model generates structured suggestions, including a category, filename, summary, and possible action items.
The frontend displays the results for review.

The current implementation generates recommendations rather than automatically moving or renaming original files.

Why Does Open Innovation Matter?

I wanted to explore how open-weight AI could make everyday automation more private and accessible.

By running an open-weight model through Ollama, LazyLoop AI can process document contents locally rather than sending them to a hosted AI API.

Open innovation gives developers more control over the technology they use. I can experiment with different models, adjust prompts, inspect outputs, and adapt the application without depending entirely on a proprietary AI service.

Some key benefits include:

Privacy: Document contents can stay on the local machine during inference.
Flexibility: I can switch between compatible local models.
Cost control: Local inference avoids per-request fees from a hosted AI API, although hardware and electricity still have costs.
Offline potential: Once the model and dependencies are installed, the application can perform inference without an internet connection, provided the local environment is configured correctly.

For me, open innovation is about more than using an open-weight model. It is about having greater control over how AI works and where personal data is processed.

My Agent Session

I haven't published a DevRelay agent session yet.

I'll add a session link here if I record and share one.

The Lazy Payoff

Imagine opening document after document just to figure out what each contains, where it belongs, and whether it requires any follow-up.

LazyLoop AI brings those suggestions together in one workflow.

I haven't measured actual time savings yet, so I won't claim a specific percentage. My next step is to test it on a collection of documents and compare the time required for manual review with AI-assisted review.

The goal is to turn a tedious digital chore into a simple review process.

Prize Categories

I'll update this section according to the eligible partner categories and the official challenge rules.

Built with open-weight AI, local inference, and a little less busywork.

Sometimes the smartest productivity hack is making yourself do less repetitive work.

BillBuddy AI: A Privacy-First AI Invoice Assistant for Freelancers and Small Businesses

Yashika Kumari Vishwakarma — Sat, 17 Oct 2026 09:05:04 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

BillBuddy AI is a privacy-first, AI-powered invoice and receipt assistant designed for freelancers, independent professionals, consultants, and small business owners who want to simplify their financial record-keeping without sending sensitive financial documents to third-party AI APIs.

Managing invoices manually can become surprisingly time-consuming. Freelancers often receive invoices and receipts in different formats, manually enter details into spreadsheets, categorize expenses, search for duplicates, and organize records for accounting or tax preparation.

BillBuddy AI aims to make that workflow easier.

Users can upload an invoice or receipt, extract important information using a locally running open-weight AI model, review and correct the extracted details, and organize their financial records in one place.

The key features

AI-powered invoice extraction: Extract vendor names, invoice numbers, dates, currency, subtotal, tax, and total amounts from invoice text.
Local AI inference: Run open-weight language models through Ollama on the user's own machine.
Human-in-the-loop verification: Review and edit extracted information before saving it as a verified record.
Privacy-first processing: Keep sensitive documents and AI inference local in the local application workflow.
Invoice organization: Build a searchable record of invoices and expenses, with categories and status tracking.
Duplicate detection: Identify potentially repeated invoices to help prevent duplicate records.
Exportable records: Support CSV exports for spreadsheets and accounting workflows.
A practical, accessible dashboard: Bring important financial records and their statuses into one interface.

The broader goal is to turn invoice management from a repetitive administrative task into a straightforward workflow.

Who would pay for it?

BillBuddy AI is designed for people who want to spend less time on paperwork:

Freelancers managing invoices from multiple clients.
Consultants and independent professionals tracking business expenses.
Small businesses without dedicated accounting staff.
Solo founders managing operational finances.
Privacy-conscious users who prefer local AI over cloud-based document processing.

The potential business model is a free local-first version, with optional paid features such as advanced reporting, bulk processing, team workflows, and accounting integrations.

The aim is not to replace an accountant or make financial decisions automatically. It is to reduce manual data entry while keeping users in control of their records.

Code

Source code: BillBuddy AI on GitHub

The repository contains the Next.js application and the API integration for working with local Ollama inference.

Technology stack

Frontend: Next.js App Router, React, JavaScript, Tailwind CSS
AI inference: Ollama
Open-weight models: Phi-3 and Mistral
Validation: Zod
Planned storage: SQLite for persistent local records
Planned document processing: PDF text extraction and OCR for scanned invoices and receipt images

The GitHub link above is a placeholder for the project repository. Replace it with the actual BillBuddy AI repository URL before publishing.

How I Built It

I wanted to build something practical with open-weight AI—not just another chatbot interface.

I started with a Next.js application and built the initial dashboard UI. Then I integrated a local Ollama setup and verified that the application could detect the running Ollama service and available models.

The initial model options include phi3:latest and mistral:latest.

The AI workflow

The intended end-to-end workflow is:

Input: The user uploads an invoice or receipt, or provides its extracted text.
Preprocessing: The application extracts text from the document. OCR is planned as a fallback for scanned documents and images.
Local inference: The backend sends the text to Ollama, which runs the selected open-weight model locally.
Structured extraction: The model returns the requested invoice fields in JSON format.
Validation: Zod validates the returned data so malformed or unexpected output is not accepted blindly.
Human review: The user checks and corrects the extracted values.
Persistence: The verified record is saved to local storage/database.
Organization: Users can review their records, identify potential duplicates, and export data.

A crucial design decision is that AI-extracted financial information must not automatically be treated as verified truth. Models can misread amounts, dates, tax values, or vendor names. The user remains responsible for reviewing the information before it is marked as verified.

Why use local inference?

Invoices and receipts can contain names, addresses, transaction details, tax identifiers, and other sensitive business information.

Instead of depending on a paid external model API for every extraction, BillBuddy AI uses Ollama to run an open-weight model on the user's own machine.

This approach also makes experimentation more accessible. I can switch between supported local models, test different prompts, and iterate without building the entire product around a proprietary inference API.

The application uses a backend route to communicate with Ollama, rather than calling the model directly from the browser.

The project is being developed incrementally, with the initial dashboard and health check completed and the extraction, persistence, document processing, and export workflows being built and tested in stages.

Why Does Open Innovation Matter?

Open innovation is central to BillBuddy AI because the project is built around the idea that useful AI tools should not require every user to depend on a closed API.

Open-weight models and tools such as Ollama make it possible to experiment with AI locally, inspect and modify the surrounding application logic, and build a workflow around a user's privacy and resource constraints.

For this project, open innovation makes several things possible:

1. More control over sensitive data

A local-first architecture can keep document processing on the user's machine rather than requiring every invoice to be sent to an external AI provider. Privacy still depends on the complete implementation, including document storage, logs, backups, and any external integrations.

2. Freedom to experiment

I can compare models such as Phi-3 and Mistral, adjust extraction prompts, validate outputs, and test failure cases without tying the product to a single proprietary model provider.

3. Lower barriers to building

Open-source frameworks and local inference tools allow an individual developer to prototype and improve an AI-powered product without needing to purchase a separate API service for every experiment.

4. Greater transparency and user control

Users should be able to understand where their documents are processed, where their data is stored, and how AI-generated information becomes a saved record.

5. A foundation others can improve

The project can grow through community contributions—better document parsing, additional models, improved validation, accessibility improvements, testing, and integrations.

Open innovation does not automatically make a product secure, accurate, or free to operate. It provides the flexibility to design those qualities deliberately.

What's Next?

The next milestones for BillBuddy AI are:

Complete invoice and receipt upload.
Add PDF text extraction and OCR fallback.
Connect the extraction endpoint to the user interface.
Add editable review and verification.
Persist records in SQLite.
Implement duplicate detection and CSV export.
Add tests for invalid model responses, missing fields, and incorrect extraction.
Document setup instructions and collect feedback from an initial user.

The long-term vision is simple: make AI-powered financial organization more accessible, more transparent, and more private.

Building with open-weight AI has made it possible to explore that idea without starting with a proprietary API or a cloud-first architecture.

I'm excited to keep improving BillBuddy AI and learn from the Hacktoberfest community.

🌿 TrailMate AI: Explore More, Scroll Less

Yashika Kumari Vishwakarma — Sat, 10 Oct 2026 18:15:52 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

What if AI could help us spend less time staring at screens and more time exploring the world outside?

That's the idea behind TrailMate AI — an AI-powered outdoor adventure companion that turns outdoor activities into quests, rewards progress, and encourages people to reconnect with nature. 🌎

🌱 What I Built

TrailMate AI is designed for students, explorers, nature lovers, and anyone who wants to build healthier habits by spending more time outdoors.

Instead of making technology another reason to stay online, I wanted to explore how AI could encourage real-world experiences.

✨ Key Features

🥾 Outdoor Quests: Turn outdoor activities into engaging challenges.
⭐ XP and Progress Tracking: Earn experience points as you complete quests.
🏆 Badges and Achievements: Celebrate milestones and stay motivated.
📓 Adventure Journal: Record experiences and reflections from your adventures.
🤖 AI Trail Guide: Get AI-generated guidance to support your outdoor journey.
💾 Progress Persistence: Keep track of quest progress and journal entries between visits.

The goal is simple: make going outside feel rewarding, engaging, and fun!

🚀 Demo

Live Demo: https://trail-mate-ai-three.vercel.app

The project is currently available as source code on GitHub.

💻 Code

GitHub Repository: TrailMate AI

Feel free to explore the code, learn from the implementation, and share suggestions or improvements.

🛠️ How I Built It

I built TrailMate AI using modern web technologies and an open-weight AI model.

Tech stack:

Next.js — Application structure and API routes.
JavaScript and React — Interactive components and application state.
Tailwind CSS — Responsive styling and UI design.
Ollama + Phi-3 — Local language-model inference for the AI trail guide.
Browser localStorage — Persistence for quest progress and journal entries.

Ollama allows the Phi-3 model to run locally, making it possible to experiment with AI-powered features without relying entirely on a proprietary hosted AI API.

The application combines an interactive web experience with AI guidance and gamification. Quests, XP, achievements, and journaling are intended to make outdoor exploration feel like a continuing adventure rather than a one-time activity.

🧠 Why Does Open Innovation Matter?

Open innovation makes AI experimentation more accessible to developers.

Using an open-weight model through Ollama gives developers an opportunity to experiment with local inference, understand how language models integrate into applications, and build experiences with greater control over their development environment.

For TrailMate AI, this approach helped me explore an important question:

Can we use AI not just to keep people engaged with technology, but to encourage them to engage with the real world?

Open-source tools and publicly shared code also create opportunities for other developers to learn, contribute, and build on existing ideas.

I believe technology should help us live better — not simply spend more time online.

🏆 Prize Categories

This project is submitted to the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

Partner prize categories: None claimed at this time.

🌍 What's Next?

I'd love to keep improving TrailMate AI by making outdoor quests more engaging, refining the AI guide, and exploring more ways to encourage people to step away from their screens.

This is an opportunity to experiment with AI in a different way: using technology as a bridge to the outdoors.

💬 Your Turn!

If you could create one outdoor quest for yourself, what would it be?

A morning walk? A hike? Exploring a nearby park? Or simply watching the sunset without checking your phone?

Share your idea in the comments. Let's inspire each other to touch grass! 🌿

Build with AI. Explore the real world. Scroll less.

My Friend Needed a Second Opinion. I Built Six.

Yashika Kumari Vishwakarma — Mon, 05 Oct 2026 06:52:39 +0000

Hacktober 2026 : Build for a friend.

Meet RoundTable AI — a voice-first multi-agent room where AI perspectives debate your decisions instead of simply giving you an answer.

What I Built
When a friend has an important decision to make, sometimes they don't need another person to simply tell them what to do. They need different perspectives.

That's why I built RoundTable AI—a voice-first, multi-agent decision-making platform where different AI perspectives come together in a virtual meeting room and debate a decision.

The idea is simple:

Don't ask AI for an answer. Build a room that argues about it.

The user provides a decision or problem, and RoundTable creates relevant AI participants with different roles, goals, expertise, and opinions.

For example, the room can include an Investor, Engineer, Customer, Competitor, Devil's Advocate, and Moderator.

The agents don't simply give separate answers. They challenge each other's arguments, question assumptions, and work toward a structured Room Verdict.

The user also stays part of the conversation and can interrupt, challenge the room, ask questions, or add another perspective.

I built RoundTable AI for a friend who often has to make important decisions and could benefit from having multiple viewpoints available before making a choice.

Code
The project is open source:

GitHub: RoundTable AI on GitHub

How I Built It
RoundTable AI is built around three main parts.

🧠 Gemma — The AI Reasoning Layer
The reasoning layer uses Gemma, an open-weight AI model, to power the agents, their perspectives, arguments, challenges, and final synthesis.

The architecture is designed to be model-agnostic, allowing us to experiment with different open models and local inference.

🎙️ ElevenLabs
I use ElevenLabs for the voice layer.

Each AI participant can have a distinct voice, making the experience feel more like an actual meeting instead of a normal chatbot conversation.

⚡ Real-Time Application
The application is built with:

Next.js
React
TypeScript
Tailwind CSS
Node.js
Fastify
Socket.IO
The backend manages the meeting room, participants, conversation, turns, challenges, and final verdict.

An Argument Ledger keeps track of important claims and disagreements so the agents can respond to what is actually being discussed.

Why Does Open Innovation Matter?
Open-weight AI isn't just a checkbox for this project.

RoundTable is designed around experimenting with how different AI agents reason, challenge each other, and reach a decision.

Using open-weight AI gives us the freedom to:

Swap models
Experiment with different models for different roles
Modify agent behavior
Explore local inference
Reduce dependency on a single AI provider
Potentially keep sensitive decisions local
The reasoning model can evolve without rebuilding the entire application.

That's important because RoundTable is not about one particular AI model. It's about creating a system where different AI perspectives can interact.

Open-weight AI provides the reasoning.

RoundTable provides the room.

ElevenLabs provides the voice.

My Agent Session
I used DevRelay during development to help with architecture, implementation planning, code generation, and reviewing the multi-agent system.

Prize Categories
🎙️ ElevenLabs — For giving each AI participant a distinct voice and creating a voice-first meeting experience.
🧠 Gemma — For powering the open-weight AI reasoning and multi-agent debate.
Final Thoughts
We already have AI assistants that answer questions.

I wanted to build something different.

Instead of giving you one AI answer, RoundTable gives you a room full of perspectives.

Sometimes the best AI isn't the one that agrees with you.

It's the one that makes you think twice.

RoundTable AI — Don't ask AI for an answer. Build a room that argues about it.

My Friend Needed a Second Opinion. I Built Six.

Yashika Kumari Vishwakarma — Mon, 05 Oct 2026 06:50:07 +0000

Hacktober 2026 : Build for a friend

Meet RoundTable AI — a voice-first multi-agent room where AI perspectives debate your decisions instead of simply giving you an answer.

What I Built

When a friend has an important decision to make, sometimes they don't need another person to simply tell them what to do. They need different perspectives.

That's why I built RoundTable AI—a voice-first, multi-agent decision-making platform where different AI perspectives come together in a virtual meeting room and debate a decision.

The idea is simple:

Don't ask AI for an answer. Build a room that argues about it.

The user provides a decision or problem, and RoundTable creates relevant AI participants with different roles, goals, expertise, and opinions.

For example, the room can include an Investor, Engineer, Customer, Competitor, Devil's Advocate, and Moderator.

The agents don't simply give separate answers. They challenge each other's arguments, question assumptions, and work toward a structured Room Verdict.

The user also stays part of the conversation and can interrupt, challenge the room, ask questions, or add another perspective.

I built RoundTable AI for a friend who often has to make important decisions and could benefit from having multiple viewpoints available before making a choice.

Code

The project is open source:

GitHub: RoundTable AI on GitHub

How I Built It

RoundTable AI is built around three main parts.

🧠 Gemma — The AI Reasoning Layer

The reasoning layer uses Gemma, an open-weight AI model, to power the agents, their perspectives, arguments, challenges, and final synthesis.

The architecture is designed to be model-agnostic, allowing us to experiment with different open models and local inference.

🎙️ ElevenLabs

I use ElevenLabs for the voice layer.

Each AI participant can have a distinct voice, making the experience feel more like an actual meeting instead of a normal chatbot conversation.

⚡ Real-Time Application

The application is built with:

Next.js
React
TypeScript
Tailwind CSS
Node.js
Fastify
Socket.IO

The backend manages the meeting room, participants, conversation, turns, challenges, and final verdict.

An Argument Ledger keeps track of important claims and disagreements so the agents can respond to what is actually being discussed.

Why Does Open Innovation Matter?

Open-weight AI isn't just a checkbox for this project.

RoundTable is designed around experimenting with how different AI agents reason, challenge each other, and reach a decision.

Using open-weight AI gives us the freedom to:

Swap models
Experiment with different models for different roles
Modify agent behavior
Explore local inference
Reduce dependency on a single AI provider
Potentially keep sensitive decisions local

The reasoning model can evolve without rebuilding the entire application.

That's important because RoundTable is not about one particular AI model. It's about creating a system where different AI perspectives can interact.

Open-weight AI provides the reasoning.

RoundTable provides the room.

ElevenLabs provides the voice.

My Agent Session

I used DevRelay during development to help with architecture, implementation planning, code generation, and reviewing the multi-agent system.

Prize Categories

🎙️ ElevenLabs — For giving each AI participant a distinct voice and creating a voice-first meeting experience.
🧠 Gemma — For powering the open-weight AI reasoning and multi-agent debate.

Final Thoughts

We already have AI assistants that answer questions.

I wanted to build something different.

Instead of giving you one AI answer, RoundTable gives you a room full of perspectives.

Sometimes the best AI isn't the one that agrees with you.

It's the one that makes you think twice.

RoundTable AI — Don't ask AI for an answer. Build a room that argues about it.

🚀 Hello DEV! Let’s Build Something Cool!

Yashika Kumari Vishwakarma — Sat, 03 Oct 2026 17:44:19 +0000

🚀 Hello DEV! Let’s Build Something Cool!

Finally joining the DEV Community! 👋

I'm Yashika, an M.Tech CSE student who enjoys turning random ideas into actual projects. 💻

I’m currently exploring:

🤖 AI & Machine Learning

🌐 Full-Stack Development

📱 Flutter

🔬 AI Research

⚡ And a lot of experiments that sometimes work... and sometimes don't 😅

From building web apps to training deep learning models, I'm learning something new with every project.

I’ll be sharing my projects, experiments, failures, research, and things I learn along the way.

No idea where this journey goes, but let's build and find out. 🚀

What are you building right now? 👇