We recently swapped OUT Qwen3.6-35b-3a with Qwen 3.8-27b. This new 27b model is just so much more powerful and competes with frontier level coding. And we are throwing all of our compute directly at it.

If you havent heard of us, we’re taking a completely different approach--

• We will never token-bill you. There are no percentage bars draining to zero in an hour, no "credit multipliers". We run on straight queue-based concurrency tiers. You secure a slot, you use the slot.
• There's no token limits. We are NOT running A/B split tests on your accounts or psychologically tricking you into accepting lower usage limits disguised as "milestone resets." The throughput you get on day one is the exact throughput you keep.
• Strictly for code. This endpoint is entirely dedicated to coding and development workflows. Because of this focused context, we expect high cache hit rates across the board. This keeps the backend flying and latency incredibly low for everyone.

If anyone is tired of jumping between models just to conserve a percentage bar that changes every week, come check it out. Happy to answer any questions about how Qwen 3.8-27b handles specific languages or workflows below.

We have a user base of 500+ users and a very active disc. You can chat with us, or just ask questions below!

yolo-auto[(.)]com

Hey everyone,

I’ve been working on some backend upgrades at yolo-auto based on how people are actually using the API, and from direct feedback from users.

Since a lot of you are running heavy automation, agent loops, and mass data processing, we have a new queue-based pricing structure to handle concurrency better.

It's still flat-rate and completely unmetered, but you can now scale up your concurrent requests if you need more throughput. Plus, instead of throwing rate-limit errors when you hit your concurrency cap, the backend will now hold up to 20 additional requests in a queue and process them as soon as a slot opens up. This is a huge help when agent calls are fanning out with research.

Here are the new tiers:

• $6/mo - Solo Tier: 1 concurrent request. Unlimited tokens. 128k context window. Perfect for standard chatting and sequential scripts.
• $10/mo - Double Tier: 2 concurrent requests. Unlimited tokens. 128k context window. Recommended if you are doing mass data processing or running parallel agents and need some more speed.
• $15/mo - Quad Tier: 4 concurrent requests. Unlimited tokens. Upgraded 256k context window + Higher priority in the processing queue. Especially good and cheap for auto research -- stop busting your claude credits and sending all your data to people who train on your data or have extremely slow tps.

Quick reminder on the setup: It still uses the standard OpenAI format, so you just swap the base URL and plug your API key directly into your existing UI or automation pipelines. We never save prompts, so you have complete privacy. As soon as your prompt leaves the kv cache, its gone forever.

Come hang out in the Discord if you have any questions or want to see what people are building.

You can signup, find our discord, over at yolo-auto [dot] com !!

Growing discord of 250+, come chat if you'd like! 32b+ tokens served and almost 1 million requests handled in under 2 months, with big plans to grow out to more models soon.

Hey everyone, quick update. Due to people asking for it, crypto payments are now live. It's the exact same price, but I set it up so it doesn't auto-renew at the end of the month. Just pay once and use it.

If you haven't seen my posts before and are wondering what this is..... I host qwen3.6-35b-3a and sell flat-rate, unlimited access to it starting at $6 a month. No token billing, no daily request limits. It uses the standard openai format, so you just swap the base url and it plugs right into basically any UI, agent, or automation workflow you already use. Context window is 128k (goes up to 256k).

I built this mainly for people who do heavy inference and hate watching their API balances drain. I know "unlimited for $6" sounds a little fake, so if you're skeptical, come hang out in the discord (about 200 of us in there right now) and ask the active users yourself.

(And yeah, getting a lot of questions about other models—dsv4-flash is next on the roadmap for unlimited, just need a bit more time to get it running smoothly).

cheers yolo-auto [dot] com

Hello

I run yolo-auto, a cheap unlimited inference provider that runs qwen3.6-35b-3a.

Plans start at $6 a month for 128k context (goes up to 256k), no daily request cap, no token billing. It is OpenAI compatible.... meaning you can use it with any agent that supports that format (most do). Use it for automations, workflows, sub agents, and any tool that lets you plug into a LLM.

This is basically for people who want to run a lot of inference without constantly watching a token meter. We have a discord with 200+ members - please come chat with us if you are skeptical!

One common question we get: When are you adding other models? Our near-future plan is to add dsv4-flash - unlimited. But we're not quite there yet.

Thanks!

yolo-auto ((.)) com

Hello!

If you are just a hobbyist or running OpenClaw 24/7 on a VPS and heavily utilizing background cron tasks or HEARTBEAT.md checklist evaluations --- you’ve probably noticed how fast your Anthropic or OpenAI API keys bleed tokens.

Because OpenClaw passes systemic file contexts, historical logs, and skill metadata back and forth on every loop, a background agent pulling text from RSS feeds, triaging GitHub PR diffs, or monitoring server logs can cost $10–$20 a week if you are using the wrong model.

I spent the last week testing/optimizing my pipeline to separate high-logic reasoning from dumb muscle. Here is my workflow, the config setup, and the benchmarks on how to route structural ingestion to a flat-rate infrastructure fallback.

My setup is a mixture of gpt 5.5 , deepseek, and qwen3.6-35b-3a.

High-Volume Background Loops

When a heartbeat triggers, the agent loop evaluates files. If a skill requires it to scrape 20 pages of documentation or process raw server logs, you are sending millions of input tokens down a metered pipe.

You don’t need a frontier model with medical-board-passing logic to turn messy HTML into clean markdown, strip boilerplate, or categorize log errors. You just need healthy context capacity and a predictable billing shape.

The Strategy: Split-Model Routing

The fix is configuring OpenClaw to route background, text-heavy processing chores to a cheap, unmetered endpoint running a sparse Mixture of Experts (MoE) model like Qwen3.6-35B-A3B. Because it only fires ~3B active parameters per token, it is exceptionally fast at structural syntax parsing, while saving your premium keys for critical reasoning or user-facing executions.

Here is the security-hardened openclaw.json configuration structure to safely handle dual-provider routing over an external gateway:

JSON

{
  "models": {
    "default": {
      "provider": "anthropic",
      "model": "claude-3-7-sonnet-latest"
    },
    "structural_worker": {
      "provider": "openai",
      "baseURL": "https://yolo-auto [dot] com/v1",
      "apiKey": "YOUR_UNMETERED_KEY_HERE",
      "constraints": {
        "maxContextTokens": 32768
      }
    }
  }
}

Creating the "Dumb Muscle" Background Skill

By target-calling the structural_worker inside your high-volume loops, you completely remove the input token meter on mass ingestion. Here is a baseline example of a processing skill (SKILL.md) structured to handle heavy background extraction without breaking your bank:

---
name: background_triage
description: Ingests raw log data or scraped HTML blobs and normalizes it to Markdown
model_preference: structural_worker
---

You are a structural text utility. Your job is to extract raw data, strip code boilerplate or HTML tags, and return markdown

Or whatever.. use json_schema for strict json.

If you want a cheap way to burn through millions or billions of tokens without watching a meter, for just a flat ten bucks a month, check out yolo-auto [dot] com. I'm splitting the domain format up so the automated spam filters don't kill a genuinely helpful tool. Drop by the Discord if you want to see the live cluster performance or stress-test the nodes.

Coming from a traditional data background, I have been tasked with pulling effective-dated information from the Workday API, and I am losing my mind.

Workday’s bi-temporal, object-oriented graph bullshit means data isn’t stored in nice tables; it’s an array of events with an "Effective Date" (when it happened) and an "Entry Date" (when some HR admin clicked submit).

Here was my original plan to handle this:

1. Use the Workday Transaction Log as a proxy to pull changes.
2. For backdated/retroactive changes, build a manifest pipeline to go back and re-pull the data effective as of those specific dates. (e.g. if u have 20 changes and you just back dated something a year ago, you repull all of the as_of for this worker).
3. Extract facts into effective dated tables for employees from the raw artifacts
4. Use those lines to stitch together effective timelines for downstream employee calendars.

"Why dont you use RaaS"? Our internal report writers literally only understand snapshots. Everything downstream is a snapshot to them. They can’t write the interval math to parse effective from/to dates across multiple tables, and our Workday team can't get all the facts into a flat historical table format for them anyway. Try getting your RaaS team to re-create the manager report in workday.

So I looked into the alternative: just pulling a full, daily As_Of_Effective_Date snapshot via SOAP. But that would literally mean downloading terabytes of data where 99.9% of it is the exact same redundant garbage. It would take a week to pull everything.

Has anyone actually built a sane incremental architecture to feed snapshot-brained analysts from Workday without melting their infrastructure or hitting API limits with massive manifests? What am I missing here?

Hi,

Any of you devs here use gpt 5.5 to control godot?

I tried to use it with pi-mono and it literally destroyed my buddies game.

Just wondering what the best practices are here around this.

Hello!

It's me again. The Unlimited token dude. Coming here to tell you that you are now allowed up to 4 concurrency and 256k context. We upgraded to a FP16 Cache. Still unlimited tokens and unlimited requests.

qwen3,.6-35b-3a unlimtied tokens? thats crazy! why would i ever want that?

-- Dumb Muscle -- high volume web scraping, semantic deduplication and filtering streams, log analysis and error classification. Send us everything.

-- Infinite monkey test sandbox -- you're guarenteed to have a LLM available to you 24/7 with no usage constraints or fears of going over your token limits. It can be your agentic plumbing sandbox.

```python

yolo-auto \ \\

. \ \ \

com

```

i made my private disc channel public and random people (mostly buddies) were controlling my amazon mini pc thru openclaw. it wasnt sandboxed, but the machine is basically a burner itself.

They renamed all of my folders to stuff like "cope_archive_17"

They had a very insulting performance review dashboard of how my agents think i am "high energy, low trust, and not safe to speak with"

{ublished my passwords/secrets to the channel.... and luckily, the agent refused the relentless rm rf requests!

anyway, be careful out there!

Hey r/RAG — sharing what we’re building at Yolo-Auto.

Yolo-Auto is an OpenAI-compatible inference provider built for unlimited-token workloads. The simple pitch is: send us the stuff that gets annoying or expensive fast — big docs, messy corpora, RAG experiments, eval loops, chunking tests, indexing passes, extraction jobs, and agent runs.

We’ll eat the document-heavy work.

The goal is not to replace frontier models for every final answer. It’s to give you cheap, practical inference for the bulk RAG work where token caps and usage limits get in the way.

No token or request caps. Like Fatherless.ai or whatever its called... but for $6.

OpenAI-compatible endpoint.... Good for dirty work, preprocessing, extraction, testing, and high-volume RAG experiments.

It pairs well with Yolo-Auto Desktop too, but you can use the endpoint from whatever stack you already have. No need to use that though, i assume if you are here you already know what you're doing.

Site: https://yolo-auto.com

For people building RAG systems: what would make an unlimited-token inference provider actually useful to you?

I'm looking for a SQL editor built for speed but don't make it a game of watch the skinny box and hope the AI comes back with the right query.

I don't want a button-driven interface. I want to stay on the keyboard and move as fast as I can think.

Most existing tools miss this. DataGrip, for example, is too slow and buggy for this workflow. Schema refreshes are unreliable, autocomplete lags, and I still end up typing boilerplate like:

select *

from schema.table

Then I have to jump back to the "*", inspect the table, remember the columns, figure out the joins, and manually build the query. Yuck

Instead....

I want the editor to understand the table as soon as I type it. Schema information should appear inline while I'm writing: column names, data types, row counts, cardinality, foreign-key relationships, common joins, and likely filters.

Ghost text should predict the next clause. Formatting should happen as I type. Common SQL boilerplate should disappear.

The goal is not AI that writes the whole query for me. The goal is an editor that helps me explore data and build joins, filters, where clauses, at the speed I'm thinking or faster.... without constantly stopping to look things up or fight the interface.

Example workflow:

Question:

Who subscribed to my app on Saturday, and what plans did they get?

What I type:

c

Editor expands / suggests:

select *

from customers c

Then I type:

i

Editor suggests the likely join:

inner join customer_plans p

on c.id = p.customer_id

Then I type:

w

Editor adds:

where

Then I type:

s

Editor suggests:

stripe_event_created

Then I type:

= saturday

Editor resolves it into:

stripe_event_created::date = current_date - interval '2 days'

Final formatted query:

select

c.id,

c.email,

c.created_at,

p.plan_name,

p.status,

p.stripe_event_created

from customers c

inner join customer_plans p

on c.id = p.customer_id

where p.stripe_event_created::date = current_date - interval '2 days';

That is the experience I want: type small, obvious signals, and have the editor fill in the boring parts using live schema context.

And like, I'm sick of typing select distinct from ..... Just to get enums.

Also like, you should be able to do this to parquets, cleanly, too.

There has to be a product out there that can do this , and takers? If not, we need to start something .

We're nowhere near capacity, so here's a stupid deal, while also telling you what it's all about.

Unlimited AI inference for $6/month.

Model:qwen3.6-35b

\- No token caps

\- No request caps

\- OpenAI-compatible endpoint

\- \~100 tokens/sec average right now

\- 2 active generations at once

\- 128K context (maybe 256 soon)

\- strong growing discord community

\- events with prizes

\- for normal prompts, TTFT is insane

If you're building an AI embedded SaaS, shipping side projects, or just burning through prompts, this is probably the cheapest unlimited inference endpoint you'll find.

So we have about 99% uptime now. Finally figured out how to make qwen3.6-35b-3a not loop, and we've had some pretty big blunders along the way. It's all at yolo-auto.com .

Why dont large providers just let you use their LLM without token limits?

Why havent more unlimited llm subscriptions followed up that just give you an openai/v1 compatible endpoint with a monthly subscription?

Whats up with all these usage caps and stuff?

Hi,

So like the whole point of AI Agents, whether you are doing random stuff at home, setting up mutli agents to do things, is to just keep them working 24/7. Local hosting solves alot of this but many people cant host anything because there's no GPUs available -- the entry is is $4000 right now.

I also got tired of cloud companies forcing paid api tokens to use other tools outside their ecosystem.

So the dream is: No credits, No obscure usage, No token limits, no request limits, and run agents in your own sandbox or pc .

I built the dream--- an unlimited qwen3.6-35b-3a provider service at yolo-auto -- come for a $6 flat fee.

Sure its not the best coding model. But its awesome in openclaw and in the right harness, it can code while burning millions of tokens to do somewhat medium difficulty tasks.

Its locally hosted and we're sitting at like ~98% uptime. The users who stuck around are crushing billions of tokens a week. We finally figured out how to make MI300x not suck (sglang crew). We're basically making enough to pay for power, but we're a growing community and people really enjoy the service.

So whats that have to do this this thread? If you are:

1. spending more than $6
2. afraid to use metered api tokens to do hobby-like things
3. want to try some open weighted models on private servers with 0 data retention

then come give us a try or, chat in our discord, which is on our site, commented below

Thanks for reading!

​I currently use dbt Core on-prem with Postgres. I genuinely love the documentation, testing, and CLI commands.

But I'm hitting a wall: some transformations are just an absolute nightmare to write in pure SQL.

​The standard workaround of sandwiching tools together—doing Python Extract/Load -> Polars -> dbt -> Polars -> back to dbt—sucks. You end up having to write fake stubs just to make the steps talk to each other cleanly.

​Here is where I'm at with the current ecosystem: ​dbt Python models / Fivetran: Not an option. I'm avoiding that ecosystem entirely.

​Dagster: I was looking into it, but I'm glad I dodged that bullet given their recent trajectory. I have zero interest in getting pushed to their cloud.

​Airflow: Manually stitching this all together with Airflow DAGs is tedious and bloated.

​SQLMesh: Honestly, it seems a bit weird to me, though maybe I need to look closer.

​What are you all actually using for strictly on-prem solutions where you need to seamlessly mix Python (Polars) and SQL?

​I'm completely open to ripping out dbt if there is a better paradigm for this.

Also, I might just re-write everything in polars. But the problem there is polars is better if u have hive style partitions with s3- like storage -- not an option for this client. ​I would essentially be doing ETL to postgres just to extract it again. Then, how could I get that self documenting pipeline?

Thanks