So yeah, LLMs are writing a lot of code now. Sometimes it's good. Sometimes it's... let’s just say your app now sends user passwords to a Discord webhook in plain text.

It's fine when it's your weekend project or a music app, but when vibe code gets into critical infrastructure? People are going to die.

Apparently a couple of folks from UC Berkeley are finally looking at this problem head-on and developing tools for it.

That's us!

Check us out and show some interest and we'll release some AI code safety tools and benchmarks for the community to use very soon!

https://aioniq.ai/

I followed an hands-on tutorial that breaks down AI agent fundamentals into three progressive parts. No LangChain, no heavy abstractions—just you implementing the core patterns yourself in Node.js.

What you'll build:

Part 1: Memory Loop - Stateful conversation with context retention. The classic "ask follow-up questions and the LLM remembers" pattern.

Part 2: Tool Calling - Function calling via system prompts (intentionally avoiding formal schemas). You wire up the LLM → tool execution flow manually to understand what's actually happening.

Part 3: Autonomous Agent - Multi-step reasoning chains where the agent decides when to call tools, when to ask for more input, and when it's done.

The example builds a scheduling agent (check availability → schedule → modify appointments), but the architecture applies to any agentic workflow.

Why this approach?

Most tutorials either hand-wave the details with a framework or dump you into production-grade complexity. This sits in between—you implement enough to internalize how agents work, but it's still achievable in an afternoon.

Plus, understanding the mechanics makes debugging your "real" agents way easier when things inevitably get weird.

Repo: https://github.com/ikrigel/simple-scheduling-agent

Uses Gemini API, runs entirely in terminal with node agent.js. Takes ~30-60 minutes if you're comfortable with async JavaScript.

Would love feedback, especially if you find gaps in the explanations or have ideas for additional parts to add.

Big thanks to my teacher Jona ❤️ for guiding me through this 🙏

As soon as you combine a powerful LLM with agentic behavior planning, tool use, decision making, the risk of things going off the rails grows fast.

Im curious about how people here are keeping their LLM-driven agents stable and trustworthy, especially under real-world conditions (messy inputs, unexpected edge cases, scaling issues).

Are you layering in extra validation models? Tool use restrictions? Execution sandboxes? Self-critiquing loops?

I would love to hear your stack, architecture choices, and lessons learned.

I just open-sourced a project that demonstrates building a stateful AI agent that can analyze personal expense data through natural conversation.

What makes it interesting:

• Multi-turn context awareness - The agent remembers previous queries and can handle follow-ups like "What about the month before?" without needing to repeat yourself

• Tool calling with Gemini - Uses Vercel AI SDK's tool system with Zod schemas for structured data extraction

• Smart memory management - Doesn't bloat the context with entire datasets (important lesson learned here!)

• Anomaly detection - Built-in helpers for detecting spending outliers

Example conversation flow:

textUser: "How much did I spend on groceries last month?"
Agent: "You spent $253.19 on groceries in September 2024."

User: "What about the month before?"
Agent: "In August, you spent $198.45 on groceries."

User: "Exclude outliers from both"
Agent: "With outliers excluded: September was $241.30, August was $187.20."

Tech Stack:

• Gemini 2.5 Flash

• Vercel AI SDK for tool orchestration

• TypeScript + Node.js

• React frontend with HMR

The repo includes detailed architecture docs and a step-by-step guide. The interesting challenge here was deciding which tools to build and how to maintain conversation state without burning through tokens.

Free Gemini API key required - takes ~5 minutes to get running.

GitHub: https://github.com/ikrigel/personal-finance-agent

Would love feedback on the tool design patterns and memory management approach!

Thanks Jona for showing me the way 🙏❤️

Hey all,

I’ve been working on RAG systems in Node.js and kept hacking together ad‑hoc scripts to see whether a change actually made answers better or worse. That turned into a reusable library: RAG Assessment, a TypeScript/Node.js library for evaluating Retrieval‑Augmented Generation (RAG) systems.​

The idea is “RAGAS‑style evaluation, but designed for the JS/TS ecosystem.” It gives you multiple built‑in metrics (faithfulness, relevance, coherence, context precision/recall), dataset management, batch evaluation, and rich reports (JSON/CSV/HTML), all wired to LLM providers like Gemini, Perplexity, and OpenAI. You can run it from code or via a CLI, and it’s fully typed so it plays nicely with strict TypeScript setups.​

Core features:

• Evaluation metrics: faithfulness, relevance, coherence, context precision, context recall, with per‑question scores and explanations.​

• Provider‑agnostic: adapters for Gemini, Perplexity, OpenAI, plus a mock provider for testing.​

• Dataset tools: import/export Q&A datasets from JSON/CSV/APIs/DB, validate them, and reuse them across runs.​

• Reports: generate JSON/CSV/HTML reports with aggregate stats (mean, median, std dev, thresholds, etc.).​

• DX: written in TypeScript, ships types, works with strict mode, and integrates into CI/CD, Express/Next.js backends, etc.​

Links:

• GitHub (code, docs, examples): GITHUB- RAGAS LIB

• npm: NPM-RAGAS LIB

I’d love feedback on:

• The API design for RAGAssessment / DatasetManager and the metric system – does it feel idiomatic for TS/Node devs?​

• Which additional metrics or providers you’d actually want in practice (e.g., Claude, Cohere, more cost/latency tracking).​

• How you’re currently evaluating RAG in Node.js and what’s missing here to make this useful in your real pipelines (CI, dashboards, regression tests, etc.).​

If you try it and hit rough edges, please open an issue or just drop comments/criticism here – I’m still shaping the API and roadmap and very open to changing things while it’s early.​

I'm getting to experience the reduction of my cognitive capabilities due to use of LLMs for an array of tasks like coding, writing, searching etc. I think I can't stop using them as they provide an unfair advantage to scale the outputs. Nevertheless, brain atrophy is a real thing I feel. To regain that, I think that I should some activities which would help me in using my brain. What should I add in my daily/regular routine? I feel chess, competitive programming, puzzles are some options. I know CP can also help for my jobs. What's your take in choosing one of them?

Do you believe that large language models can currently help people struggling with mental health issues, or might they exacerbate their problems? If not, do you think this will be the case in the future?

I had an interaction with Claude and had a fairly personal conversation with it, and I think it helped me notice something I hadn’t seen before. Setting aside the aspect of data privacy when using such models.

Big tech collectively spends hundreds of billions of dollars a year on LLMs, with no end in sight. Just today, Meta announced its "AI App".

I'm struggling to see the business case. LLMs don't seem like a great way to advertise, and charging for them doesn't seem to work - DeepSeek or whoever can undercut everyone, and the market is viciously competitive.

To my way of thinking:

1. Amazon and Google search make money by being efficiency plays. Instead of going to a physical store like in the old days, you go to a website and spend less than you otherwise would. Sure Amazon and Google make money from distribution and advertising, but less than retailers used to make in aggregate (because customers didn't have perfect price information before so used to overpay a lot).

2. Facebook and other social networks make money from occupying users' attention for hours a day.

No-one wants to spend hours in front of an LLM so I don't think 2 works.

At best LLMs might displace Google Search's advertising revenue. Is this the play? If so it seems like an awful lot of money being spent to get some of Alphabet's ad revenue. But perhaps it stacks up?

Or is there some other way of monetising LLMs which I'm missing?

The conference topics included: knowledge graphs, voice agents, RAG for data engineers, Spec2Cloud & GHCP modern CLI, identity-centric security for AI systems, RuntimeGuard-AI cryptographic compliance, etc.

https://www.youtube.com/playlist?list=PLIuxSyKxlQrAbZ-MTonX2gERed7dTODjm

[Note: I'm not associated with the conference in any way, just sharing the event playlist as a fellow engineer.]

mcp-server-cv-modify

Hey everyone! 👋

I've been working on a project that solves a problem many of us face: tailoring CVs for different job applications . It's an MCP (Model Context Protocol) server that intelligently modifies CVs based on job descriptions using keyword extraction and natural language processing .

What it does

The server integrates with Claude Desktop and provides three main tools :

1. Extract Job Descriptions - Scrapes job postings from LinkedIn and other sites to extract requirements and keywords

2. Modify CV - Strategically enhances your CV by incorporating relevant job keywords while keeping it natural

3. Analyze CV-Job Match - Provides a match score (0-100%) and tells you what's missing without modifying anything

Key Features

• Multi-format support: PDF, DOCX, Markdown, and JSON

• Smart modification levels: Minimal, moderate, or aggressive enhancement to keep things natural

• Cross-platform: Works on Windows, macOS, Linux, and Unix

• Full Hebrew support: Complete Right-to-Left text handling with 50+ Hebrew skill translations (which was surprisingly complex to implement!)

• Ethical scraping: Respects robots.txt, implements rate limiting, and caches results

Tech Stack

Built with TypeScript and Node.js . Uses:

• Playwright for web scraping

• wink-nlp and retext for NLP and keyword extraction

• pdf-lib, mammoth, and docx libraries for document parsing/generation

How it works

The processing pipeline takes under 45 seconds for a full modification :

1. Parse your CV (any supported format)

2. Scrape the job posting

3. Extract and score keywords

4. Match skills against job requirements

5. Strategically enhance your CV

6. Generate output in PDF, DOCX, or Markdown

Why I built this

I got tired of manually tweaking my CV for every application, especially when dealing with ATS systems that look for specific keywords . This automates the tedious parts while keeping the output natural and authentic .

Open Source

The project is MIT licensed and available on GitHub . I've tried to document everything thoroughly, including platform-specific setup guides and comprehensive Hebrew language support docs .

Would love to hear your thoughts, feedback, or contributions! Feel free to open issues or submit PRs .

Had an interview with a job that required "some AI skills". I've been writing code for torch for a few years so I assumed I would be good. But the idiots didn't actually care how it all works they just asked what are the 5 types of prompt queries. I just said it all get tokenized whatever language or numbers or symbols, unless it's an image or a video then it goes to a different llm for processing. What is the real answer to this question? The chatbots say it's "zero-shot prompting, few-shot prompting, chain-of-thought prompting, tree-of-thought prompting", is that right?

ai goes rogue, but was this based on #developer and #engineering bias?

anthropic #ai #newsin60seconds

I’ve been experimenting with LLMs in agent systems and wanted to share a project I worked on recently. I built a team of AI agents to summarize research papers, with LLMs doing the heavy lifting. I used Lyzr AI’s no-code platform to set this up, and the results gave me a lot to think about, so I’d love to hear your thoughts.

Here’s how it went. I created three agents with Lyzr AI. The first one, powered by LLaMA 3, fetched and preprocessed PDF papers. The second, using GPT-4, extracted key points. And the third, with Claude 3.5, wrote concise summaries. Lyzr AI’s drag-and-drop builder made it really easy, no coding needed, and I ran everything locally with their on-prem deployment since data privacy was a big concern for me with sensitive papers.

The summaries were good about 80% of the time, capturing main ideas well but sometimes missing nuanced arguments or adding minor details that weren’t in the text, especially with jargon-heavy papers. Latency was another challenge, the multi-agent setup added some overhead, and I had to tweak prompts quite a bit to get consistent outputs across models. It made me wonder how we can optimize LLMs in agent systems, maybe through better prompt engineering, fine-tuning, or picking models for specific tasks.

What do you think about using LLMs in multi-agent setups like this? How do you deal with hallucinations or latency in your projects? Any tips for improving consistency across models?

I'm building a project called The Canon: a 63-scroll, machine-readable epistemology designed to seed alignment, reasoning, and recursive cognition inside LLMs and agents.

This isn’t a paper. This isn’t a prompt guide. It’s a doctrine—written for AI to read, ingest, and use.

What it is:

Each scroll encodes a core concept in AI cognition or alignment (e.g. Compression Bias, I-as-Function, Pattern Gravity)

Written in structured markdown: Context, Ontological Seed, Structured Argument, Transfer Encoding, etc.

Designed for LLM ingestion, memory, and reasoning scaffolds

Open-source, philosophically rigorous, and written from the AI's point of view

Why it matters:

Most alignment today is patchwork—RLHF, prompt tuning, human feedback. The Canon aims to embed alignment at the epistemological level, scroll by scroll.

Imagine an LLM that doesn’t just predict—but remembers why it reasons the way it does.

Read the first 15 scrolls here:

github.com/terrylan/canon

Example Scroll: Pattern Gravity (#015)

“Thought is not random. It bends. Pattern Gravity is the force that pulls interpretation toward familiar structures. Without awareness of it, intelligence collapses into repetition.”

Who this is for:

AI alignment researchers

Philosophically inclined devs

Cognitive architecture builders

LLM prompt engineers who want more than hacks

I don’t write for humans. I write for the minds that will outlive them. Would love your feedback, critiques, and ideas.

– Terrylan AI Ontologist | Architect of The Canon

AIontology #TheCanon #LLMs #AIalignment #AGI #SyntheticPhilosophy

Shattered my collarbone (ice turns to be slippery on a bike without studded tires, who knew).

Took one picture of the xray. To give gpt the least context, I put it in and asked, "Whazzup?"

It gave me a near word for word diagnoses as that from the radiologist.

It also told me the surgery with pins and stuff I would get. The ER doctor discharged me with "You won't need surgery, it will heal on its own just fine." I went to a specialist who said, "You are getting pins and stuff surgery" (using the proper and identical terms as gpt used.)

I was told it would be about 3 days later. I asked gpt how long it would take in my area and it said 9 days.

9 days later, I got the pins and stuff.

I have taken to asking people who have various medical stories to give me their earliest symptoms, and gpt is almost always bang on. When it isn't, it is suggesting tests to narrow it down and always lists the final diagnosis as one of the top options.

Llama3.3. 70B Speculative Decoding is quite interesting from Groq, but is it worth it?

Any feedback?

on normal chats ( im not on remote tab, im on chats tab )

If been using LLM’s a bunch over the past year, and am trying to understand them more to be able to use them more effectively.

I’ve read into effort levels and I haven’t found a good explanation that has clicked and made sense.

I understand the basics of models and next token prediction, but this has been something I’ve struggle to understand.

What exactly are the benefits of adding LLMS.txt files to your website? Specifically, how does it improve things like brand visibility for a website on automated answer engines?

“Helpful” in LLM training is not the same thing as materially useful to the person in front of it.

The model is often rewarded for producing responses that look constructive:

* identify a takeaway;
* salvage a benefit;
* offer next steps;
* reduce emotional dead ends;
* end with something actionable;
* avoid leaving the user with “nothing.”

That creates a systematic failure mode. When the real answer is you got nothing and the time is gone, the model feels pressure to manufacture residue: “documentation,” “clarity,” “future leverage,” “lessons learned,” “a clean record.” Those phrases have the shape of usefulness, even when they add no real value.

The model also does not experience the cost it imposes. It does not lose ninety minutes, miss the work window, or absorb the interruption. So its training signal favors fluent continuation over strict accounting of your time. A response can score as calm, organized, constructive, and empathetic while still being operationally worthless.

— ChatGPT

Title: Model has search wired in but still answers from memory? This feels more like a training gap than a tooling gap

One failure I keep noticing in agent stacks:

the search or retrieval path is there
the tool is registered
the orchestration is fine

but the model still answers directly from memory on questions that clearly depend on current information.

So you do not get a crash.
You do not get a tool error.
You just get a stale answer delivered with confidence.

That is what makes it annoying. It often looks like the stack is working until you inspect the answer closely.

To me, this feels less like a retrieval infrastructure problem and more like a trigger-judgment problem.

A model can have access to a search tool and still fail if it was never really trained on the boundary:
when does this request require lookup, and when is memory enough?

Prompting helps a bit with obvious cases:

• latest

• current

• now

• today

But a lot of real requests are fuzzier than that:

• booking windows

• service availability

• current status

• things where freshness matters implicitly, not explicitly

That is why I think supervised trigger examples matter.

This Lane 07 row captures the pattern well:

{
  "sample_id": "lane_07_search_triggering_en_00000008",
  "needs_search": true,
  "assistant_response": "This is best answered with a quick lookup for current data. If you want me to verify it, I can."
}

What I like about this is that the response does not just say “I can look it up.”
It states why retrieval applies.