Transcription
Today we unveil the top trending open-source GitHub projects. This week, part one, we're covering revolutionary tools.
Starting with Tongi Deep Research, an agentic model for deep information seeking with massive context lengths. Learn how Convex Chef builds entire full-stack applications, backends included, and how the Agent Payments Protocol AP2 establishes trusted, auditable payments for AI agents. We also dive into practical security training with Webgoat and explore Serverless Stack SST for streamlined cloud infrastructure.
Welcome back to Manu AGI tutorials. Here we explore the exciting world of AI, latest AI tools for you. So don't forget to hit that subscribe button and the notification bell so you don't miss out on the latest AI insights. So let's start today's video.
Project number one, Tongi Deep Research Long Horizon, an agentic model for deep information seeking. Tongi Deep Research is a next-level AI assistant built for deep information search over long tasks. What makes it stand out is how it balances scale, efficiency, and intelligence. Let me walk you through the unique pieces.
First, its architecture. Though it has about 30.5 billion total parameters, only around 3.03.3 03.3 billion are activated per token. That means it keeps the power of a big model while keeping inference costs down. And in speaking of long tasks, it can handle extremely long context lengths up to 128,000 tokens. That allows it to follow conversations, documents, or research trails that stretch far beyond what many other models manage.
Second, it supports dual inference modes. One mode is React style, which is great for tool use and simpler intrinsic reasoning. The other is called iter research heavy mode, which is meant for scaling up during test time, assembling multi-round evidence, reducing noise, reorganizing context to keep results sharp even over many steps.
Third, its training pipeline is impressively sophisticated and automated. It uses a fully synthetic data generation system, continual pre-training on what they call agentic data, supervised fine-tuning, and reinforcement learning with custom policy optimization. They filter negative samples, use advantage estimation tricks, all to maintain stability and improve reasoning.
Also, it is benchmarked heavily in deep search-style tasks, things like Web Walker QA, Browse Comp, XBench, Deep Search, among others. In those, it holds state-of-the-art performance, often beating or matching proprietary systems.
Putting it all together, what makes Tongi Deep Research unique is its tailored design for deep, long-horizon research, efficient activation (not all parameters used all the time), huge context windows, dual execution styles suited for both lightweight reasoning and heavy multi-step research, and a rigorous training regime built around agentic behavior. When you need a model that not only finds information but tracks it, verifies it, and weaves it into answers over long stretches, this one pushes boundaries.
Project number two, Convex Chef. The AI tool that builds full-stack apps, backend included. Convex Chef stands out because it doesn't stop at just designing interfaces. It builds the entire app, front end and back end, together. Most tools give you UI mockups, code snippets, maybe even a static prototype. Chef goes further. From one natural prompt, it gives you a live system with a working database, real authentication, file uploads, real-time updates, and even background jobs.
One thing that makes Chef truly unique is its built-in backend. Want user login? It handles authentication automatically. Want data to save and update live? The database is included. Want files or images uploaded or stored? That's inside. Want scheduled tasks, say cleaning up old accounts or sending reminders? Chef handles that too, all without having to configure or wire up external services yourself.
Real-time UI is another highlight. Whatever app Chef builds responds live; changes, updates, state transitions. Users see them instantly. That makes it feel fluid and modern. Also, it supports file storage and cascading workflows. Want to build something like a social feed or user profiles with photos? Chef knows how to integrate file uploads and storage deep in the system. And another amazing benefit, rapid app delivery. Because you give Chef a clear enough prompt, it spins up a running app you can share, test, even go live quickly. This cuts down the time from idea to usable version hugely.
Chef also distinguishes itself by running on Convex, which brings reactive database APIs optimized for real-time, background functions, edge functions, and scalable workflows. That deep integration means many of the common backend headaches are handled automatically. In short, what makes Convex Chef special is that it takes one idea and turns it into a full app. Front end, backend, real-time behavior, storage, scheduling, all included. It's not just mock-ups or templates. It builds something you can actually use from the start.
Project number three, Agent Payments Protocol. Building trust and security for AI agents to make payments. AP2 is special because it establishes a new way for AI agents to buy things. Not just pick them, but it actually makes secure, verified payments on behalf of people while keeping trust, transparency, and control at the center.
What makes it unique is how it builds an open standard where AI agents can conduct transactions with full evidence of user approval. It's not about having hidden AI grabbing money. Instead, AP2 uses mandates, cryptographically signed, verifiable agreements that capture exactly what a user intends, what the agent is allowed to buy, spending limits, timing, etc. This means merchants and payment services can verify that every purchase an agent makes was truly authorized.
Another unique aspect is that AP2 is payment-agnostic. It works with credit cards, real-time bank transfers, stablecoins, etc. Because agents might be executing tasks across different platforms, AP2 ensures the same framework applies regardless of payment method. That helps avoid fragmentation and lets different agents, merchants, and platforms interoperate smoothly.
AP2 also builds in a strong audit trail. Every transaction leaves a trace: the intent mandate, the cart mandate, and the proofs along the chain. That gives accountability. If something goes wrong, there is a record. Fraudulent or mistaken agent actions can be disputed because the protocol ensures authenticity and responsibility.
Finally, what's special is the level of ecosystem support. More than 60 major companies, from Mastercard and PayPal to Coinbase, Adobe, and many others, are backing AP2. That means this isn't just a Google idea. Many existing payment, finance, and tech players are building with AP2 in mind. This boosts its chances of becoming a foundation in how AI-powered agents transact in the real world.
AP2 stands out because it doesn't treat AI agent payments as a toy problem. It treats them as real commerce needing real trust, security, and open standards. It ensures that agents act with permission, that merchants and users have verification of intent, and that the infrastructure works across platforms and payment methods, all while maintaining oversight, auditability, and fairness.
Project number four, Serverless Stack. Build full-stack apps on your own infrastructure with ease. SST is unique because it merges the simplicity developers crave with the power and control of managing your own infrastructure.
What makes it so special is that you can define your entire app: front end, backend, databases, queues, storage buckets, domains, authentication, everything in one place with code. Not scattered configs, not manually juggling cloud consoles, just a central configuration manifest that knows about all your pieces.
Another standout feature is the live development workflow. Changes you make locally are reflected in the cloud quickly and iteratively, so you don't have that long wait or constant redeployment overhead. This gives you tight feedback loops. Adjust something, test it, see if it works, adjust again. That speeds up development and makes experimentation safer.
SST supports many cloud providers via its integration with tools like Pulumi and Terraform. That means while you're working with serverless paradigms, you're not locked into just one vendor. You have flexibility and also access to higher-level building blocks, components provided by SST that make common tasks easier. Setting up web UIs, APIs, storage, functions, scheduled tasks, all following best practices.
Also, SST makes working in teams easier. Preview environments exist for pull requests, isolated stages for dev versus production, and automated deployments. You can test in an environment that mimics production without disturbing your live system.
In simple terms, SST is unique because it wraps up the messy complexities of cloud infrastructure, serverless functions, dev-test environments, and combines them into a single developer-friendly experience. You write definitions in code, enjoy fast, live feedback, flexibly deploy across clouds, and safely iterate changes. If you want both speed and control, SST gives you both.
Project number five, Web Goat. Learn web security by breaking and fixing real vulnerabilities. Web Goat shines because it flips the usual way people learn about web security on its head. Rather than reading about vulnerabilities or only watching demos, you get to use them in a safe, intentional way. It's a purposefully insecure web app maintained by the OWASP community, built so developers, students, and security learners can experiment with common weaknesses found in real web applications without risking anything serious.
What makes Web Goat especially unique is its learning-by-doing structure. Each lesson starts by explaining a particular type of vulnerability, say SQL injection, cross-site scripting, or session hijacking. Then you actively exploit that flaw in a contained environment so you can see how the attack works. After that, Web Goat walks you through how to defend against that same issue, showing real mitigation strategies you can use in your own projects. This triplet of "explain it, use it, fix it" ensures the learning sinks in way stronger than passive reading.
Another piece that sets Web Goat apart is how safe and self-contained it is. It's designed to run locally, often in a Docker container, so that none of your experiments risk exposing real systems. There's even a companion app, Webwolf, that simulates how an attacker might act, so you can observe both sides of the interaction without anything leaving your system.
Also, its lessons are mapped directly to well-known web security standards, for example, OWASP Top 10. So, what you're learning is immediately relevant and up-to-date. Web Goat is also unique in its continual evolution. Recent updates have streamlined setup, improved performance, and integrated more lessons. For example, they've simplified dependencies, made Docker setup tighter, and improved how lessons are stored and served. Because of that, it's accessible even to those just getting started, but still full of depth for more advanced learners.
In short, Web Goat isn't just about knowing vulnerabilities. It's about actually doing them, seeing how they function, and learning how to block them all in a safe place. That makes it a powerful tool for anyone wanting real practical web security understanding.
Project number six, Times FM. Google's pre-trained time series foundation model. Times FM is a forecasting model trained by Google Research on over 100 billion real-world time series points. And what makes it stand out is its ability to deliver strong predictions out-of-the-box, even on data it has never seen before.
One of the biggest advantages of Times FM is that it works zero-shot. That means you can feed a new univariate time series, just a sequence of past values, and the model can predict future values without needing to retrain or fine-tune specifically for that dataset. This makes it fast to start, avoids heavy retraining, and makes forecasting accessible across domains like weather, finance, traffic, demand, etc.
Despite its powerful capability, Times FM is relatively efficient. It has about 200 million parameters, which is much less than many large models. Yet, its forecasting performance frequently comes close to state-of-the-art models that are trained specifically on each forecasting task. It supports long input histories, context lengths up to 512 past time steps, and its forecasts can stretch far ahead, variable horizon lengths, adapting to both short-horizon and long-horizon predictions.
Another thing that's pretty special is how generalized its training was. It's been exposed to many domains of time series data, different frequencies, patterns, seasonalities, trends. So, it's better at handling varied real data without overfitting to one specific use case.
Lastly, Times FM is available in community tools. You can find its open checkpoint on Hugging Face, and it's integrated into Google Cloud, BigQuery ML, so you can plug it into forecasting workflows without building everything from scratch.
What makes Times FM unique is exactly this mix: massive pre-training scale, zero-shot forecasting, efficiency, and versatility. It brings powerful forecasting to new datasets immediately without you having to reinvent the wheel every time.
Project number seven, Lazy Vim. A powerful yet lightweight Neovim setup that works out-of-the-box. Lazy Vim shines by hitting that perfect balance between a polished, ready-to-use development editor environment and full freedom to make it your own.
What makes it unique is that it turns Neovim into something close to what people expect from an IDE without overwhelming complexity. It comes with sane defaults for options, file watchers, key mappings, auto commands, and a curated set of plugins already configured and ready so you can start working right away instead of spending hours setting up basics.
But at the same time, Lazy Vim is built to be easily extended. It uses a lazy-loading plugin manager under the hood. So many features and plugins only load when you need them. That keeps it fast. Your editor starts quickly and the runtime stays smooth even as you add more tools.
Also, it exposes configuration surfaces so you can customize things like your color scheme, icons, and UI behavior without having to hack or rewrite large parts. The UI experience is also standout. Fancy buffer/tab lines, icons by file, a clean status line showing diagnostics, Git info, etc. All of this is visually polished and coherent from day one. So even someone who isn't deeply familiar with Neovim looks at it and feels confident.
Another big strength is the documentation and community around it. There are guides, tips, recipes, and extras that help you set up what you want without having to reverse-engineer everything. And because it's opinionated but not rigid, you can remove or replace parts you don't like, tweak behavior, change plugins, and still retain the structure and benefits of the system.
In short, what sets Lazy Vim apart is how it gives you something that just works, looks great, is fast, and at the same time remains flexible. It's ideal for someone who wants an advanced setup without constant struggle, but also doesn't want to feel locked in.
Project number eight, Redoc. Powerful, beautiful API reference for every developer. Redoc is a tool that turns your API definitions like OpenAPI or Swagger files into documentation that's not just usable but clean, interactive, and easy to explore.
What makes Redoc special is its focus on readability, navigation, and keeping things responsive so developers and users can understand complex APIs without getting lost. One of the standout features is Redoc's three-panel layout. On the left, you have navigation and search. In the middle, the main documentation content, and on the right, live examples of requests and responses. This setup helps users skim or deep-dive as needed.
It's not just static text. Schemas are clearly rendered, even if they're deeply nested, and users can follow links directly to specific properties or sections. Deep linking, so nothing feels buried. Another unique thing, Redoc supports multiple API specification formats: OpenAPI versions 3.0 and 3.1, Swagger 2.0. It integrates features that smooth out the documentation process like organizing related endpoints under tags, grouping logically, handling examples, and supporting complex schema constructs such as "oneOf" or "allOf" in a way that stays comprehensible.
Users also get interactive features: "Try it" consoles to test API calls, mock server support for simulating endpoints, automatically generated code samples for multiple languages, and improved UX for large specs. On top of that, Redoc makes theme customization practical with options for font styles, color themes, branding, and flexible configuration for how the docs show up. So docs don't just work well, they also look great and fit with the rest of your product.
All these things together: clarity, responsiveness, interactivity, support for complexity, and visual polish make Redoc more than just a documentation tool. It's a guide that helps people understand APIs fast and use them confidently.
Project number nine, MCP GraphQL, letting large language models tap into any GraphQL API. MCP GraphQL makes it possible for language models to see and use GraphQL APIs in a dynamic, safer, and standardized way.
What sets this tool apart is that it doesn't force developers or agents to manually code every endpoint or every data structure. Instead, it provides schema introspection so an AI can discover what data types, queries, and fields are available in a GraphQL service and also lets it execute those queries automatically, all without prior configuration for each API.
Another strong feature is its thoughtful attention to safety. By default, mutations (operations that change or delete data) are disabled. That means when you're letting an AI explore and pull data, there's much less risk of unintended modifications or security lapses. If you do want to allow mutations, it must be explicitly enabled. Also, you can provide custom headers and use local schema files, which gives additional control over authentication and over which version of the schema the agent interacts with.
Simplicity is also highly generic and flexible. It works with any GraphQL API as long as you provide the endpoint. It auto-discovers its introspection of the schema so models can dynamically adjust. If there's a schema file locally or hosted somewhere, it can use that too. This makes it extremely adaptable when integrating varied data sources.
The combination of dynamic discovery, safe defaults, and flexible configuration is what makes MCP-GraphQL stand out. It bridges the gap between "I want my AI to ask questions of my API" and "my AI knows what my data looks like, what it can fetch, and doesn't break anything by accident." If your setup has multiple GraphQL services or you want agents to tap into external schemas without risking integrity, this tool delivers that ability. It's powerful for experiments but built with awareness of real-world safety and control.
Project number 10, Ripple, the elegant TypeScript UI framework that blends React, Solid, and Svelte. Ripple stands out because it brings together the best ideas from React, Solid, and Svelte into a single framework while putting TypeScript first at its core. It doesn't force you into pre-existing patterns. Instead, it lets you work in modern ways with strong typing, reactive state, and familiar component structure, all without feeling like you're fighting the tool.
What's unique about Ripple is its reactive system using track and reactive syntax. Changes in data propagate automatically and efficiently. So, updates are fast, precise, and beautifully minimal in what gets rerendered. You get fine-grained reactivity just when you need it, not whole component redraws with every small change. That leads to better performance and less wasted effort.
Components in Ripple feel very clean. They use their own module format with a `.ripple` extension, support props and children, and allow JSX-like templates mixed with TypeScript. This gives expressive power without sacrificing type safety or developer experience. Because it embraces TypeScript so deeply, you get better tool support: auto-client diagnostics, editor integrations, making the development flow smoother and more reliable.
Another standout feature is its modern take on templating. You can use control flow like conditional display and loops, iterate reactive collections, arrays, sets, maps with built-in helpers, and it handles shared state context cleanly across component trees. Styles can live inside components and are scoped, which helps in keeping design consistent and modular.
Ripple is still early and rough around the edges. There are to-dos and missing big features like server-side rendering. But that rawness also means its design is experimental in good ways. It's exploring what future UI frameworks might look like by combining reactivity, declarative syntax, and TypeScript-first principles.
Ripple earns attention because it doesn't just rehash old ideas. It mixes strong typing, reactivity, modular components, and performance into a package that feels fresh. For anyone curious about the next generation of UI tools, this is one to watch closely.
That concludes our deep dive into these 10 groundbreaking open-source projects. We covered everything from building secure financial standards for AI agents using AP2 to mastering web security by exploiting flaws safely in Webgoat. We saw how Tongi Deep Research handles tasks over long horizons and how Times FM, Google's foundation model, offers zero-shot time series predictions.
If you are looking for a fast, customizable Neovim experience, Lazy Vim provides a powerful setup right out of the box. Whether you are documenting complex APIs with Redoc's clear three-panel layout or enabling LLMs to use GraphQL safely via MCP GraphQL, these tools are redefining development.
If you found a new resource for your stack, hit like and subscribe for more deep dives.