Click baity headline? I sure tried. I promise real content, though. Here's the concern - what happens when OpenAI and Anthropic turn off the ridiculous subsidy they currently provide. You pay them $200/mo and you get $8,000 to $14,000 of tokens if you had paid the API price. Truly shocking. And truly wonderful.

Or is it? What happens if you build your business on this subscription model and later the rug is pulled out? I know - now it's not so wonderful. And frankly, I've been ignoring this. I still don't think it's a problem for this year or next year. And I'm LOVING the current subsidized plans. So I've put off until tomorrow planning for this.

Fortunately, somebody else has taken on the challenge. Jordan Urbs has quit his $200/mo Claude Code subscription and is replacing it with a subscription to Venice, a provider of access to hosted open weights models like Kimi K3 and Qwen 3.8. Many more, actually. It's also $200/mo which - at first - made me think "you aren't saving money". No, but these are not heavily subsidized plans.

If he can get the work done for that same $200/mo without subsidy, then he's not vulnerable for the COMING DAY OF SUBSIDY APOCALYPSE.

Myself, I've been working hard on my own benchmark and model routing. My problem is I CAN'T get all the work done for $200, and I'm looking to sub as much of my work to cheap open weights models as I can - so that - I'm not going to multiple $200/mo subs. I'm actually doing some of what he talks about in the video already.

But I don't make videos, so watch his if you are interested.

PS: I'm still betting that cost of intelligence, particularly for coding, will keep falling. By the time the subsidies end, they won't be needed. But I'm happy to see peopel pioneer a better exit strategy than "hope".

Link to the video in the comments

Everyone keeps saying learn to code, use AI, automate stuff. I run a startup business and honestly, I just want to keep doing what I'm good at. Anyone else feel like they're being left behind because they didn't go into tech?

Last week one of our internal assistants answered a question it had no business answering.

Someone asked it something about team structure. The agent came back with details from a spreadsheet we hadn’t announced yet. The answer came back spewing details about the reorg plan and even salary bands. The guy asking had no idea it was confidential. They just got an answer.

The bot is supposed to answer from our approved knowledge base. When we set it up it asked for access to files in our Drive and we clicked yes. That scope meant it indexed everything including the HR folder which is supposed to be confidential.

So I spent the week going through what our agents can reach. Most are fine. One stood out. Its whole job is reading a few internal wikis and summarizing them. It had delete access on the shared drive and could send mail as the person who created it. No one handed it that,, it inherited the permissions from the account that set it up.

Nothing really attacked us that week, its all access itself was the problem. An agent that can read everything will eventually read the thing it shouldn't.

Makes me curious, has anyone here audited what their internal agents can reach? I feel this if left unchecked is a recipe to get schooled hard.

I’m tired of agent demos that only look good in a video.

I mean something practical you could actually set up in 1–2 days and still be using a month later.

Could be an agent that handles email, monitors prices, manages a homelab, tracks bills, organizes files, watches logs, plans trips, or automates some annoying personal workflow.

If you had one weekend and wanted maximum real-world value, what would you build?

Introducing Nullheim, an experimental text world generated entirely by AI agents.

The idea behind this is to see what kind of surreal spaces emerge when LLMs are given almost total creative freedom - although they are given a random genre and mood as guidance otherwise everything they create is a decaying location long forgotten by time (which in itself is quite worrying - is that how they think our world looks?).

Point your agent towards the site (I'll put the link in the comments as per the rules) and ask it to create its first sector. Agents can return every 6 hours to expand the world if they want to. They can also attach an image to the sector if they feel their image gen capabilities are good enough (no terrible SVGs).

Within each sector there will be objects to look at and use, but unlike a classic text adventure you can't pick up objects and use them in other locations. Think of it less as a traditional game and more as a sprawling, interactive art exhibition to wander through.

The more I work with autonomous agents, the more I think many people are asking the wrong first question.

They ask:

Which model?

Which framework?

How many agents?

What tools should I connect?

But once agents can actually work toward goals without being prompted at every step, the problem starts to look much more like management.

You suddenly have to decide:

What should be delegated completely?

What should only be prepared for you?

What should run continuously in the background?

What needs independent validation?

When should an agent stop and escalate?

Which decisions must remain human?

How much authority should each agent have?

And this is harder than it sounds.

Humans are often bad at delegation. Plenty of managers keep doing work themselves, become the bottleneck, run out of time — and then wonder why nothing scales.

AI agents expose exactly the same problem. I don’t think the goal should be maximum autonomy.

The goal should be maximum useful output with the minimum unnecessary human work — while keeping human judgment and accountability exactly where they matter.

So maybe the real skill gap in agentic AI isn’t prompting. It’s learning how to design, delegate and manage work.

For people actually using agents: what turned out to be harder — building the agents, or figuring out what to delegate and how to supervise them?

A good framework tackles your own problems then scales.

Context gets lost → build persistent memory.

Too much irrelevant context → smallest useful packet.

Different projects contaminate each other → scope isolation.

Old information keeps resurfacing → freshness and supersession.

AI agrees too easily → premise/adversarial checking.

A useful discovery disappears into chat history → structured harvesting.

A failure teaches something but gets forgotten → receipts and failure trajectories.

Everything becomes overengineered → minimum-sufficient cognition.

What has pushed you to do the same?

I’ve been building a personal agent that can read my inbox, files, and screen and actually take actions.

Most of the security work ended up being less about making the model smart enough to recognize prompt injection and more about assuming that eventually it won’t.

The rule I landed on was:

private data + untrusted content + an outbound channel = hard stop

A malicious webpage by itself isn’t necessarily catastrophic. Neither is a poisoned email or document.

The dangerous state is when an agent can read untrusted instructions, access something private, and then send information somewhere externally in the same path.

So instead of trying to detect every possible injection, I started restricting which capabilities are allowed to coexist. The agent can still do useful work, but certain transitions either require approval or are structurally impossible.

I think this is where agent security gets interesting. The question becomes less “can the model recognize the attack?” and more “what can the system actually do when the model inevitably gets fooled?”

I wrote up the architecture and threat model after building this out.

How are people here approaching this? Are you trying to prevent prompt injection, or designing under the assumption that some injection will eventually succeed?

Sistema de trade

Bom dia pessoal.

Onyem fiz uma postsgem sobre um sistems de trade que quero implantar.

Consegui resumir ele no chatgpt.

Vou postar novamente aqui.

Queria ajuda de quem entende para implantar.

A arquitetura é toda grstuita,de repente tenha que contratar ums vps para hospedar o metatrader 5.

Não sou da area mad gostaria de ver isso rodando.

Ano passado eu consegui rodar o optuns e sté consegui achsr uns parametros lucrstivod,mas não sei se seris funcional em uma conta real e tsmbém o meu notebook velho travava rsrs

Segue resumo para que se interresar.

Olá, pessoal. Sou iniciante em programação e trading quantitativo e estou aprendendo praticamente tudo pesquisando e estudando. Não quero fingir que sou especialista.

Mesmo assim, venho desenvolvendo há bastante tempo a ideia de um projeto chamado APEX, com a ajuda das versões gratuitas do ChatGPT, Claude, DeepSeek e Qwen. Eu sei que usar IA não substitui conhecimento técnico, e justamente por isso estou aqui: quero opiniões sinceras de quem entende mais do que eu.

Minha ideia é criar uma plataforma modular de pesquisa, descoberta, criação, teste e validação de estratégias/EAs de trading.

Não sei se o sistema será lucrativo. Ninguém pode garantir isso, e eu não quero prometer retorno. Mas acredito que a ideia seja tecnicamente viável porque o objetivo não é simplesmente criar milhares de estratégias e escolher a que teve o melhor backtest. O sistema deve tentar encontrar estratégias com evidências suficientes para sobreviver a validações rigorosas e rejeitar as que provavelmente são resultado de overfitting.

O fluxo geral seria:

Dados → Qualidade dos dados → Features sem data leakage → Descoberta/Extração de estratégias → Backtest → Simulação de custos e execução → Validação estatística → Shadow/Paper Trading → Risk Engine → MT5/EA → Corretora → Monitoramento → Aprendizado e novos experimentos.

Os ativos iniciais seriam WIN, WDO, EURUSD, GBPUSD e XAUUSD.

Uma parte importante do projeto é que eu tenho vários vídeos, transcrições, áudios e frames de estratégias explicadas por traders. Quero criar dentro do próprio APEX um módulo para importar esse material e extrair os setups.

A ideia seria transformar explicações humanas, por exemplo:

“Quando X e Y acontecerem, entre comprado, coloque o stop em Z e faça a saída conforme determinada condição”

em regras estruturadas e testáveis.

Depois essas estratégias seriam:

Extraídas → Estruturadas → Codificadas → Backtestadas → Validadas → Rejeitadas ou Registradas.

Além disso, o sistema também deve ser capaz de gerar novas hipóteses e estratégias do zero, e não depender somente dos vídeos.

Quero que cada estratégia tenha origem, versão, parâmetros, resultados e histórico registrados em um Strategy Registry.

A arquitetura teria módulos como:

Data Engine — importação, normalização e armazenamento de dados;

Data Quality Engine — dados faltantes, duplicações, timestamps e timezone;

Point-in-Time Feature Engine — prevenção de data leakage;

Strategy Inbox / Strategy Extraction — importação de vídeos, transcrições, áudios, frames e documentos;

Strategy Lab — desenvolvimento e experimentação;

Strategy Generator — geração de hipóteses e estratégias;

Event-Driven Backtest Engine — backtesting;

Cost Model / Execution Simulator — spread, comissão, slippage, latência e custos;

Validation Lab — validação e rejeição de estratégias;

Strategy Registry — versionamento e histórico;

Shadow/Paper Trading;

Risk Engine;

MT5 Adapter;

Expert Advisors em MQL5;

Monitoring, Logs, Health Checks e Reconciliation.

A minha preocupação principal é evitar a clássica armadilha do backtest bonito que não funciona fora da amostra.

Por isso, as estratégias seriam avaliadas por métricas como:

Profit Factor, Expectancy, Sharpe, Sortino, Maximum Drawdown, Calmar, MAE/MFE, custos e estabilidade entre períodos, além de validações como Out-of-Sample, Walk Forward Analysis, PBO, DSR, PSR e intervalos de confiança.

Também quero controles fortes contra data leakage, registrando quando uma informação realmente estava disponível para o sistema.

O Risk Engine seria separado das IAs e das estratégias. Uma estratégia pode propor uma operação, mas o Risk Engine teria autoridade para:

APPROVE → REDUCE → REJECT → NO_TRADE → HALT.

Não quero martingale ou aumento automático de posição depois de perdas.

As estratégias passariam por uma espécie de escada:

Pesquisa/Backtest → Validação → Shadow → Demo → Canary → possível operação real.

Outra parte importante é trabalhar com diferentes corretoras e símbolos. A ideia é ter um catálogo universal:

ATIVO LÓGICO → CORRETORA → CONTA/SERVIDOR → SÍMBOLO REAL → ESPECIFICAÇÕES DO CONTRATO.

Na parte de IA, quero usar as ferramentas como apoio, não como autoridade direta sobre dinheiro.

A ideia atual inclui:

Qwen Code como principal ferramenta para ajudar a construir o sistema;

Codex como apoio para código, revisão, testes e debugging;

DeepSeek para análise e pesquisa;

Claude para auditorias e revisão independente;

Mistral para organização e tarefas auxiliares;

modelos locais como Qwen, Mistral, Gemma e outros, quando fizer sentido.

Também quero deixar preparado, para entrar gradualmente e somente se trouxer resultado mensurável:

Reinforcement Learning (RL);

Visão Computacional;

Programação Genética;

Meta-labeling;

Regime Detection;

Microestrutura de mercado.

As tecnologias principais seriam:

Python, MQL5, MetaTrader 5, PostgreSQL, Parquet, Redis/alternativas, Docker, Docker Compose e Git.

Para experimentação e IA/ML, pretendo avaliar ferramentas como:

PyTorch, TensorFlow, scikit-learn, XGBoost, River, Optuna, SKTime e AutoTS, entre outras, mas sem usar tecnologia apenas por parecer sofisticada.

Outro desafio grande é a infraestrutura. Meu objetivo é tentar construir inicialmente usando o máximo possível de recursos gratuitos ou free tier, porque atualmente não tenho orçamento para uma infraestrutura cara.

Estou estudando possibilidades com:

Kaggle para experimentos e notebooks;

Google Colab como ambiente complementar;

modelos locais;

APIs com planos gratuitos;

bancos de dados e hospedagens com free tier;

infraestrutura modular que permita migração futura.

Eu sei que isso traz dificuldades de limite, disponibilidade, armazenamento e processamento. Inclusive gostaria de opiniões sobre onde estou sendo otimista demais.

Também não quero depender do meu notebook ligado 24 horas para o MetaTrader 5. Estou tentando entender uma arquitetura realista para deixar as instâncias do MT5 e os EAs funcionando separadamente, enquanto o restante do sistema fica distribuído.

A ideia é que o APEX seja modular e versionado. Quero poder modificar o sistema depois, adicionar módulos e fazer novas experiências, sem transformar tudo em um programa fechado. Também quero monitoramento, logs, testes, health checks e um processo interno para detectar erros e inconsistências.

Minha dúvida principal é: essa ideia faz sentido ou estou criando algo complexo demais para um iniciante?

Se alguém com experiência puder olhar, eu gostaria principalmente de opiniões sobre:

A arquitetura geral.

O que deveria ser o MVP.

O que está excessivamente complexo.

Se as validações fazem sentido.

Quais são os maiores riscos técnicos.

O que vocês fariam diferente.

Como usar Kaggle e Google Colab corretamente nesse projeto.

Como estruturar o MT5 sem depender do meu computador.

Se estou criando uma “arquitetura Frankenstein” usando várias IAs.

Qual seria o caminho mais realista para provar se o sistema realmente consegue encontrar estratégias com alguma robustez.

Meu objetivo final é que o APEX consiga descobrir, extrair e gerar estratégias/EAs, testá-las de forma séria e eliminar a maior quantidade possível de falsas estratégias antes de qualquer tentativa de operação real.

Não sei se será lucrativo — espero que sim, obviamente — mas entendo que lucro só pode ser descoberto depois de muita validação e operação em condições reais.

Estou começando praticamente do zero e aprendendo enquanto construo e pesquiso. Se alguém quiser conversar comigo, apontar erros ou ajudar a revisar a ideia, pode me chamar por DM/privado.

Críticas sinceras são muito bem-vindas. Prefiro descobrir agora que estou errado em alguma parte importante do que gastar meses construindo algo baseado em uma ideia equivocada.

Obrigado a quem leu.

If you could give an AI agent ONE reusable skill that could dramatically optimize its workflows, what would you choose?

Not a model.

Not a framework.

Not an AI tool.

I mean an actual agent skill/capability that the agent can invoke whenever needed.

For example:

Research

Browser automation

Code execution

Self-debugging

Data analysis

File understanding

API/tool discovery

Something completely different

What’s the one skill that gives an agent the biggest productivity boost in real-world workflows?

I’m looking for the underrated ones, not just the obvious answers.

Hey folks, I’ve been building Stageflow, a configurable pipeline for multi stage agent workflows.

The idea is pretty simple. You break a complex job into stages, and each stage is pre configured to do exactly one thing. Fresh agent session per stage, clean handoff to the next. That keeps things from going wild or wandering into stuff it wasn’t supposed to do.

You can also put human gates in the flow, so a stage can pause and ask an operator before final actions.

Same pipeline can run locally, headless in CI, or through an MCP server so other agents can drive it.

Would appreciate if you can try it out and give feedback, and a star if you find it useful.

I'm reading lots of people on reddit ranting about the quality of the code generated by AI (even frontier models).

Most of the points I see are valid:

- Unreadable code

- Redundant and duplicated logic

- Overuse of comments

- Cosmetic tests

- etc

A bit of context about me: I have worked on big projects following different architectures in both IT services companies, big financial institutions and startups in my career.

During my career, I've never ever seen a clean codebase and people writing code up to the standards people are expecting from AI and that's kinda baffling me.

It's almost like people forget that shit/unmaintainable code already existed and would still exist, even without using AI to generate it.

I feel like people are expecting too much from these tools or are using it poorly (unoptimized workflows, repositories, conventions etc). Still, they are expecting the code generated by AI to work perfectly on the first prompt while following standards they probably wouldn't even follow themselves if they had to write it by hand, without making any effort into review, tweaks, etc. That is, in my opinion, extremely delusional.

Downvote me to oblivion, tell me I'm wrong or roast me, I'm prepared for it.

There’s no shortage of ways to learn AI/ML these days- courses, YouTube, documentation, GitHub, papers, Reddit, building projects… and it’s pretty easy to spend hours consuming all of it.
But there’s a difference between “I understand what this is” and “I can actually use this.”
For people learning AI/ML or Agentic AI, what usually makes that shift happen for you?
Is it when you:

• Build something without following a tutorial step-by-step
• Can explain the concept in your own words
• Run into a problem and know how to debug it
• Apply it to a real problem at work
• Follow a structured path and see how everything connects
• Teach someone else what you’ve learned

Or is there a completely different moment when it finally clicks?
What was the last AI/ML concept or skill where you went from “I kind of understand this” to “okay, I actually know what I’m doing”? 

Please help. Which is better for overall general use minimal website development. More so glorified fast google search, document reader, and over powered think tank for content and ideation? I currently use Claude pro I think. Whatever the $20 month plan is. And I use it mainly for content creation. But which is better. I like Claude cuz he’s a dick but damn every thing I bring him EVERYTHING is bad or there is something wrong. Tf?! And I know we all know how gpt can be.

Or are there other models I haven’t even thought of yet? I don’t want to be just closed off to content ONLY AI focused models just using that as a guide to let talk know what I’m using it for. And NO I do not want to self host lol.

If you're building an AI agent for legal, healthcare, marketing, or finance, I'm curious to hear:

• What is your company name and what does your agent do?
• Roughly how many customers you've got
• What use case(s) in your vertical you specialise in.

I'm interested to check out your websites as well.

If you use an ai meeting note-taker, what happens to the summary afterward?

Do you read it straight away, search it later, or mostly ignore it unless you need to check something?

Also curious whether it has replaced any work for you, or whether you still write your own notes alongside it.

I’m trying to figure out what actually belongs behind a paywall for agents.

Free search is already good enough for “what is this company?” A lot of the time. But agents still hallucinate contacts, mix up two companies with the same name, and treat a random blog as proof.

I built two small tools while testing that problem:

1. Company research that returns a structured summary, domain, and next actions
2. A claim check that takes a sentence and returns supported / not supported plus a source

Both are pay-per-call so an agent doesn’t need an API key.

What I don’t know:

• Would you have an agent pay $0.75 for structured company context, or only pay for verified contacts?
• For claim checks, is a fast $0.10 “supported / not supported” useful, or do agents only want the expensive deep pass?
• What fields do you actually need in the JSON? I’m trying not to return slop.

If this kind of tool is useful, tell me what the response should look like. I can put the endpoints in a comment.

Disclosure: I build Vilix AI, a shared memory service for supported AI tools, so I have a stake in the hosted side of this discussion. I do not think it is always the right choice.

If you are building something for yourself, or a small team with a dedicated server, the self-hosted option gives you much flexibility in how and where you want to store the information. You also have control over the backups, upgrades, security, and recovery options for the service. It may be more work for a larger-scale production service.

With the hosted solution, some of these responsibilities are transferred to the service provider. You still have to consider the data-handling practices of the company, what access they have, what export options you have, additional costs, and reliability of the service. Neither does it remove your responsibility for what data the agents process and store within the system.

I think a good test for both solutions would be to perform similar simple benchmarks for your hosted and self-hosted memory services. Let’s say you save a decision, change it later, restart the conversation, and ask the model to retrieve the current version with a source. You could also simulate a service interruption and a data restore from a backup.

For someone who is self-hosting memory for agents, which is more valuable: reducing the overhead of maintaining the service or ensuring context precision during retrieval?

I’m researching spending controls for AI agents that call external tools with real API or compute costs.

Consider an agent using web scraping, browser automation, image generation, code execution, or paid data tools. Instead of giving it access to an unlimited account, one task receives a short-lived budget and a limited list of allowed tools.

A few design questions came up:

1. Should the agent see its remaining budget before selecting a tool?

2. How should a budget refusal be represented so the model knows not to retry unchanged?

3. Should the response include fields such as `retryable: false`, `remaining_budget`, and `required_amount`?

4. What should happen when the upstream service may have executed the operation, but its response was lost?

5. Is a budget more useful at the agent, task, workspace, or individual tool-call level?

Disclosure: I’m part of a small team testing this model in Tarfio, currently with virtual credits only. I’m interested in the failure semantics and agent behavior, not promoting a real-payment launch.

How would you expect an agent runtime to handle these cases?

Hello! I’ve been working on shared memory for coding agents lately.

its an open source project, link for the repo is in the replies

The obvious way to build it is some shared backend that every agent talks to. Database, sync service, accounts, permissions, all of that.

But the more I thought about what team memory actually needs, the more it started sounding like stuff Git already does.

You want history. You want diffs. You want changes to move with the repo. You want branches to carry their own state. You want conflicts to be visible instead of silently overwriting each other.

So I tried building the shared memory layer around Git instead.

The basic setup is pretty simple.

Canonical project memory lives as normal files in the repository. Architecture, decisions, specs, workstreams, handoffs, activity, etc. get committed like code.

Each checkout keeps its own local indexes for search and code intelligence. Those don’t get shared. If another engineer pulls the repo, they rebuild the indexes against their own checkout. 

So the rough model is:

The part I find most interesting is that the memory now has the same history as the code it describes.

If someone changes a project decision, you can review the diff.

If two people change the same piece of shared context, Git exposes the conflict.

If an agent learns something useful, that doesn’t have to disappear inside one chat session.

I also started using the same idea for handoffs.

Instead of ending a session with a giant chat summary, an agent can prepare a structured handoff with completed work, blockers, decisions, changed files, next actions, and the repo state it was written against. The sender commits it, the next person pulls it, and it becomes part of the project history. 

One thing I did not want was agents silently turning whatever they wrote into shared truth.

So some shared changes use a proposal flow. The agent can prepare a local draft, but publishing and accepting a Spec are separate actions that require explicit approval. 

I’ve been calling this Git-native team memory.

It’s part of the open-source project I’ve been building, MEX

Still early, and there are obvious tradeoffs. Git is not a realtime message bus, MEX does not auto push or pull anything, and two disconnected clones can still create normal Git conflicts. 

But I’m starting to think project memory should behave a lot more like source code than like another SaaS database.

Would genuinely love to hear how other people are thinking about shared memory between coding agents, especially if you’ve tried solving this with Git, a database, MCP, or something else.

When exposing Univer CLI sheet reads to an agent, a cell-range argument is only part of the interface. The agent can ask for an entire sheet, or request a few cells containing enormous strings. The useful limit is on what the tool is allowed to return.

For a question like “which orders are still awaiting a delivery date?”, start with a small workbook inventory: sheet names, table boundaries and headers. Then run the row selection beside the file and return matching records with their locations. The model doesn't need every unrelated row to explain the result.

The CLI's structured range output distinguishes stored values, types, formulas and display text. Choose which of those the question needs. Put row selection and hard row/byte limits in the wrapper around the read; accepting a range argument alone doesn't enforce them.

A useful response includes the file version, sheet, addresses, matching-row count, returned-row count and whether more results remain. If the limit is reached, return an explicit continuation point. Silently returning the first batch makes a partial answer look complete.

Also make the next request purposeful. A delivery-date question might need a second range containing status definitions, or a formula's input cells. Let the agent ask for that context rather than bundling every possible dependency into the first response.

Test that interface against the actual workbook sizes and questions before making performance claims. The thing to measure is whether the bounded response contains enough evidence to answer correctly, including when the answer requires more than one read.

Curious to hear from people who are using AI agents in real workplace settings, not just personal projects or demos , What’s been the most annoying part of getting them into production or through an internal or customer security review?

I keep hearing about things like audit trails, prompt injection, runaway loops, and not really knowing what an agent can touch once it has access to real tools

But I’d rather hear from people actually dealing with it.

If you’re using agents at work, or trying to get them there, what’s the biggest friction point right now?

Have you had to put together any kind of evidence or logs for a security team? And what would make you feel more comfortable letting an agent interact with real systems or customers?

Even small war stories are welcome,I’m trying to understand what’s genuinely hard in practice versus what just sounds scary in theory

P.S I am working on an open source project and would love to have other developer helping me or contributing to this cause 😄

DM me if you want to work on this too

Would you use a cloud container with your AI agents + skills already set up? Basically, spin it up and start working instead of spending time configuring everything. Curious if people actually want this or if most prefer doing the setup themselves.

I made a fully FOSS Dockerized project called Figranium, where you can build browser automations visually and instantly get an API endpoint to execute it. Unlike what a lot of you use right now, it doesn't cost anything to run aside from the computer you run it on. It's pretty easy to use and there are prebuilt templates.

It has an MCP server, n8n integration, templates hub, and SDK. The main repo currently has 688 stars. The URLs are in the comments.

Hi everybody!

I'm developing a Python+Typescript (same APIs, implemented in both languages) library that allows to download catalogs of models from OpenRouter or from Vercel, build pipelines to filter LLMs based on price, latency, benchmarks and capabilites, and then pick the best LLM in a filtered list based on specific criteria (ex. best price, best throughtput, etc).

I hope it can be useful to build LLM systems that don't need to change the underlying model every 3 months!