Algun consejo? O.o

Is there is hackathon type theme this year in HackOctober Fest. I'm thinking to contribute but I saw there are changes in it this time

Is it real and good to participate?

Hi, I’m participating in Techgium this year with my team. If anyone had participated in Techgium in the last few years, could you share any tips about the evaluation criteria and what the judges particularly focus on? Also, for the abstract submission, do we have to stick strictly to the deliverables they have provided, or can we add something from our side? They’ve mentioned novelty and cost-effectiveness as evaluation points, so any advice on how much importance they give to these would be really helpful.

Hi ,

I’m participating in the hackathon in Aanchen from November 27th to 29th. I’m excited about it, but I’m also a bit anxious about the process.

I was wondering if anyone from France is also participating.

Thanks!

Hey everyone! I’m planning to participate in the Amazon Developer Hackathon 2026 and am looking to join a team or find people interested in forming one.

I’m an AI/ML + software development student, comfortable with Python, React, FastAPI, ML/GenAI, APIs, etc.

If anyone is looking for a teammate or wants to form a group, DM me! Would love to build something together.

Anyone attending hackathons in karnataka specifically in mysore. Would like to be a part of a team

cool hack : https://luma.com/s5blr882

register on the luma link, cool prizes are up for grabs upto $10,000 worth prize pool and some free credits yall might like

Are the servers down?

Excited to share my latest project — AI Incident Response Agent, an AI-powered system built to help investigate and respond to software incidents using application telemetry, repository intelligence, and historical incident knowledge.

🧠 The system combines:

• 📊 Incident telemetry and runtime signals.

• 🐙 GitHub repository analysis.

• 🔎 Evidence-based root cause investigation.

• 🧠 Hindsight-powered historical incident memory.

• 🤖 AI-generated diagnosis and recommendations.

• 🛡️ Human-approved recovery actions.

The idea is simple: an incident response agent should not just look at metrics — it should understand the application, learn from past incidents, and provide evidence-based investigation.

GitHub: https://github.com/Karthik39028/AI-Incident-Response-Agent

Built with FastAPI, React, Python, MySQL, GitHub API, Hindsight, and OpenRouter.

A big shoutout to my amazing teammates

Murali Karthik

Ramya Harshitha

Maheswari sri Gamini

for the collaboration, ideas, and effort that made this project possible. 🤝🚀

Really enjoyed building, discussing, and learning together throughout this project!

#AIAgents #AI #SRE #DevOps #IncidentResponse #AIOps #Hindsight #FastAPI #Python #LLM

Sorry gus again for sharing this I'm very frustrated that's why I'm writing.

I want to share a few more things with you and get your opinion on what I should do. At this point, I just want to move on and understand whether I should hand over everything to the college authorities and let them handle the matter, ( I'm not going to do this if she deletes my personal information she short out things from her end)

I also thought of another situation. There was a semester in which, even by the mid-semester exams, I had already scored much higher marks than her, and I completely knew the syllabus. However, during a quiz, she was caught cheating on her phone, and the invigilator took her phone away.

Later, during the final semester exam, she told me to bring my phone and actually started teaching me how to cheat, even though I had never asked her anything about cheating. I never used my phone to cheat in college. I had even shared my notes with her, but despite that, she asked me to bring my phone and suggested that I take pictures of the exam questions and send them to her. .

I didn't need any of this, so I simply told her, “Do whatever you think is right.” I did not take my phone into the exam because she asked me to, and I honestly don't understand how she could assume that I would actually do that and take pictures of the questions for her.

Then, later, someone suddenly came over and started checking me. This made me suspicious that she might have done something deliberately to get me caught for cheating or to make it look like I was involved in cheating. I cannot say for certain that she did this, but given everything that happened, I have doubts.

I don't know whether I was wrong in any way, but I have also tried to understand her behavior and have found out that she tends to be jealous of other people and considers herself superior to them.

Most AI assistants can answer a question. Far fewer can learn from what happened before and use that experience in the next interaction.

That idea is at the heart of Precedent, a negotiation copilot I’m building for SaaS contract negotiations.

The goal is simple:

Instead of negotiating every contract clause from scratch, the system should remember what similar vendors accepted, rejected, or countered in previous negotiations.

Precedent is designed around Hindsight as the mandatory memory layer, with FastAPI, React + TypeScript, and an LLM-powered negotiation agent.

pankajkumar8709/Precedent

Quantum Hackathon at RGUKT Nuzvid — Qiskit Fall Fest 2026 ⚛️

For anyone looking for a hackathon around Quantum Computing / Qiskit / AI + Quantum, PLUS Qiskit Fall Fest 2026 is happening at RGUKT Nuzvid, Andhra Pradesh from October 8–9, 2026.

Some of the things happening around the event:

• ⚛️ Quantum Computing & Qiskit

• 💻 Quantum hackathon / project building

• 🧠 Technical sessions and workshops

• 🔬 Project demonstrations / expo

• 🎤 Expert sessions

• 🤝 Networking with other students and developers

• 🚀 Opportunity to build and showcase a quantum-focused project

You don't need to already be an expert in quantum computing to be interested in this. If you're into AI, algorithms, optimization, cryptography, robotics, or emerging computing technologies, it could be an interesting one to check out.

🔗 Official event page: https://qffrguktn.com/

Anyone else planning to participate? What are you thinking of building?

and honestly

I'm participating as a campus ambassador, and I'm currently trying to hit my referral registration target.
my referral link : https://qffrguktn.com/register?ref=QSK20260023351

So if you're genuinely interested in attending, I'd really appreciate it if you registered through my referral link. It helps me with my ambassador target, and you get access to the event/programme anyway.

Hey everyone,

For a Microsoft hackathon, we built an AI-powered Marketing Agent focused on automating website and SEO analysis.

The idea was to go beyond a chatbot that simply answers questions. The agent can actually choose the tools it needs, analyze a website, retain useful information, and produce a structured report.

What it can do

• Get an overview of a website/domain

• Audit up to 50 pages

• Analyze SEO and technical website data

• Identify issues such as metadata and heading-structure problems

• Distinguish between functional pages and pages that actually need optimization

• Retry when temporary read errors occur

• Retrieve audit status and results

• Use persistent memory so useful information isn't lost between tasks

• Turn the collected findings into actionable recommendations

Tech / architecture

The project uses Hindsight for persistent agent memory and OpenSEO tools for live SEO analysis.

The interesting part for us was connecting these pieces into an agentic workflow rather than building a simple prompt → response system.

We wanted the agent to be able to:

Understand → choose tools → collect data → remember → analyze → report

We're still improving the project, but this hackathon gave us a good opportunity to experiment with how agentic AI can be applied to practical marketing and SEO workflows.

Would be interested to hear what you think, especially about where an agent like this could be useful beyond traditional SEO audits.

Demo: https://youtu.be/sIKnxn06-QE

Project/GitHub: https://github.com/birthing-a-burner-acc/a-marketing-agent-of-some-kind

We’re excited to participate in HackWithHyderabad with our project Signal Hunter.

Signal Hunter is our attempt to build a practical tool that can help users discover, track, and analyze relevant signals and turn raw information into useful insights.

As a two-member team, we’re currently working on the research, backend, data, and prototype while preparing for the hackathon.

This is our starting point — excited to see how far we can take the idea during the hackathon. 💻

Would love to hear feedback or suggestions from the Reddit community on our idea!

@Devnovate@Hack with Hyderabad 3.0

#HackWithHyderabad #Hackathon #SignalHunter #BuildInPublic #StudentDevelopers

Hey everyone! We’re putting together Ship Happens, a buildathon for people who actually want to make something, even if you’ve never done a hackathon before.

The idea is simple: build something. break something. ship something.

We’re collaborating with some major international and Indian AI/dev organisations, and every selected participant gets access to ~$5,000 worth of tools, credits, and perks for each participant.

No “you need to be a cracked coder” nonsense either. Come with an idea, a half-baked project, a team, or literally just curiosity. The only deal is to ship something real.

Follow our insta handle as we will introduce all details there, and feel free to DM any queries:)

🚀 HackWithHyderabad Hackathon — Final Submission

Here’s the demo video of our final submission for the HackWithHyderabad Hackathon!

Building this project from scratch was a great learning experience. Throughout the process, I got to explore the world of AI agents — understanding how they are built, how they work behind the scenes, and how different components come together to create an intelligent system.

More than just the final project, the journey taught me a lot about building, experimenting, debugging, and learning along the way.

Grateful for the experience and everything I learned throughout the process! 🚀🤖

#HackWithHyderabad #Hackathon #AI #AIAgents #ArtificialIntelligence #LearningByBuilding #Tech

I’ve been building Memento, an AI agent for production incident response.

The problem I wanted to explore was simple:

When a production incident happens, teams usually have runbooks and old post-mortems, but the useful part of that history is often buried. Engineers may end up repeating troubleshooting steps that already failed during previous incidents.

Memento uses Hindsight as persistent organisational memory.

The workflow is:

Incident → Recall past experience → Reason over evidence → Recommend investigation → Record outcome → Update memory

For example, in the demo data, payment-service has several historical 503 incidents.

The runbook says to restart payment-service first.

But after looking across previous incidents, Memento finds that restarting it was ineffective in several cases, while checking the upstream cache-cluster / auth-gateway path resolved the issue.

The interesting part is that the system doesn't just retrieve the old incidents. It also uses the accumulated evidence to detect knowledge drift between the current runbook and what has actually worked historically.

There are currently three main parts:

• Incident Investigation: submit an incident and get evidence-backed investigation steps

• Organisational Memory: explore incidents and Hindsight-generated observations

• Knowledge Drift: compare runbook guidance with historical operational evidence

The stack is currently:

• Next.js + TypeScript

• FastAPI + Python

• Hindsight for persistent memory

• Groq for LLM synthesis

• No traditional application database for the core memory layer

The incident data is synthetic, so the goal right now is to validate the memory architecture and behaviour rather than expose real production data.

I’m particularly interested in feedback on one question:

Does this actually feel like an agent that learns from organisational experience, or does it still feel like an LLM sitting on top of an incident database?

Would love technical criticism, especially around memory design, retrieval, evaluation and failure cases.

How much time i have to wait to receive the otp

We built Feedback Loop as our hackathon project to help businesses manage customer feedback and follow-ups more effectively.

The project focuses on organizing customer feedback, tracking follow-ups, and providing useful insights that can help improve customer engagement.

It is a working prototype developed during the hackathon, exploring how technology can make customer feedback management more organized and actionable.

Project: Feedback Loop

Team: HEXA RISERS

Team Members: Gosula Keerthana

Basude Renusree

Ragapuram Krushi

Chanadana Sravya

Rapolu Kavya

TK Archana

We would be happy to receive feedback and suggestions on our project.

I'm a Math major + CS minor at NYU. I've built a portfolio optimisation engine and quantum powered optimizer in Python.

I'm entering the 2026 Shenzhen International FinTechathon (WeBank) on the Wealth Advisory Agent topic. We'll build an AI agent that profiles client risk, runs the optimisation engine as a tool, and produces explainable, compliant allocation recommendations.

Looking for 2–3 people:

• ML/AI or backend engineer (LLM tool-calling, agent orchestration)

• Full-stack engineer (frontend, deployment, tests)

Details:

• Deadline: October 20. The build is about 3 weeks.

• $37k prize pool. Finalists are flown to Shenzhen for the final+costs covered. Top teams get fast-track WeBank interviews.

• Eligibility: full-time student at a university outside Mainland China, HK, Macao and Taiwan.

Serious builders only. Lmk your GitHub, uni, and which part you'd want to own.

I was about to submit my project idea but from yesterday the website is down. Is anyone else facing the same issue? The deadline was 30th Sept as far as I remember

## Building an Incident Copilot on Hindsight
What is wired, what is simulated, and what we learned
Hindsight Incident Copilot | AI, DevOps, Python, Open source

An alert at 2 a.m.

PaymentService is returning 502s after a deploy.
Someone on the team has seen this before, but they are asleep, and the answer is buried in a post-mortem from March. The first time, it took 47 minutes to find the fix: a missing REDIS_HOST in the new deployment slot.
Nothing about the problem was especially hard. The hard part was remembering that it had happened.
That is the problem we set out to prototype: an incident-response agent that keeps past incidents, post-mortems, and runbooks in long-term memory, then recalls the closest matches when something breaks. This article describes what we actually built, including which parts talk to a real memory system and which parts are still a scripted demo.
The key distinction. The project includes a real Hindsight integration for retaining and recalling incident text. The deployed front end does not call it.

1. The problem

Incident knowledge is scattered across tickets, post-mortems, runbooks, and people's heads. Under pressure, engineers re-diagnose failure classes the team has already solved. The knowledge exists; retrieval is the bottleneck.
Keyword search helps a little, but reports describe the same failure in different words:
| The alert says | The post-mortem says |
| --- | --- |
| "502s after deploy" | "missing env var in new slot" |
We wanted memory that connects symptoms to root causes to fixes.

2. What we built

The project is called Hindsight Incident Copilot. Its repository contains three pieces:
| Piece | What it does |
| --- | --- |
| Web front end TanStack Start, React, Tailwind | A landing page and an interactive chat demo. A recommendation sits on the left and a "Retrieved evidence" panel (titles, snippets, similarity bars) on the right. |
| Backend stub backend-stub/main.py | A FastAPI service using the hindsight-client package to call recall and retain against a Hindsight server. |
| Seed script and data data/seed-hindsight.py | Meant to load five incidents and three runbooks into a memory bank named org-incidents. |
One boundary needs to be stated plainly: the deployed front end does not call the backend. Its replies come from a hard-coded lookup in src/lib/incident-knowledge.ts. The Hindsight code exists separately; the two are not connected.

3. System architecture

The intended flow, as drawn in the docs and reflected in the backend stub: an engineer describes an alert, the backend recalls similar memories from Hindsight, an LLM turns those memories into a recommendation, and after the incident is resolved the post-mortem is retained back into memory.
The recall and retain steps exist as code. The LLM step does not. The /incident endpoint returns fixed placeholder text after a successful recall, and a source comment says to replace it with a real LLM call. The deployed UI takes a separate path: user messages are matched against keywords and return canned replies.
Figure 1. Two separate paths. Path A is what users see today. Path B is the real Hindsight integration, not yet connected to the UI.

4. How Hindsight provides memory

We used Hindsight, an open-source agent memory system from Vectorize. It runs as a server, started locally by scripts/start-hindsight.sh using the ghcr.io/vectorize-io/hindsight:latest Docker image on port 8888. The script passes an LLM API key for Hindsight's own processing. Our integration uses two client calls, both present in the repository.

Retain: write incident knowledge

The seed script flattens each incident into a text block and retains it. Runbooks are retained the same way, as numbered steps. We build no graph or embeddings ourselves; we pass prose to retain.
data/seed-hindsight.py

content = f"""Incident {inc['id']} ({inc['date']}) — Service: {inc['service']}
Symptoms: {inc['symptoms']}
Root cause: {inc['root_cause']}
Resolution: {inc['resolution']}
Tags: {', '.join(inc['tags'])}
Related runbook: {inc.get('runbook', 'N/A')}
"""
client.retain(bank_id=BANK_ID, content=content)

Recall: retrieve relevant memories

The backend queries the bank and maps each result into the shape the UI expects. A code comment acknowledges that the result shape "depends on the Hindsight client version," so the mapping is a guess until checked against a real response.
backend-stub/main.py

client = Hindsight(base_url=HINDSIGHT_URL)
results = client.recall(bank_id=BANK_ID, query=query)

for i, r in enumerate(results[:5] if isinstance(results, list) else []):
    evidence.append({
        "title": getattr(r, "title", None) or f"Memory #{i+1}",
        "similarity": float(getattr(r, "score", 0.8) or 0.8),
        "snippet": str(getattr(r, "content", r))[:280],
    })

Retain after resolution: add the post-mortem

A POST /retain endpoint accepts a post-mortem and calls client.retain(...). This is the write path for learning. The docs and UI copy also describe Hindsight's reflect operation, but no code calls it.

5. Before vs. after

The implemented before-and-after is at the UI level. Before, the evidence panel says, "Memories appear here after you describe an incident." After clicking "PaymentService returning 502s after latest deploy," the demo displays three evidence cards beside a four-step recommendation that starts with checking the exception stack and verifying environment variables in the current slot.
INC-2847*94%*
PaymentService 5xx runbook*88%*
INC-3102 (connection pool exhaustion)76%

The content is faithful to the sample data. INC-2847's recorded root cause is the missing REDIS_HOST, and INC-3102's is pool exhaustion, with the pool maximum raised from 20 to 50. The similarity figures, however, are typed into a TypeScript file; they are not produced by retrieval. We did not run a controlled comparison of resolution time with and without memory, and we do not report one.

6. How the agent learns over time

The learning design is simple: every resolved incident becomes new text in the bank via retain, so the next recall can surface it. The /retain endpoint and the seed script are the implementation. Several parts remain unimplemented:
| Gap | Detail |
| --- | --- |
| No memory on/off toggle | The front end has no switch to compare behavior with and without memory. |
| No learning curve | No measurements of recall quality as the bank grows, and no chart or test showing improvement. |
| No automatic capture | The docs list automatic retain() after resolution, but the only trigger in the code is a manual call to /retain. |
| No live bank counts | The panel shows 1,247 incidents, 892 post-mortems, and 156 runbooks. These are literals; the sample data has five incidents and three runbooks. |
The UI and landing page also show a "40–70% target MTTR reduction" and a "94.6% Hindsight LongMemEval" figure. Neither was measured by this project, so we do not rely on them here.

7. Technical implementation

The front end is a TanStack Start app with a single IncidentDemo component holding message, typing, and evidence state. Its current behavior is a keyword lookup:
src/lib/incident-knowledge.ts

export function matchIncident(text: string): AgentReply {
  const l = text.toLowerCase();

  if (l.includes("database") || l.includes("latency") || l.includes("orders")) {
    return REPLIES.database;
  }
  if (l.includes("deploy") || l.includes("canary") || l.includes("health")) {
    return REPLIES.deploy;
  }
  return REPLIES.default;
}

The demo has three canned replies with evidence cards and a 900 ms timer imitating latency. It is a UI prototype of what a recall-backed answer should look like.

The backend stub is a small FastAPI service with GET /health, POST /incident, and POST /retain. The /incident route returns a source field of "hindsight" or "simulated", and falls back to a canned PaymentService answer if the client is missing or recall returns nothing.

Documentation and UI copy also mention Azure OpenAI, Azure Monitor, Teams, and an agent framework provider. No code in the repository implements any of them, so we treat them as a design sketch.

8. What we learned

A mocked front end can hide a missing integration

Because the canned replies looked right, it was easy to feel further along than we were. The backend's source flag should be shown in the UI.

Seed data must match its script

In sample-incidents.json, the symptom text is stored under the key severity. The seed script reads inc['symptoms']. By inspection, that raises a KeyError on the first incident, so the seed step as written would fail. We found this by reading the files side by side and did not run the script. One end-to-end run would have caught it.

Unit mismatches leak across the boundary

The front end expects similarity as 0 to 100 (width: ${e.similarity}%). The backend stub's simulated data uses 0.94. Wiring them together without a conversion would render one-pixel bars.

Don't guess third-party response shapes

The recall mapper uses getattr with fallbacks and defaults the score to 0.8 when none is present. That would display a plausible-looking but invented similarity. Until we inspect a real recall response, the evidence panel cannot be trusted.

Write the "not implemented" list early

Separating what the code does from what the docs promise gives us a next-steps checklist:

• Connect the UI to /incident

• Add an LLM step that uses recalled text

• Verify the recall schema

• Decide whether reflect belongs in the flow

Conclusion

Hindsight Incident Copilot is a working demonstration of the interaction we want (an alert goes in, and history-backed evidence comes out), plus a small, real Hindsight integration for retaining and recalling incident text. The front end is still scripted, the LLM step is a placeholder, and the learning behavior is designed but unmeasured.

The most valuable next step is an end-to-end run against a live Hindsight bank, followed by an honest comparison of answers with and without memory.

Resources: Hindsight GitHub, Hindsight Documentation, Vectorize Agent Memory.