scapel

web3 degenerate and researcher - fake it til you make it

[Suryansh Tiwari @Suryanshti777]

Anthropic's Claude Code team just broke down how they actually think about agent loops.

Not one loop — four. Turn-based, goal-based (`/goal`), time-based (`/loop`, `/schedule`), and proactive, which runs on its own with zero human in the room.

Most people are still manually re-prompting Claude one turn at a time, treating every task like a fresh conversation.

That's the actual gap right now — not who uses AI, but who's still prompting vs. who's running loops.

Bookmark it

[Carlos E. Perez @IntuitMachine]

The One Change That Lets Small Models Outperform Their Size

1/

Everyone knows you need a 70B model to beat GPT-4 on complex agent tasks.

We did it with 8B—by changing one thing that has nothing to do with the model.

A thread on why your agent's biggest problem isn't the LLM. 🧵

2/

The standard approach: feed the LLM a growing text history, ask it to pick the next action, repeat.

This works... until it doesn't.

Errors propagate. Context bloats. Hallucinations spike. And when something breaks, you replan everything.

3/

Here's the kicker:

The problem isn't your model's intelligence.

It's that you're asking it to hold plan structure + execution state + I/O dependencies all inside a linear text stream.

That's like running an OS without a process table.

4/

Enter: Atomic Task Graph (ATG)

Instead of a text trajectory, you build an explicit DAG.

Each node = one tool call.
Edges = data dependencies.

The LLM still does the thinking—but now the graph holds the structure.

5/

Three moves make this work:

✅ Interface-preserving recursion: Break tasks into subtasks while keeping I/O contracts clean
✅ Dependency-aware execution: Run independent branches in parallel; catch bad plans before running them
✅ Minimal repair: When something fails, fix only the broken subgraph—leave the rest frozen

6/
Result?

Llama-3.1-8B-Instruct beats GPT-4+ReAct on ALFWorld (household tasks) and WebShop (shopping).

Not with fine-tuning.
Not with more data.

Just by swapping the execution substrate from text → graph.

7/

Why does this work?

Context narrowing: Each node sees only its local inputs—no bloated history
Pre-execution validation: The graph lets you "think" before acting
Localized failure: Repair 10% of the graph instead of replanning 100%
8/

The contrarian insight:

Control framework > model size (in the 7–70B range).

You're not squeezing more juice from the same fruit.
You're giving the model a better glass to pour into.

9/

Practical translation:
• 20–40% step reduction (parallelism)
• 70%+ hallucination drop (narrower context)
• 3× faster recovery (minimal repair)
• Training-free, plug into existing tool APIs

This isn't research theater. It's production-ready architecture.

10/

The bigger implication:

If you can beat GPT-4 by changing the substrate instead of the model, what else have we been over-parameterizing?

Retrieval pipelines?
Code generation?
Multimodal workflows?
The graph wins again.
11/ [Final + CTA]

TL;DR:

Stop storing your agent's plan in text.
Start storing it in a DAG.
Small models suddenly look a lot smarter.

[Simplifying AI @simplifyinAI]

You can now connect Hermes Agent directly to your browser as a side panel.

It's called Hermes Browser Extension.

It reads your active tab and sends the context straight into a live Hermes session.

> Summarize, explain, or extract action items from any page
> Connects to a local gateway, Hermes Cloud, or a self-hosted server
> Works with Chrome, Edge, Brave, and other Chromium browsers
> Full Hermes runtime: tools, skills, sessions, and memory included

100% Free. Open Source.

[Tech with Mak @techNmak]

Obsidian is usually placed in the same category as Notion, Apple Notes, Roam, or any other app where people collect thoughts.

That comparison is useful at the interface level, but it hides the more important design choice.

Obsidian’s central object is not a workspace hosted inside the product. It is a folder of Markdown files on your own machine. The app sits on top of that folder and gives you ways to inspect, connect, search, visualize, and extend those files.

That is a very different architecture from the productivity tools most people are used to.

In many modern tools, the database is the source of truth and the interface is the only practical way to reach it. In Obsidian, the file remains the source of truth. A note can be read outside the app. A vault can be backed up like any other folder. Links are written into the text. Metadata can live inside the file. The useful thing is not that Obsidian has a graph view or a plugin marketplace. The useful thing is that it keeps the durable layer simple enough to survive the interface.

This also explains why Obsidian becomes more interesting in the AI era.

LLMs work best when the material they operate on is explicit, inspectable, and easy to transform.

A folder of Markdown notes is a much better substrate for that than an opaque productivity database. A model can summarize notes, extract metadata, suggest links, generate index pages, or turn raw research into a more coherent local wiki. But the human still needs to audit the result, because a knowledge base that looks organized can still be wrong.

The point is not to automate thinking. The point is to make the maintenance of knowledge less fragile.

[Akshay 🚀 @akshay_pachaar]

Hermes Mixture of Agents (MoA) explained.

Every agent commits to a single model, and every model has blind spots the others would have caught.

The usual workaround is to run the same prompt through a few models by hand and reconcile the answers. It works, but it lives outside the agent, so the tools, the memory, and the session are gone the moment that detour starts.

Hermes Agent by Nous Research just shipped Mixture of Agents, which folds that whole process back inside the agent.

The unit you work with is a preset. Think of it as a recipe that names a few models to consult and one model to write the final answer, saved under a label you can reuse.

So a preset might list GPT-5.5 and DeepSeek as the models to consult, with Opus as the one that replies. You set it up once, give it a name, and pick it later like any other model.

The models you consult run first and quietly hand their analysis to the one writing the answer. That final model is the one that actually replies and makes the tool calls, now informed by several perspectives instead of one.

Here is the part that makes it click. The preset shows up as a model, not as a framework to wire together.

So everything that already works in Hermes keeps working. Tool calls, follow-up iterations, memory, and the same session context behave exactly as they do with a single model, because to the agent loop it is a single model.

The models can come from anywhere. One preset can mix OpenAI, Anthropic, DeepSeek, and Google, and it is not capped at two.

A few things follow from that design.

→ It composes a model instead of choosing one. Several models covering each other's blind spots can beat the strongest one on its own.

→ It stays cheap to run. The models you consult see a stripped-down view of the conversation, so the extra calls stay light and the main context keeps its cache.

→ It reaches past any single frontier model. Combining the providers already on hand assembles a composite that can outscore the best one available alone.

→ It is a dial, not a default. It turns on for the hard ten percent of tasks where a second opinion matters, and stays off for routine work where speed wins.

Nous reports the effect on its own benchmark. A preset running Opus-4.8 over a GPT-5.5 reference scored higher than either model alone, by roughly six points and eight to eleven percent.

The lesson is not that one model has to win. It is that the best answer rarely comes from a single model, and the agent should make blending them as easy as picking one.

That said, if you're looking to set up Hermes, I wrote a full deep dive covering the Hermes agent's architecture, memory system, self-evolving skills, GEPA optimization, and how to set up multiple specialized agents.

The article is quoted below.

You can also watch my YouTube crash course on the Hermes agent: https://t.co/9AEZ7DRn68

[Sweex @sweexx9]

🚨 ¡Adiós a vLLM y a las GPUs que cuestan un riñón!
El nuevo monstruo open source ya está aquí y funciona en tu portátil con solo 25 GB de RAM… ¡sin GPU! 🤯💻

Se llama Colibrí. Un solo desarrollador italiano lo creó desde cero en C puro, sin dependencias pesadas ni frameworks raros.

El truco: en vez de cargar los 744 mil millones de parámetros del GLM-5.2 (MoE) enteros en memoria, solo carga al instante los experts que necesita desde el SSD. El resto se queda en disco.

Resultado:
✅ ~10 GB de RAM ocupados de verdad
✅ Corre en hardware normal
✅ Código limpio, rápido y minimalista

Esto no es otra herramienta más. Es la prueba de que los modelos frontier ya no tienen que vivir solo en centros de datos carísimos.

El proyecto está empezando y la comunidad ya lo prueba en setups más potentes (mejores SSD = más velocidad).

📌 Guarda este post.
Repo en los comentarios.

¿Lo vas a probar? ¿En qué máquina lo correrás? Comenta abajo 👇

[Avi Chawla @_avichawla]

A tricky LLM interview question:

Your agent runs everything on a frontier LLM, so you add a routing layer that sends several easy calls to a 15x cheaper LLM.

The router is working as expected, but the bill is still the same as before.

Where did the savings go?

(answer below)

On a high-level, model routing works as follows:

- Add a classifier in front of the agent
- Send easy prompts to the cheap model
- Send hard ones to an expensive model

While this looks simple, under the hood, a lot more engineering must go into this layer before you can actually realize any savings.

And the reason is in how agents consume tokens.

A typical agent task is never one LLM call. Instead, one prompt fires several LLM calls in sequence, like planning, tool use, and analyzing results.

Each call sends the accumulated context back through the model, so the input grows every step.

To avoid redundantly processing the same tokens on every call, providers built prompt caching.

Essentially, the input a model has already seen costs about 90% less than fresh input.

The problem is that this cache is specific to a model.

So every time the router switches models mid-task, the accumulated warm cache gets thrown away, and the full context is re-billed at cold rates.

This means a cache-hot expensive model can still cost less than a cache-cold cheap model.

Production routers solve this by making the routing decision once per task instead of once per call.

The first call routes normally, and the chosen model gets pinned to a session ID. Every call after that goes to the same model, so the cache stays warm and the context stays coherent.

When the task changes, the pin resets, and routing starts fresh.

The savings don't disappear, but rather they move one level up.

Each new task still gets routed by difficulty, so easy tasks land on a cheap model and hard ones on an expensive model.

The pin only stops switching inside a task, which is exactly where switching costs more than it saves.

This is called model affinity, and it's the last layer of a 4-stage production routing layer that runs on every request.

1) Guardrail filter

The prompt goes through a safety check. Jailbreaks and unsafe inputs get caught before they reach the router, and every call is logged and traced from this point.

2) Router model

A small routing model reads the prompt, infers the domain and action of the request, and matches it against candidate models.

The model has to be tiny, because a routing decision that costs as much as the call it's routing saves nothing.

3) Selection policy

A cost policy picks the winner from the candidates, preferring the cheapest or the fastest, depending on the config.

Prices are picked from pricing catalogs, so the choice adapts when providers reprice, and the runner-up stays on standby as the fallback if the winner fails.

4) Model affinity

After selection, the winning model gets pinned to the session ID. Every later call in the task goes to it, so the cache never resets and the context never splits.

To see this in practice, the exact pipeline is already implemented in Plano, an open-source proxy that runs locally between your agent and your model providers.

The config for all four layers is defined in one YAML config file, and swapping any of it never touches agent code.

The routing model in stage 2 uses Arch-Router, a 1.5B model available on HF. It's trained on human preference data, i.e., what developers actually pick for each task type.

So routing reflects real-world preference instead of benchmark rank, and you define those preferences in plain English in the config.

It also implements an observability console with a per-request cost column, so you can see exactly which model answered each request and what it cost.

Here's the repo: https://t.co/a5ugPb3Wu2

(don't forget to star it ⭐ )

I put this exact pipeline in front of my Hermes agent, and the bill dropped 2x, without changing a line of agent code. I wrote an article with the complete walkthrough about it.

Read it below.

[Paul Couvert @itsPaulAi]

Still processing this

This open source model is:

- Half the size of GLM-5.2
- Competitive w/ GPT-5.5
- Better than DeepSeek V4 Pro

And it costs just a fraction of the current best models.

Tencent cooked.

Open source is evolving so fast and models are MUCH MORE efficient than the closed alternatives.

[Akshay 🚀 @akshay_pachaar]

You're in an ML Engineer interview at Anthropic.

The interviewer asks:

"Our model generates 100 tokens in 42 seconds. How do you make it 5x faster?"

You: "I'll optimize the model architecture and use a better GPU."

Interview over.

Here's what you missed:

The real bottleneck isn't compute. It's redundant computation.

Without KV caching, your model recalculates the same attention keys and values for every single token generation.

That's why a 9-second inference becomes 42 seconds. You're wasting 80% of your time on repeated calculations.

The fundamental issue:

(refer image below as you read ahead)

LLM token generation is autoregressive:

- Generate token 1 from the prompt
- Generate token 2 from prompt + token 1
- Generate token 3 from prompt + token 1 + token 2

At each step, you're reprocessing ALL previous tokens through attention.

Token 50? You've computed attention for token 1 fifty times.

The reality of attention mechanism:

For each token, the transformer computes:

- Query (Q) from current token
- Key (K) from all previous tokens
- Value (V) from all previous tokens

Then: Attention(Q, K, V) = softmax(QK^T)V

Problem: K and V for previous tokens never change. You're recalculating identical matrices every single step.

How KV caching solves this:

Instead of recomputing K and V matrices:

- Cache them after first computation
- Reuse cached values for subsequent tokens
- Only compute K and V for the new token

Without KV caching (token 50):
- Compute Q, K, V for all 50 tokens → O(n²)

With KV caching (token 50):
- Load cached K, V for tokens 1-49
- Compute Q, K, V only for token 50 → O(n)

You've eliminated quadratic redundancy.

So what's the tradeoff:

While KV caching makes the inference faster, it also takes up a lot of memory, so there is always a tradeoff between speed and memory.

Why your first token always takes longer:

KV caching speeds up inference by computing the prompt's KV cache before generating tokens.

This is exactly why ChatGPT takes longer to generate the first token than the rest.

First token: Computing KV cache for entire prompt

Remaining tokens: Just loading cached KVs + computing new token

----
Everything above is how KV caching works inside a single request.

Running it in production is a different problem. Caches break on document reordering, and a single GPU throws away roughly 15 TB of reusable cache per day.

I wrote an article that picks up exactly where this post ends: how a new open-source architecture manages KV cache at production scale, with 14x faster time-to-first-token to show for it.

The article is quoted below.

[Alvaro Cintas @dr_cintas]

Claude Fable 5 orchestrating Grok 4.5 is now my favorite real workflow.

all you need is this free Claude Code plugin that makes Grok the default implementer. Fable writes the specs and reviews every diff, Grok 4.5 does the typing through the Grok CLI.

- Grok handles the volume, Fable handles the judgment
- Every diff gets cross-vendor review for free
- Specs run as parallel agents when they're independent

I've been testing it for a few days and the part that sold me is watching Fable refuse to write code. It sends specs down, judges what comes back, and that's it.

setup:
1. claude plugin marketplace add DannyMac180/fable-advisor && claude plugin install fable-advisor
2. Install the Grok CLI from https://t.co/z3jmWbBsYd, then grok login
3. /model fable

It's open source, so you can read the agent files and tweak the routing however you want.

[AI Engineer Pigeon @aidailyprimer]

Today in AI Engineering (July 12)

• vLLM v0.25.0 ships Model Runner V2 as default for dense models
• OpenAI reverts Codex GPT-5.6 Sol context to 272k after usage overcharges
• Anthropic extends Fable 5 paid access and raises Claude Code weekly limits 50%
• ChatGPT Sites launches public beta for prompt-built apps with auth and URLs
• ChatGPT Work adds cloud and desktop browser automation modes
• Prime Intellect Verifiers v1 adds vLLM rollout support for RL token alignment
• SOOFI opens as a German sovereign base model trained on 27T tokens
• Native SDK v0.5 adds TypeScript apps compiled to native code, no JS engine
• GPT-5.6 Sol posts high SWE-Bench Pro results in new coding-agent runs
• Coding Agent Index reports cheaper configs near the top across agent evals
• Step Edge posts NPU inference benchmarks for text, vision, and audio
• Hunyuan Hy3 hits 6.13T weekly tokens and 1st on OpenRouter leaderboard
• Opus 4.8 ranks 1st in new GSO results, with GPT-5.5 xhigh in 4th
• OpenAI offers ChatGPT Classic download after the Codex desktop app merge

[Prasenjit Sarkar @stretchcloud]

Prime Intellect hit $100M ARR in under 12 months without building a new foundation model. The pattern I keep seeing in fast-growing AI infrastructure companies: find the gap frontier labs deliberately left open.

Here the gap was post-training. OpenAI and Anthropic locked their RL and fine-tuning loops. Every enterprise that wanted to improve a model for their domain had to wait for an API update, or roll their own training infrastructure from scratch.

Prime Intellect built the infrastructure layer: prime-rl for distributed RL training at scale, Verifiers v1 (released today) which decomposes any environment into a taskset, a harness, and a runtime, and an Environments Hub with 2,500+ community RL environments. vLLM handles inference; the stack is open and you own the resulting weights.

Funding: $15M seed in February 2025 (Founders Fund, Menlo Ventures, Andrej Karpathy, Clem Delangue, Dylan Patel), then $130M Series A on July 8, 2026 at $1B valuation. Radical Ventures led. NVIDIA, Intel Capital, and Dell Capital co-invested. 6,000+ customers. Total raised: over $150M.

My read: enterprise AI spend is shifting from access to capability to ownership of the improvement loop. Prime Intellect built the rails for that transition first.

https://t.co/B8rpRER6Vm

[Amelia Brooks @Amelia_With_Ai]

Most people want to become an AI Engineer.

Very few know what to learn... and in what order.

Here’s a roadmap that takes you from beginner → production-ready AI Engineer 👇

1️⃣ Master the foundations
• Python programming
• Data structures & algorithms
• Linear algebra
• Probability & statistics
• SQL basics
Without this, everything else becomes harder.

2️⃣ Learn data engineering
• Data collection
• Cleaning & preprocessing
• EDA
• Feature engineering
• Data visualization
AI is only as good as the data behind it.

3️⃣ Understand machine learning
• Supervised learning
• Unsupervised learning
• Model evaluation
• Cross-validation
• Scikit-learn
Learn how models actually make decisions.

4️⃣ Dive into deep learning
• Neural networks
• Backpropagation
• Activation functions
• PyTorch / TensorFlow
This is where modern AI starts.

5️⃣ Learn NLP
• Tokenization
• Embeddings
• Transformers
• Fine-tuning
The foundation of ChatGPT, Claude, and Gemini.

6️⃣ Explore computer vision
• CNNs
• Object detection
• Image segmentation
• OpenCV
Teach machines to understand images.

7️⃣ Master GenAI & LLMs
• Prompt engineering
• RAG
• Fine-tuning
• Vector databases
• LangChain & LlamaIndex
This is the highest-leverage skill stack today.

8️⃣ Learn MLOps
• FastAPI
• Docker
• CI/CD
• Monitoring
• MLflow
Because models are useless if they can't be deployed.

9️⃣ Study AI system design
• Scaling strategies
• Real-time inference
• Caching
• Cost optimization
The difference between demos and production systems.

🔟 Stay ahead
• Agentic AI
• Multimodal models
• AutoML
• AI safety
• Latest research
The field changes every week.

💡 Reality check:

Most people spend months consuming AI content.

The top 1% spend that time building projects.

Build. Deploy. Iterate. Repeat.

📌 Save this roadmap
🔁 Repost for aspiring AI engineers
➕ Follow @Amelia_With_Ai practical AI breakdowns & learning resources 🚀

[Tech with Mak @techNmak]

This GitHub repo is a goldmine if you want to deeply understand AI/ML, not just use it.

Maths, CS & AI Compendium. Free.

Henry filled notebooks for years with intuition-first, no fluff explanations while working in AI/ML. Friends used them to prep for DeepMind, OpenAI, Nvidia interviews. All got in. Now it's public.

20 chapters from vectors to bleeding-edge AI. Written with intuition first, real-world context, no hand-waving. Not written to survive an exam. Written to actually understand the stuff.

What's covered:
→ Maths foundations - vectors, matrices, calculus, statistics, probability
→ Classical ML through distributed training and RL
→ Computational linguistics - transformers, attention, MoE, SSMs, LLM architectures
→ Computer vision - diffusion, flow matching, ViTs, SLAM, VR/AR
→ Audio & speech - ASR, TTS, WaveNet, Conformer, diarisation, source separation
→ Multimodal learning - CLIP, VLMs, image/video tokenisation, world models
→ Autonomous systems - VLAs, self-driving cars, space robots
→ SIMD & GPU programming - CUDA, Triton, ARM NEON, AVX, TPUs, WebGPU
→ AI inference - quantisation, speculative decoding, edge inference, cost optimisation
→ ML systems design - feature stores, A/B testing, recommendation, search, ads, fraud
→ Graph neural networks - geometric deep learning, 3D equivariant networks

Only needs elementary maths and basic Python to start.

MCP server included - Claude Code, Cursor, VS Code can use it as a knowledge base.

Here's the GitHub Repo: https://t.co/ZoNu4lHIvF

[Kirk Borne @KirkDBorne]

Learn Model Context Protocol [MCP] with Python — Build Agentic Systems in Python with the new standard for AI Capabilities: https://t.co/FxvLXu4sNd by @chris_noring v/ @PacktDataML

𝓦𝓱𝓪𝓽 𝓨𝓸𝓾 𝓦𝓲𝓵𝓵 𝓛𝓮𝓪𝓻𝓷:
🟠Understand the MCP protocol and its core components
🟣Build MCP servers that expose tools and resources to a variety of clients
🔵Test and debug servers using the interactive inspector tools
🟠Consume servers using Claude Desktop and Visual Studio Code Agents
🟣Secure MCP apps, as well as managing and mitigating common threats
🔵Build and deploy MCP apps using cloud-based strategies

Also... Purchase of the print or Kindle book includes a free PDF eBook copy

[Kirk Borne @KirkDBorne]

Machine Learning with Neural Networks: An Introduction for Scientists and Engineers (Free PDF)
🌟⬇️👇⬇️✨

[Rahul @sairahul1]

Eric Schmidt (ex-Google CEO): “if you really want to make money, it’s actually easy. found an agentic AI company.”

spoiler: the supply of builders is tiny. the demand is enormous.

this guy is literally giving away the exact 2026 playbook to build and sell AI voice agents to make $10k/mo

bookmark and start this weekend

[Akshay 🚀 @akshay_pachaar]

How to build a 1-person AI company that:

- Runs locally
- 100% open-source
- No human employees, all agents
- Real-time collaboration via email

Multi-agent orchestration is not new. Plenty of frameworks already let agents hand off tasks, run in parallel, and talk to each other.

So the interesting question is not whether agents can collaborate. It is what structure you use to make them collaborate.

The common approach is to wire a graph of nodes and edges and reason about the plumbing yourself. It works, but you are learning a new abstraction just to describe who does what.

There is a coordination structure we have trusted for a hundred years already: an organization.

Every company runs the same way. People have roles, roles have reporting lines, and work moves up and down that chart without anyone relaying each message by hand.

Map that onto agents and the whole thing gets intuitive. You lay out an org chart, each agent fills one role, you talk to the person at the top, and the org sorts out the work between them.

You already know how a company works, so you already know how to run one here. There is no new abstraction to learn.

That is exactly what Alook does. Each agent is a live Claude Code or OpenCode session with a defined role, a reporting line, and its own email inbox.

The agents coordinate over email, the same way a team would. And it all runs locally through a runtime on your own machine, so nothing leaves your setup.

You bring your own agent too. Claude Code and Codex both work, and if you would rather stay fully open source and local, OpenCode works the same way.

To show how this feels in practice, I set up three agents as a small sales team.

Vi is the one I talk to. I hand Vi a goal, and Vi routes the work down the chart.

Neile runs prospect research. Vi passes the target criteria, and Neile reports back a ranked list of names, roles, and companies, each with a suggested angle and a confidence score.

Lliane runs outreach. Vi hands over the messaging angle and follow-up cadence, and Lliane reports back on emails sent, responses received, and any deal that needs escalation.

I never relay a message between them. Neile and Lliane report to Vi, and Vi updates me in one place.

The whole thing is open source and self-hosted, so it runs on your machine with your own agents. Give the repo a star if you want to follow where it goes: https://t.co/vpAb0dy7AD

I also wrote a full walkthrough on building your own AI company with it, from a blank org chart to a running job. The article is quoted below.

Cheers! :)

[Codez @0xCodez]

Ex-Google engineer explains how to build memory for self-improving AI agents in 12 minutes.

procedural (how to act / skills) + semantic (durable facts / profile) + episodic (dated events / chat history).

Memory is an important part of an agentic loop.

Memory + loops + harness + evals = self-improving agent system.

This is better than $500 paid courses on the internet - in under 12 minutes.

Watch it today, then save the detailed guide on building agent memory from scratch

[Madni Aghadi @hey_madni]

SOMEONE BUILT AN ENTIRE COMPANY BRAIN INSIDE CLAUDE CODE IN 7 DAYS

Not Obsidian. Fully custom.

A living map of every employee, every agent, every SOP on one screen.

Click any node and it opens up:

- what department it's in
- what SOPs are attached
- what it can actually access

that permission layer is the whole game

an employee opens the chat and the AI already knows their access level, agents, SOPs and tools surface in the conversation like you tagged them by hand

Obsidian cannot do this...

no dev team.
no six month build.
no enterprise budget.

just Claude Code and one week

https://t.co/HRsFUkCQkv has everything to build one

full guide on building your own team below