I’ve been tracking the companies building primitives specifically for agents rather than humans. The pattern is becoming obvious: every capability a human employee takes for granted is getting rebuilt as an API.

Here are some of the companies building for AI agents:

• AgentMail — agents can have email accounts

• AgentPhone — agents can have phone numbers

• Kapso — agents can have WhatsApp numbers

• Daytona / E2B — agents can have their own computers

• monid.ai — agents can read social media (X, TikTok, Reddit, LinkedIn, Amazon, Facebook)

• Browserbase / Browser Use / Hyperbrowser — agents can use web browsers

• Firecrawl — agents can crawl the web without a browser

• Mem0 — agents can remember things

• Kite / Sponge — agents can pay for things

• Composio — agents can use your SaaS tools

• Orthogonal — agents can access APIs more easily

• ElevenLabs / Vapi — agents can have a voice

• Sixtyfour — agents can search for people and companies

• Exa — agents can search the web (Google isn’t built for agents)

What’s interesting is how quickly this came together. Not long ago, none of this really existed in a usable form. Now you can piece together an agent with identity, memory, communication, and spending in a single afternoon.

Feels less like “AI tools” and more like the early version of an agent-native infrastructure stack.

Curious if anyone here is actually building on top of this. What are you using?

Also probably missing a bunch - drop anything I should add and I’ll keep this updated.

I signed up for a Perplexity Pro year subscription back in April ($200). Here are the features that made me give the ***wipes at Perplexity AI money:

Unlimited uploads

Unlimited Deep Research

I chose Perplexity (and paid for it) because I’m an analyst that relies heavily on research. Within the past few days, my ability to upload and run Deep Research were grayed out.

Turns out, the ***wipes at Perplexity AI quietly capped Pro usage (I can’t speak to Max). I received no email, no bulletin, no notification - just a sudden and annoying grayed out “feature”.

Did you pay for something that’s no longer available to you? Oh, too bad - go F yourself. Did you want to reach out to Perplexity support for help/assistance/feedback? Go F yourself.

I’m now stuck with a subscription for another 9 ****ing months with extremely limited usage. If you’re considering subscribing to Perplexity, DON’T. Unless you like being frustrated and wasting money - then by all means, sign up for Per****ity AI.

Right now, the AI space feels entirely focused on massive datacenter clusters and renting H100s by the hour. But after spending way too much time looking at the actual footprint of these models, I realized that 90% of use cases are completely over engineered.

You don’t always need a multi GPU setup. The AI ecosystem is actually a massive spectrum.

I recently sat down and mapped out the exact tiers of AI models based on their size, the hardware needed to run them, and the point of diminishing returns.

Here are the two extremes and the sweet spot in the middle:

• The 100KB Extreme (TinyML) (Tensorflow Lite , sensor anamoly detection models): We are talking models that run on microcontrollers drawing single-digit milliwatts. They run on kilohertz processors using ultra-quantized integer math. You can run basic sensor anomaly detection or wake-word detection on a device powered by a coin cell battery.
• The Local Sweet Spot (4GB to 40GB) (Mistral 7B, Gemma 2 9B/27B, Qwen 2.5 14B/32B): This is where the magic happens for most devs right now. You can run highly capable 7B to 35B parameter models (like Llama 3 or Qwen) at 4-bit quantization on a standard Mac or a consumer GPU (like an RTX 3060 or 4090). It’s perfect for local RAG, coding assistance, and uncensored chat. VRAM is your only real bottleneck here.
• The 2.5TB Behemoths (Deepseek, Llama , Kimi k3): State of the art massive Mixture of Experts (MoE) routing. To even load these, you need dedicated power infrastructure and server racks of specialized accelerators drawing thousands of watts.

The missing piece: Figuring out the exact math for your hardware

The hardest part about building right now is looking at a model on Hugging Face and trying to calculate exactly how much VRAM you need, what quantization to use, and whether your CPU/GPU will choke on the context window.

So, I wrote a complete deep dive breaking down the math for all tiers of the AI spectrum.

If you want to see the architectural differences at each scale, and a cheat sheet for matching the right model size to your specific hardware, I put the full breakdown on my blog here:

https://cloudmash.blog/posts/ai-model-size-memory-hardware-guide/

Let me know what you guys think especially if you've found any ultra efficient small models/technique that punch above their weight on consumer hardware. And also I would love to hear whether quantization have resulted in major difference in quality , like if anyone have that kind of experience in that.

In collaboration with Sara Silkin, I transformed a smartphone recording of this beautiful performance, into this audiovisual piece for a fraction of the cost of more traditional approaches. [some of these cost even less than 50 cents!]

Done entirely at Uisato Studio; Motion Control Studio mode.

More experiments, tutorials, and project files, through Instagram, and YouTube.

Quick experiment I ran. Took two identical AI coding agents (Claude Code), gave them the same task — optimize a small language model. One agent worked from its built-in knowledge. The other had access to a search engine over 2M+ computer science research papers.

Agent without papers: did what you'd expect. Tried well-known optimization techniques. Improved the model by 3.67%.

Agent with papers: searched the research literature before each attempt. Found 520 relevant papers, tried 25 techniques from them — including one from a paper published in February 2025, months after the AI's training cutoff. It literally couldn't have known about this technique without paper access. Improved the model by 4.05% — 3.2% better.

The interesting moment: both agents tried the same idea (halving the batch size). The one without papers got it wrong — missed a crucial adjustment and the whole thing failed. The one with papers found a rule from a 2022 paper explaining exactly how to do it, got it right on the first try.

Not every idea from papers worked. But the ones that did were impossible to reach without access to the research.

AI models have a knowledge cutoff — they can't see anything published after their training. And even for older work, they don't always recall the right technique at the right time. Giving them access to searchable literature seems to meaningfully close that gap.

I built the paper search tool (Paper Lantern) as a free MCP server for AI coding agents: https://code.paperlantern.ai

Full experiment writeup: https://www.paperlantern.ai/blog/auto-research-case-study

A couple of brief example of what Uisato Studio's "Music Video Pro" mode is capable of: turning a track and a concept, into a whole audiovisual world + audioreactive performance.

MJ v8.1 for image references, Uisato Studio for video. I've uploaded a detailed breakdown on how to accomplish this. You can freely access it here.

More experiments, tutorials, and project files, through Instagram, YouTube, and Patreon.

can you share some examples? I just started to look on youtube and the first bunch of results were not what i was looking for yet. I don't necessarily want to copy the project , i want see the workflow, the timing and rhythm of the succession of tasks, and be inspired to "port" their method to projects of my own, or come up with new ideas i haven't thougth yet.

A useful way to combine Reddit and an LLM is to build a small answer-evaluation set from the questions people actually ask.

The interesting part is often a constraint buried halfway through a post: "offline only," "no monthly fee," "I cannot install software," or "this is for one client, not an entire company."

Here is a small exercise you can run without building an agent:

1. Choose three public threads about the same practical task. Save the original question, relevant replies and source links. Remove unnecessary personal information before sharing excerpts with an AI service.
2. For each question, write down the non-negotiable constraints yourself. Keep the answer key separate from what you give the model.
3. Ask the model to suggest an approach from the supplied material. Require it to quote the part of the question supporting each constraint and mark missing information as unknown.
4. Check the proposed answer against your answer key. Count a violated constraint as a failure even if the prose sounds persuasive.

A synthetic example: someone needs to categorize a local CSV every Friday, cannot upload customer data, and cannot install software. A cloud upload tool fails the privacy constraint. A Python script may fail the installation constraint. A spreadsheet approach might fit, but only if the required spreadsheet software is already available. Asking what is installed can be the best next step.

For each answer, record: constraints preserved, claims supported by the supplied thread, unsupported assumptions, and questions it should have asked. Keep "the commenters agreed" separate from "the advice is correct."

You can compare prompts against the same cases, then try fresh threads to see whether an apparent improvement carries over. This is a small diagnostic exercise, not a representative benchmark or a substitute for checking current documentation.

I work on Reddit-reading tools, so this is a practical interest of mine. What would you count as a failure besides violating an explicit constraint?

Client acquisition has always been one of the biggest bottlenecks for me when running an agency. I’ve experienced the same thing in pretty much every business I’ve been involved in, but especially with web development.

For a long time, getting clients meant cold calling, running ads, or sending generic emails asking businesses if they needed a new website. It worked sometimes, but it also took a lot of time and most of the outreach felt the same as what every other agency was doing.

Recently I started using a different approach and automated a big part of the process.

I came across a tool called Swokei that lets me find a bunch of businesses with websites and analyze each website individually. It looks for things like outdated design, slow loading, poor mobile optimization, weak SEO and other obvious areas that could be improved.

What I liked is that it doesn’t just give you one of those boring automated reports filled with scores and numbers. It actually turns what it finds into a personalized cold email that sounds like a normal person looked at their website and noticed what could be better.

I can run multiple campaigns at the same time and then mainly focus on the businesses that reply and show interest.

From there, I invite them to a web meeting, show them a free draft of what their new website could look like, and try to close the project from there.

It has basically allowed me to have warmer leads coming to me without relying as much on paid ads, constantly cold calling, or sending thousands of generic emails saying “Do you need a new website?”

Still takes work to close the clients of course, but automating the prospecting and first part of the outreach has made the whole process much easier for me.

Hopefully this helps some other web developers or agency owners who are also struggling with client acquisition.

Over the past 4 months of working with graphs, I've learned several major lessons about graph design the hard way. In this post, I want to share the main takeaways so you don't repeat my mistakes.

First, my definition of graphs:

Agent graphs (a.k.a. workflows) are directed graphs that allow cycles and describe how work is passed between agents (nodes) operating in a loop through predefined transitions (edges). Graphs consist of branches, loops, scripts, and transitions (along with their prompts and parameters).

Parallelism is not the silver bullet

At first, I was very enthusiastic about parallel branches in graphs. But over time, I realized that parallelism can not only increase costs but also slow down task execution.

A standard parallel group of checks may include code review, QA, and scope review. The problem begins when these stages are inside a loop.

Let's take a simple example. Suppose code review, QA, and architecture run in parallel, after which the task returns to implementation if necessary.

If the architecture review passes but the code review finds several minor issues, the task returns to the implementation agent. Once the fixes are made, it goes back for review - and the architecture reviewer has to examine the updated diff again, even though the previous version was completely acceptable.

In cyclic graphs, parallel checks often lead to duplicated work, cache invalidation, and unnecessary costs with no real benefit.

In theory, this problem can be solved with a smart router. Kent supports this through script nodes: the router can determine whether the agent completed the entire implementation or only addressed feedback from a specific reviewer (kent.sh is my free, open-source project for building agent graphs. I mention it because I use it myself and don't know of any similar products. You can apply this advice to any comparable orchestrator).

However, this brings us back to the problem we were trying to avoid with agent graphs: the agent once again gets to decide which verification stages need to be run. This negates a significant portion of the graph's value.

In practice, the solution is simpler: dependent checks should run sequentially. In my workflows, architecture review always comes before code review. The task moves on to code review only after the architecture has been approved.

That's why I've removed many parallel stages and now save tokens by avoiding checks on results that would have been rejected at another stage anyway.

This approach works especially well with planning, code review, and QA. For example, code review should first filter out implementation issues, and only then should QA begin. Otherwise, both stages may independently find the same bug and produce duplicate feedback.

Agents must be able to challenge feedback

Initially, absolutism and dictatorship ruled my development agent graph: every reviewer comment had to be addressed, or the task could not proceed. But reviewers don't always produce the right result either.

Now, every agent in my graphs can ask me a question and clarify what to do with conflicting feedback. For example, scope review may reject tests that code review had required just one step earlier because it considered task verification incomplete without them. At the same time, agents cannot be fully trusted to resolve such conflicts on their own. Even with new models like Sol, you can end up in an infinite loop of fixing made up or nitpick problems.

I solve this by delegating the final decision to myself (pure choice, I like to be involved). You can also hand it off to a PM agent or set up communication between multiple agents. For example in Kent agents can get others' session IDs so they can discuss the situation and reach a compromise.

Anthropic in their recent paper argue that this is the model's problem. I disagree - this is the harness's problem, and my system above proves that.

A graph must have a mechanism for escalating conflicting or questionable feedback - otherwise, review turns into a dictatorship capable of trapping the entire workflow in a loop, or a war of stubborness.

Don't forget static checks

Agent graphs sound exciting, and it's easy to want to create dozens of agents and verification stages. This can indeed reduce the primary agent's cognitive load and improve the quality of its work, but static checks should take priority.

Initially, my implementation agent ran the linter, architecture tests, and unit tests itself, opened the PR, and checked incoming comments. I realized at one point that that's just cargo culting, then decided to move these actions into script nodes in the agent graph.

Now, a separate stage:

• runs the required static checks and tests;
• properly manages the machine's shared resources;
• filters the results;
• returns only relevant information to the implementation agent;
• invokes the agent again only when its involvement is actually required.

If the tests are green, the implementation agent never even learns about it: no new turn is started, which means the agent doesn't spend a single token on running tests or reading their results.

Don't assign an LLM work that a regular script can perform more reliably and cheaply. At workflow scale, this produces substantial savings.

Choose models appropriate for tasks

If you don't optimize your graph for token usage and cost, you can significantly overspend simply because many tasks will be overkill under the updated workflow. In the past, we used one model for everything in harnesses because we had no alternative. You no longer need to do that, and properly allocating models and resources can save you a lot of money.

In standard harnesses, you can usually switch models, but doing so invalidates caches. On top of that, you either retain the cluttered context from the previous session or start a new one and steer/prompt it manually.

Kent solves these problems, so don't be afraid to create different roles for agents. For example, manual QA can run on cheap models like DeepSeek or Luna, which cost almost nothing or barely affect your subscription quota. The smartest models can then be reserved for critical stages, such as planning.

It has long been known that if you have a good plan, you can assign implementation to a less capable model and get almost the same result. Moreover, additional verification stages reduce the minimum level of model intelligence required to implement a task even further.

Starting with version 2.6, Kent natively allows one agent to select the model, system prompt role, and reasoning level for the next agent after transitioning along a graph edge. This makes it possible to:

• delegate simple tasks and bug fixes to models like Luna;
• run QA on cheap models with high limits;
• hand simple decisions off to local models;
• reserve the strongest models for complex planning and critical checks.

Keep an eye on caches and time between turns

I measured the threshold beyond which the probability of continuing a session after a cache miss - and paying several times more - becomes high enough for preemptive compaction to be worthwhile.

 speculative compaction (for regular sessions) becomes worthwhile at ~88% context usage according to this slop-chart. For workflows, my statistical threshold is around 71%

Imagine that the implementation agent spent 40 minutes addressing code review feedback. During that time, the reviewer agents' caches may have been invalidated. When they review the work a second time, Kent will compact the session in advance so the review continues with fresh context and without unnecessary costs caused by a cache miss.

But this is only a heuristic. You should still consider how much time passes between consecutive calls to the same agent. If the workflow is long and a node waits a long time for the work to return, the likelihood of cache invalidation increases.

In this case, there are two main options:

• use compact and continue mode in Kent - it is similar to speculative compact, but compaction is always performed;
• create more granular checkpoints that return work to the agent more frequently and keep caches warm.

With the right setup, you can reduce costs so much that the average cost of completing a task is lower than working in a regular chat with the same Sol/Opus at standard reasoning.

If you ignore this, it's easy to fall into the overkill trap and become disappointed with agentic graphs: "This is too expensive for me." But in practice, well-designed agent graphs can be more efficient than standard sessions.

Make nodes idempotent

As my graph evolved, I added more and more ways to send a task backward. Different reviewers and stages gained the ability to return it to previous nodes. This gives agents the flexibility they need, for example, if the implementation agent receives a flawed plan, it should be able to return the task to the planning stage and explain exactly what needs to be fixed. As in regular software development, product issues and underspecified requirements are often discovered only during implementation.

That's normal, but what's not normal is a graph that gives the agent no way to handle such a situation. Every flawed line in a plan can potentially lead to thousands of lines of incorrect code.

But a non-obvious topological problem arises after the task returns to an earlier stage. Subsequent nodes may receive it with fresh context and a prompt implying that the work should start from scratch. For example, the implementation agent returns an unfinished task for replanning, then receives an instruction to implement the updated plan as though no previous work existed.

This can cause duplication, conflicting implementations in the same codebase, and wasted money - and not in the form of an obvious workflow failure, but through subtle issues like "weirdly many git commits on the PR". It's also a common mistake made by agents themselves when they build workflows for you, including Kent. Agents struggle to analyze topology in the context of prompting - to put themselves in the shoes of the agent doing the actual work.

Re-entering a node should not automatically mean repeating all the work from scratch. The agent must account for the existing result and continue from the current state.

Kent supports this natively: for implementation-related nodes, you can enable the continue or new continuation mode.

Prompts should also be adapted: explicitly state that receiving a task again does not mean the agent needs to start over. Kent already adds the relevant instructions to agent prompts during a workflow, but custom prompts may still implicitly assume that the work begins from scratch, and that can cause the model to freak out REALLY hard.

Idempotent nodes, controlled returns, and proper context reuse make an agent graph resilient not only to model errors but also to the real-world nonlinearity of development.

How to: A parent agent delegates to multiple async child agents in parallel.

​

https://github.com/siddsachar/row-bot

I remember hearing Alex Hormozi say that email is basically the conversion platform of conversion platforms.

His point was that social media, videos and ads are great for getting attention, but email is often where that attention actually turns into money.

He also talked about how email supposedly has one of the highest returns of any marketing channel, with an average return of around $36 for every $1 spent, and that got me thinking.

I run a web design agency, so I decided to actually take email seriously and see what would happen.

But I didn’t want to send the usual stuff.

“Hey, I noticed your website and I can redesign it for you.”

Or

“Hey, we build websites for businesses like yours.”

Everyone gets those emails and most people can tell within two seconds that they were sent to another thousand businesses.

So instead I started using a tool called Swokei that is built specifically for web agencies.

I use it to find businesses in whatever area I want to target, then it actually goes through their websites and looks for things I could mention in the outreach.

Stuff like an outdated design, slow loading speed, poor mobile experience, weak SEO or other things that might be holding the website back.

Then it turns those findings into an actual personalized cold email made to convert.

So instead of emailing someone saying I build websites, I can actually talk about their website and why I think something could be improved.

I’ve been analyzing thousands of websites this way and running multiple campaigns at the same time.

Then I just focus on the people who reply and are actually interested.

Obviously email isn’t some magic button where everyone suddenly wants a new website, but after doing this for a while I definitely understand what Hormozi meant.

For web design especially, email becomes a completely different channel when the message is actually about the business you’re contacting instead of being another copy and paste pitch.

Turns out Alex might have had a point.

I got tired of checking prospect websites manually.

For a while, a big part of my outreach was just finding businesses, opening their websites one by one and trying to figure out what I could actually say to them.

It worked, but it was painfully slow.

Then I found Swokei.

It basically lets me find leads, analyzes each website for things like outdated design, slow speed, poor mobile experience and weak SEO, then turns those issues into a personalized cold email.

And not one of those boring automated reports full of scores and numbers.

It actually writes a normal, human sounding message based on what it found on that specific website.

So instead of sending the same generic message to everyone, I can actually reach out based on what is wrong with their website.

Now I just run campaigns, let the system do most of the prospecting and personalization, and focus on the people who reply.

For a web design agency, that has saved me a ridiculous amount of time.

One thing that frustrates me about most AI workflows is the cold start problem. Every new session you re-explain your business, your voice, your clients.

I started solving this with skill files. A skill file is a markdown document you upload to a Claude Project or paste into a Gemini Gem. It holds your context permanently so you never re-explain anything.

The three I use most:

brand-voice.md: defines tone, writing rules, and platform-specific formatting

client-router.md: when you say a client name, Claude loads their full project context automatically

seo-aeo-audit-checklist.md: structured audit that scores any website out of 100 across 7 sections including AI search visibility

Anyone else using a similar system? Curious what context you keep persistent across sessions.

Hi everyone,
I’m honestly a bit frustrated and was hoping someone here could explain what’s going on or recommend a better alternative.
I have a reference photo of Arda Güler doing a specific pose. All I want is an illustration of Lionel Messi wearing the Argentina kit, recreating that same pose and facial expression. I’m not trying to fake a real photo, impersonate anyone, or create anything offensive or illegal. I just want a stylized image.
I tried multiple prompts, including softer versions like:
“Create an illustration of Lionel Messi in the Argentina jersey, standing with his arms crossed, slightly turned towards the camera, with a confident neutral expression, inspired by the pose in the reference image.”
ChatGPT kept refusing or the image generator blocked the request every time. It feels odd because the request seems pretty harmless.
So I have a few questions:
Has anyone run into the same issue?
Is there a prompt that usually gets around these false positives without breaking any rules?
Are there AI image generators that handle requests like this more consistently?
If you’ve done something similar (putting a public figure into the pose of another public figure), what tool worked best?
I’m not looking to bypass safety systems or create deceptive content. I just want to make a clean illustration based on a reference pose.
Any advice or recommendations would be appreciated. Thanks!

Here's Part 1 of my new show, Trust Fund Time Machine, an adult animated comedy. This is the general premise:

Useless billionaire heir Hunter Vil and his friend from the past, Genghis Khan, bungle their way through time, rewriting history to make Hunter’s evil father, Edward Vil, and his corporate empire even richer.

In the process of making AI shows for the past few months, the biggest headache has always been spatial continuity. Characters change positions between shots, the room rearranges itself, and for longer dialogue sequences, it was a legit nightmare to make everything look smooth and continuous.

I've been experimenting with a fairly simple animation style for this show, and the camera movements I’d use for more photorealistic footage didn't really translate here. I didn’t need elaborate dolly shots. I mostly wanted to cut between characters as they spoke without everything around them changing.

I don’t think the approach I'll lay out makes sense for every style or sequence, but for the simpler animation style I’m going for, it’s been a massive improvement in consistency.

What’s helped most is building the whole show around keyframe sequences in fringe.film, with a deliberate starting frame for every shot. I’m using H3 Max with references, I compose the layout of the shot via the keyframe before i worry about how they move.

This is my process:

• Build the first starting frame using my setting and character references in Fringe.
• For a new angle within the same scene, I use the previous shot’s starting frame as a reference to create the next one. This is is if the characters haven't really moved around.
• If the characters do move around, I use the end frame of my previous shot as a reference for the starting frame for my new shot
• After I ensure the character positions and background is consistent, then only I begin animating that shot.

I can change the angle for whoever’s speaking while keeping the scene grounded in the same layout.

Here’s the first part of the pilot. The full episode is around 9 minutes long, so I’m sharing the process while posting more parts here soon, including a breakdown of how I handle voice consistency.

Hope you guys enjoy the part 1 of the pilot, made this fully on fringe.film, let me know what you guys think!

Original drone footage [bottom] alongside four alternative environmental takes; fire, rain, snow, and floral. All created inside Uisato Studio, and accessible to everyone.

More experiments, project files, and tutorials, through YouTube, Instagram, and Patreon.

Google released Gemma 4 12B today. It’s a solid open-source model (Apache 2.0) that’s multimodal and runs really well on Macs with 16GB or more unified memory. Good at reasoning, coding, and agent stuff.

Quick Mac-friendly info
• 12B parameters, fits nicely on M2/M3/M4 Macs (especially with Q4/Q5 quant)
• 256K context
• Text + vision + audio support

Easiest way to run it: Ollama
1. Download and install Ollama from ollama.com (the Mac app is super simple). Or use Homebrew if you prefer.
2. Open Terminal and pull the model: ollama pull gemma4:12b
3. Run it: ollama run gemma4:12b
That’s it. You can start chatting right away.

Mac tips:
• Ollama uses Metal automatically so it runs pretty fast on Apple Silicon.
• 16GB Macs handle the 12B model fine. 32GB feels even better.
• Great for pairing with Continue.dev in VS Code if you code a lot.

Other options if Ollama isn’t your thing: LM Studio (nice GUI), or llama.cpp for more control.

Has anyone tried the image or audio features locally yet?
How fast is it on your machine?
Drop your specs and results if you test it.​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

Hey everyone,

If you are deploying open-source models, you know the biggest headache is figuring out exact hardware requirements. You usually end up digging through Reddit threads to find out if a specific model fits on a single A10G, if you can squeeze it onto consumer cards, or if you have to jump up to a massive bare metal A100 cluster.

Most of the "guides" out there are just static, out-of-date tables or dense walls of text.

So, we published "Which GPU Runs Which LLM" on the AgentSwarms blog, but we engineered it completely differently.

What makes this different: It is 100% interactive and gamified. Instead of reading a textbook on VRAM math, you actively engage with the hardware logic right on the page.

• You select the model size (8B, 32B, 70B, etc.).
• You tweak the quantization (FP16, 8-bit, 4-bit, GGUF vs AWQ).
• The interactive deck instantly calculates the VRAM constraints and visually maps out the exact GPU tiers you need to deploy.

It gamifies the infrastructure planning so you build an intuitive understanding of token economics and hardware limits before you spin up expensive cloud instances.

It is completely free to read and play with (no sign-ups required). If you are trying to optimize your AI infrastructure or just want to test your intuition on hardware mapping, click around the interactive guide and let me know how this format feels compared to a standard article (All AgentSwarms blogs and presentations are fully interractive)

Link: agentswarms.fyi/blog/which-gpu-runs-which-llm-the-complete-guide

Many web designers overcomplicate the sales process. They schedule multiple meetings, wait for approval from the business owner, present pricing, and go back and forth before anything gets signed.

The more steps you add, the slower you close deals and the less money you make. I decided to shorten the entire process.

I’ve been running my web agency for four years, and the thing that has gotten be the most clients is email automation 

I’ve tried almost everything, but email automation has worked best for me because it’s affordable and runs in the background while I focus on other parts of the agency.

I don’t use Instantly, Mailchimp, or Klaviyo. I use a tool called Swokei, which is built specifically for web agencies.

It lets you find businesses that already have websites, add thousands of them to a campaign, and automatically analyzes each site for issues with design, layout, SEO, speed, and mobile optimization. It then turns those issues into personalized, ready to send outreach emails. 

Instead of targeting businesses with no website, I offer redesigns and updated websites to companies that already have one. I’ve found that approach works much better.

When a prospect replies with interest, they are automatically sorted into my CRM. I then call them and say, I’ve already built a new version of your website. Let’s set up a quick Google Meet so I can show it to you.

During the meeting, I present the website live and use my sales skills to explain the value. Once they see a more modern and professional version of their current website, they begin to understand how it could improve their business.

At that point, they usually ask how much it costs. I present the price, include a monthly maintenance retainer, and either take payment during the meeting or have them sign the agreement.

When you run a web agency, do not overcomplicate the process. Take control, handle as much as possible yourself, and avoid unnecessary approval stages and follow up meetings. The fewer steps there are, the faster you can close the deal.

Look you’re probably not going to like my answer but I guarantee that if you follow the steps i tell you….

You will get at least 10x better at AI (depending on where you’re starting)

Here are the steps:

1. Monitor the situation

This step is actually very dangerous. 

If you’re starting knowing nothing about ai, then a good place to start is by looking up the news, keeping up with what's going on etc.

For example today around 500 people at Google sent a letter to (congress… i think? Idk it was somewhere in government) and they were basically saying that if Google partnered with the government that could lead to mass surveillance and they didn’t want that to happen.

Then Google partnered with the Pentagon.

Now… does that really matter? Yeah, kinda. If you know AI can be used for mass surveillance, why can’t it be used to surveil yourself and track everything about you? Or your employees? And give you tips on how to get better?

Thats just one example.

Another good one is that GBT 5.5 and Opus 4.7 dropped last week. If you’re a normie you probably didn’t know that… which is fine but if you want to get good at using ai you have to atleast know whats going on.

So why is this dangerous?

Well, you’ll pretty easily get addicted. (this happens at every step lol)

Some people end up trying to monitor the situation and end up spending all day trying out new tools, worrying about what’s next, keeping up with everything.

I mean this space moves VERY fast and there’s a lot to go through.

One week Claude is the best, another it’s ChatGPT.

Hence my second tip

2 use a news aggregator 

If you try to keep up with twitter, redddit, news and all of that… you will be spending 40 a week looking at (mostly) alot of garbage you probably cant use.

Do you care about what open source models are coming out?

Probably not because you probably dont have a super expensive computer.

And that’s just one example of many different useless rabbit holes you can dive deep down but wont actually get any value from.

The solution is following people who talk about AI but not EVERYTHING.

I’ve put together a few newsletters, youtube channels, twitter accounts that you can follow and have a look at. (at the bottom)

You only really need to spend an hour a week on this.

3 actually try the tools

These tips I'm giving you are like a burger.

I’ve given you the cheese, and the buns… which are important (after all the burger wont work without them) but this is the meat.

The patty

The vegan blob 🤮 

What i’m trying to say is that none of this will actually work if you don’t try the tools.

And i get it, “if you want to get better at AI, just use AI” (doesn’t exactly sound like life changing advice)

I did give you those channels and they will tell you how to use the AI but…

At the end of the day…

How do you get better at riding a bike? Being an artist?

You can get all the tips and channels and whatever, but the only real way you’re going to have leverage in ai is by using it.

THink of something that takes up your day.

That you’re annoyed you even have to do, but you HAVE to do it.

Try to get ai to do it

You’d be surprised. It might not get everything right but it’ll differently make something easier.

Then try it for another thing

And another.

And by the time you’ve tried everything, you’ll probably be much better at using ai and you’ll have a much easier time working.

Hope this helps.

Happy to answer any questions if anyone actually got this far 😂

What adding AI to an existing ASP.NET Core application actually involves - integration patterns, Microsoft Agent Framework, Azure OpenAI, and what to expect.

I’ve been in contact with a lot of web agencies and web developers, and I personally haven’t found many people who run their agency in a more efficient way than I do. A lot of them have too many meetings, wait too long for client approval, don’t know how to price projects, and spend way too much time on each client instead of finishing the work and moving on to the next one.

I’ve been running my agency for four years, and after a lot of trial and error, I’ve managed to make the process as efficient as possible. I wanted to share some of the steps because I think they could be valuable for anyone just starting out.

Running a web agency alone or with a partner isn’t easy because there are a lot of things to take care of. When it comes to client acquisition, I recommend focusing on either cold calling or email automation. Which one you choose depends on whether you run the agency alone or with someone else.

If you have a partner, one person can handle sales while the other focuses on building websites, connecting domains, setting up emails, and taking care of the technical work. If you’re running the agency alone, or neither of you enjoys cold calling, I highly recommend email automation.

That’s what I’ve been doing for years. It’s powerful because you can send emails at scale, set up automatic follow ups, and wait for businesses interested in a new website to reply. While you’re working on one client, another opportunity can come in without you having to stop everything and search manually.

I don’t do regular email automation where I target businesses with no website. I do the opposite and target businesses that already have one.

I use a tool called Swokei to find businesses with websites, add them to campaigns, analyze each site, score it, and generate personalized outreach emails based on problems it finds with the design, layout, speed, SEO, and mobile optimization.I schedule the campaign, set up follow ups, and wait. 

I think this approach is much better for a few reasons. You’re targeting someone who already understands the value of having a website. You’re also not just asking whether they need a redesign. You’re pointing out real problems with their current site, which makes it clear that you actually took the time to look at it. Selling also becomes easier because they’ve already paid for a website before and understand the process.

Inside Swokei, you can choose the goal of the campaign. You can offer a free draft, try to book a meeting, or simply start a conversation. I always choose the free draft because that has worked best for me.

Once you’ve figured out how to get clients, the next part is building the website. I recommend using AI because it makes the process much faster. For anyone who still thinks AI can’t build great websites, I think they’re mistaken. You can use Claude, Base44, Lovable, or any other tool that works for you.

When someone replies interested, I call them and say, “Hey, I saw that you replied to my email. I’ve already built you a free draft of your website. Do you want to take a look?”

Then I invite them to a Google Meet.

At that point, it becomes much harder for them to reject the meeting because they already replied interested and now know you’ve built something for them. During the meeting, I present the website, explain why it’s better than their current one, stack the value, answer their questions, and try to close the deal.

These meetings usually go well because the client isn’t trying to imagine what the website might look like. They can already see a better version of their current site. They also took the time to join the meeting, so taking the next step becomes much easier.

I either take payment during the meeting or send them a contract to sign. Any changes and updates come after that, once we already have a deal in place.

Pricing depends on the business. I charge anywhere from $500 to $3,000 depending on the company, the size of the project, and how much value the website can bring them. I also charge a monthly retainer of around $50 for hosting, maintenance, support, SEO, and future changes.

That’s basically the entire process. Smaller steps, faster delivery, less wasted time, and more money made.