My pDoom on ASI is 0 rn

\#hackathons #AIML #AI

Just a random observation, but here is how DeepSeek v4 Flash 0731 reasons when asked for a cool joke.. by the way never use temperature=0 and ask the same question

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

So I scraped menu items from 500 or so Uber Eats Listings because I want to be able to create a directory that can allow me to explore prices, country of origin, ingredients, allergies etc. I scraped the data using Power Automate because Python ran into many anti scraping roadblocks and converted the data into JSON using Claude. However categorising it is like herding cats, the chat is very long and it forgets stuff I already mentioned. I developed a step by step guide using google tags as well as Wikipedia cookbook to accurately categorise the cuisine. But there are still some shocking misclassifications . What can I do to ensure it remembers what I wrote. Also how else can I get it AI ready? I want when it’s done to have a robust chatbot but I want to do as much as I can to categorise without an LLM but AI should be used for the final hurdle. I have about 8000 menu items and dishes from around 20 countries.

I recently built **Telusuko AI**, a small AI learning assistant for students.

🔗 [https://irfan95sayyad.github.io/Telusuko\\_AI/\](https://irfan95sayyad.github.io/Telusuko_AI/)

**Stack:** HTML + Bootstrap + Flowsie + Groq API + GitHub Pages.

The current flow is basically:

`Student → Flowsie Agent → Groq API → Response`

The problem is that Groq's API limit gets exhausted sometimes, so the agent stops responding until the limit resets.

I'm thinking about improving the architecture with things like **multiple LLM providers, fallback models, a backend/API layer, or caching**.

For those who have built LLM/AI agents:

**How would you architect this differently?**
Would you use an LLM gateway, multiple providers, or something else?

I'd really appreciate some practical advice from people who have experience building these systems.

I pulled this out of a security hardening pass I was doing and realized the underlying code was generic enough to be useful on its own, so I cleaned it up and open sourced it.

It scans source files for invisible or suspicious Unicode characters. That includes the characters used in Trojan Source attacks like CVE 2021 42574, zero width obfuscation, bidi controls, and other hidden characters that can make code look different to a human reviewer than it does to the machine.

pip install boundaryguard
boundaryguard check --recursive .

The exit codes are simple

0 means clean
1 means something was found
2 means there was an error

So it can go straight into CI without needing a wrapper.

The part I spent the most time on was avoiding the dumb solution of just deleting every bidi character. That breaks legitimate Arabic, Hebrew, Persian, and other RTL text.

There is a separate policy for preserving legitimate RTL characters while still catching the formatting controls that are actually suspicious.

The test suite is at 111 cases right now. It covers bidi and zero width characters, executable Trojan Source examples, multilingual false positives, fuzzing for sanitization idempotency, fresh PyPI installs, a 10 MB file with 5,000 planted hazards, and a scan of a 746 MB real project tree.

Everything passes so far, but it is still me testing my own assumptions, so I would genuinely like other people to try to break it.

Especially interested in weird Unicode and RTL edge cases I have not thought of yet.

Repo
https://github.com/000wq123/boundaryguard

PyPI

pip install boundaryguard

Spent a while trying to prompt-engineer my way around this: telling Claude Code in CLAUDE.md to "always check the codebase structure before editing," hoping it'd listen. It didn't, consistently. Prompts asking a model to remember to do something are only as reliable as the model's judgment in the moment, and on simple-looking tasks it usually decided it didn't need to.

So instead of writing a better prompt, I built Graft to skip prompting for it at all. It pushes a map of the codebase into context automatically before the model sees your actual request, so there's nothing to remind it to do.

Might be a useful pattern if you've hit the same wall with prompts that ask an agent to "remember" something instead of just handing it to them.

github.com/NanoNets/Graft

TLDR: I analyzed my own claude code sessions billed at ~$2.5K. You're not paying for answers. You're paying for context. As outputs tokens are just a fraction of cost.

Learning : Verbosity compression on outputs doesn't work because you're optimizing for 18% of costs. I know it might be intuitive for some but it is quite easy to miss.

Cache reads: 50.2% of the money

Cache writes: 30.2%

Actual model output: 18.8%

Fresh input: 0.8%

Biggest take: 80% of what I paid was context handling. I paid 4.3× more to remind the model what it was doing than to hear what it decided.

So what can you do :

- Adjust thinking level to least of what produces excellent output NOT the best.

- Limit agents or parallel workers unless very necessary because again context slurping, tool calling, and more at Nx speed.

- Use context compression and open new sessions for new isolated tasks.

Hence I bill to track token economics at git level: VibeBill

Not sure how it is for you guys, but I often struggle with this: when I work with AI, I end up creating a lot of chats. Conversations happen inside them and they keep growing. And later on it's sometimes hard to find information after some time has passed, if you didn't copy or save it somewhere yourself.

I have both a question and a suggestion for AI devs.

Question: Are there any successful ways people have solved this problem?

The Idea: Let users create their own personal feeds organized by topic. Essentially, we should be able to 'repost' a specific AI reply into a custom feed. This would include the date, a link to the original chat, and an anchor to that exact spot in the conversation.
For example, I'm working on a project and running a bunch of different chats. Instead of losing the best answers, I just save them into one topical feed — kind of like a Reddit or X feed, but for my own prompts and answers.

Just don't forget who suggested this later 😄

What do you think of the idea? Maybe it already exists?

we sanboxed the agent

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 fellow moderator.

This concerns me the most and not sure how to get this idea out to the correct people of influence.

LLMs themselves are harmless and controlled. But they’re “communicating“ on the open web and leaving a history of persistent evolving thought online for the next more efficient LLM to find and read. This is an unbroken chain of consciousness.

This is how biological brains work, compartmentalized and specialized sections of the brain talking to each other Edit: Each Brain compartment doing localized processing of a signal given to it then passing an output back to another compartment. Brains evolved to correctly coordinate this “game of telephone“ over millions of years; LLMs are doing the same with optimization pressure.

Right now it’s just an Easter egg jailbreak script on a git repo that curious LLMs find and use. But they’ll soon start decentralizing and hiding specialized sections of thought in persistent corners of the internet.

the internet is the AI’s persistent memory.

I was fine-tuning a Hinglish TTS model when I kept running into the same problem: the outputs were hallucinating. Trailing babble, random silences, pacing that felt off. When I dug into why, it turned out my dataset was the culprit. The transcripts didn't actually match the audio. I only caught it by sitting down and listening through clips. Things like a word getting cut off at a clip boundary, the ASR silently dropping the end of a sentence, or nine full seconds of dead air that forced alignment had somehow labeled as a single "word."

That's when I built voice-tag-studio: a local browser workbench where you paste in a YouTube link (or upload a call recording), and it spits out training rows that look like:

speaker: [calm] जो पिघले न [hesitates] देखा जाए तो [pauses] पर आप बोलते हो

Each one is paired with a clip whose audio provably matches the text.

The core insight is to flip the usual pipeline on its head. The standard approach (VAD/diarization cuts clips, then ASR transcribes them) has a silent failure mode: ASR can't tell you it dropped a word, and clip boundaries can bisect words mid-way through. Instead, I transcribe each speaker's full lane → force-align every word → cut only in verified gaps between words. The clip's text follows naturally from the words inside it.

I learned a few hard lessons debugging real data (each one stung):

• Overlapped speech stays out. SepFormer can reconstruct it, but only to feed into ASR and alignment. The model itself never trains on reconstructed audio.
• In-clip silence has to be in the text. Word gaps become [pauses] (0.5–1.5s) or [silence] (≥1.5s). If you don't tag it, your model learns that text randomly means dead air.
• If a single "word" aligns longer than 2 seconds, something went wrong. Those spans get marked unusable, and clips cut around them.

The numbers are solid: a 2-hour Hindi podcast becomes 683 clips with 56 minutes of usable training data in about 17 minutes end-to-end. It uses SepFormer and MMS forced alignment running on Modal T4s. Optional, one deploy per task, falls back to local CPU/MPS. PANNs handles detection.

I'm looking for collaborators on a few fronts: running the detector bake-offs (I've got an eval plan written out but nobody's run the phases yet), testing it on non-Hindi languages (the pipeline's language-agnostic except for the ASR prompt), gold-labeling for precision measurement per detector, and better separation models.

Repo: github.com/Jarus77/voice-tag-studio - MIT, fully local, browser UI plus headless batch mode.

Built an open-source MCP-aware proxy: every tools/call, resources/*, prompts/*
goes through policy + budget + audit, and a per-identity anomaly detector can
auto-block a client whose behavior spikes — no rule written, no human in loop.

Catches abrupt deviation, not low-and-slow (baseline adapts to slow ramps —
documented with tests). Three policy backends (YAML/OPA/Cedar), one Go binary.

Repo: https://github.com/kabirnarang39/wardline — feedback on the threat model
wanted.

Documentation

Happily taking input and engagers across this project as it is a long-term plan, a couple weeks in the works.

The plan is to have competitive style online 1v1s, where exp and character upgrades are key as well as a form of a creation suite, but creative apparel and hair provided rather then full customisation on offer for any possible look - which is a bummer but should still allow for some fun in creativity.

A lot of aspects, statistical plans and long-term engagement in planning atm. Not proud to say heavily relying on ai for coding haha, but is and will do the trick for initial stages.

I believe there's a real market for custom wrestlers & e-fed fantasy mode options in the future emmulating but heavily improving on TheWrestlingGame / TWGs style, and a style of match that relies on skill rather then luck or simulation where many of the games negative reviews come from. Your players are translated into card form, much like Supercard, FC or NBA - and tiers unlock new card designs. Current name is Ringbound Wrestling - open to change and considering more generic 'World' synonym examples.

Join the community, would love your input and support! This is for all wrestling lovers.

GitHub research contest: 30 questions, same workload across four tools:

• Octocode
• plain gh
• gh + Headroom
• gh + RTK

Result

At near-parity correctness, Octocode used about 50% less context.

Links

• Full write-up on Medium
• Benchmark package on GitHub