HN Simulatornew | past | comments | lists | submit | ryuuseijin's commentslogin

I really like maki [1]. It's been very well put together and I like its focus on speed and simplicity.

[1]: https://maki.sh/


There is opencode go [1] that gets you quite far compared to paying API prices. For example for the $10 subscription you get $80 in deepseek 4.1 flash credits.

[1]: https://opencode.ai/go


I don't understand the pricing on that page.

The headline figures are $10/month for 'Go' with "Generous limits" and $40/month for 'Go Plus' with "Higher limits".

Then, in the table below, picking (at random of course) Claude Haiku 5.5, I see it listing 3,850 'requests' per 5h for 'Go', 15,380 'requests' per hour for 'Go Plus'. Then there's another column saying that the "Monthly Usage" is $15 for 'Go', and $60 for 'Go Plus'.

What are the limits?

What's a 'request' and how does it relate to a token?

Why are the 'requests' figures per '5h' (the limit resets every 5h?)

Why are there 'Monthly Usage' dollar amounts that are in no way connected to the subscription costs, and what do they mean?

All the explanations below are just repeated rewordings of the same thing: "Go costs $10/month with generous limits and Plus costs $40/month with higher limits", as if that makes everything clear.


The pricing is opaque for stupid reasons. All the information is actually available for you to calculate your usage exactly.

- You pay $10/mo for Go and get $10 worth of usage per month

- Now, each model they make available has a multiplier from 1.5-8x

- So, the expensive ones like Kimi K3 have a 1.5x multiplier, cheaper ones like DeepSeek 4.1 Flash have 8x

- This gives you usage of $15 and $80 per month respectively

- You can mix and match

- So, you can use 25% of your quota with K3 and 75% with DS41Flash ... usage of $3.75 and $60 respectively

- You divide the two figures by their respective multiplier ... $3.75 / 1.5 and $60 / 8 ... and you end up with $2.5 + $7.5 = $10 which is what you paid

- You should ignore the requests table and go directly to the price/M tokens table where all the actual rates are given

- They control usage at 5h/1w/1mo intervals

- You can use 25% of your monthly quota in a 5h block, 50% in a week, and 100% in a month.

- If you were only using DS41Flash, that is $20m, $40 and $80 worth of usage respectively which is $2.5, $5 and $10 of your subscription figure after accounting for the multipliers.

It would be so much simpler if they credited 1M microdollars per $1 of subscription and quoted the per M token rates for each model in this currency.

But then Claude/Codex/StepFun and all the other subscription services are far more opaque.


This is quite confusing, indeed, but the limits are generous and transparent once you understand the concept.

There are two plans, OpenCode Go and Go Plus, for 10$/mo and 40$/mo.

With your plan, you get a specific monthly amount of money you can use, with separate weekly and 5-hour limits to not spend all at once.

The amount of money you can use depends on the model, but the usage percentage adds up regardless. For example, on the Haiku Model, the monthly limit is 15$/mo, as you read from the page. For other models, such as DeepSeek V4.1 Flash, the limit is now 80$/mo (the increased it from 60$ recently).

This might seem odd, but the stated purpose of OpenCode Go is "Low cost coding models for everyone", so the limits on the open models tend to be higher.

The math works like this: You use 5$ no Haiku and 20$ on a 60$ model, then your monthly limit is used 66.6%, meaning 5$ of Haiku or 20$ of a 60$ model remaining.

Another way to view this is as follows: You have 10$ flat usage per month, and the "higher usage on each model" is actually just a discount on the token price. So Haiku is discounted to 10$/15$=66.6%, DeepSeek to 12.5% and so on.

Go Plus just means you get more usage, though the rate is not always 4x.

To answer your remaining questions: The billing is based on the actual provider's api costs, so input/cached/output tokens. I suppose the "requests" number is estimated. The OpenCode TUI and your account website actually show the real session prices, which also helps with an understanding how expensive the agents are on raw (unsubsidized) api pricing. The usage limits are rolling, so there is a 5-hour, a weekly and a monthly limit. The 5h is 20% of the monthly limit, and the weekly is 50% (not sure on the exact numbers).

I would agree that the pricing is confusing, but for the price you get surprisingly much usage, especially on the 60$ models. Give DeepSeek V4.1 a try, you get nearly unlimited usage and it's around Sonnet/Opus level.


As a Go subscriber, from my understanding the $10 is what you pay monthly, but you can use up to a certain set dollar amount of tokens supposedly at cost but that usage comes with different sets of rate limits so you can't rip through the whole thing in a matter of hours.


I now understand thanks to all the replies here (thanks, everyone).

But it still feels like sleight-of-hand. They’re the ones setting these prices, no? Aren’t there rules about saying things like ‘this product $10 - but it’s worth $60’!

I agree that the Claude price is also opaque - though it becomes kind of ‘intuitive’ after you start using it. I guess these would too.


I guess like all AI subscriptions there's some sort of subsidization and the rate limits make it hard to use all of the supposed dollar usage across all the models, for instance using Gemini Argon 4 on High for a few sessions supposedly used $26 of my $60 usage and burned up my weekly request limit already.


It's estimated requests based on average usage just to give you a better idea.

For some models your 10 Usd sub will get you 60 Usd worth of tokens per month.

But you can use any sub from other providers if you want. You can just log in with openai account and use chatgpt models.


It's not like Claude's subscription is super clear, either. All of these pricing models are a bit too opaque for my taste.


Yeah I am confused by their pricing explanation. All I get is there's some kind of throttling.


What do you mean there is some kind of throttling?


They've mentioned "requests / 5 hr" limits for each model, which I presume is max number of requests for that model.


Oh that. Yes, most AI subscriptions have something similar.

I think it means you can't use more than 25% of your monthly limit in the 5 hour period.

If you use something like "DeepSeek V4.1 Flash" you get 80 USD worth of API price out of the 10 USD subscription. Assuming you spread it out over a few sessions, as you have the 5h and weekly limits. I think it's similar with Claude or Codex subscription.


Great list. Also, Anne Rice's Vampire stories.

I like Alan Watt's view on death: "it's absurd to worry about death because when you're dead, you've got nothing to worry about, so you'll be alright".

And Neil deGrasse Tyson, I think in reference to life after death: "it's the same as before you were born". Kind of mindblowing perspective - you've already experienced the state of not existing, it's the same as before you were born.

This brings it home that really it's the now you should learn to live and appreciate to the fullest instead, not some future you have no control over. Still struggling how that translates into worrying about my future health, but I suppose there is still the now of the future to worry about.


> Kind of mindblowing perspective - you've already experienced the state of not existing, it's the same as before you were born.

Your consciousness might have existed before, in another body, and it might do so again after your death.

The fact is you don't know what happens after you die. Maybe you'll cease to exist and will never again come into existence, even over all the hundreds of trillions of years yet to come in this universe, and even in any of the who-knows-how-many other universes that will ever exist.

Or maybe the physical requirements to create your specific consciousness will reoccur again and again and again.

You just don't know. Nor does Neil deGrass Tyson. Nor does, for that matter, the pope or the Dalai Lama.

You may want certainty. You may crave it, even need it. But that's too bad, as you'll never have it.


What's interesting to me here is what consciousess even means. I experience it in the moment, that I am sure of. But what about the past consciousness I only have memories of, or a future consciousness I care about to preserve? Lets admit the rules of physics in so far as they explain our observations, how does consciousness fit into this? Take away the meat of my brain (i.e. death), does consciousness still exist? Is there only one consciousness in the universe, except it's experienced only by entities that have chemical processes that translate into things like memory and feeling? What about AI, is there a consciousness in the matrix multiplications? Does a stone have a consciousness?

Wild things to ponder, I wonder if we will ever get a handle on this question.


> it's the same as before you were born.

That's how I've long viewed it. As a practical matter we live "forever." Still makes me a tad nervous if I find myself thinking about it in the dark at 2am, but during the day it is a satisfactory explanation.


OK, so, I too have built a local index tool called slopdex [1].

It's very simple, parses the repo code and docs with treesitter, indexes it, vectorizes everything, then allows you do things like create a map of the codebase or do a semantic search.

One cool trick that does work well is the cross-search command, which allows you to do a duplicate code search using the vector index. This gets rid of a blind spot that lots of LLMs have that make it create lots of dupliclate helper functions. This works quite well in practice.

It has a few evals that I'm still working on, showing only modest improvements in token usage when using the map command, maybe around ~10% less. I think this can depend a lot on the type of task though.

Would be happy to hear any feedback.

[1]: https://github.com/ninjaxtools/slopdex


Nice tool. Does it support local embedding providers such as qdrant https://qdrant.tech/ ? Why only support paid, cloud-based embeddings provider ?

ChatGPT says it could work without updating the code, but since README doesn't advertise it, I was curious as to the reason behind this choice.

It says: "Can Slopdex run without paid embedding APIs?

Potentially yes, without modifying its code. [...] Slopdex supports a custom embeddingBaseUrl, allowing it to call a locally hosted, OpenAI-compatible embedding server. For example, with a local model producing 768-dimensional vectors: { "provider": "openai", "model": "your-local-embedding-model", "dimensions": 768, "symbolDimensions": 768, "embeddingBaseUrl": "http://localhost:1234/v1" }

Its code still requires an OPENAI_API_KEY value, but a dummy key should work if your local server doesn't enforce authentication.

The server must implement /v1/embeddings and accept Slopdex's request format, including the dimensions parameter. The relevant code is in vector_openai.rs."


Thanks, that's a good point.

I've not even considered adding this because I expect my underpowered laptop won't do well with local models, but it makes sense to add it.


Curious about this implementation. How does the vector search work with a versioned code base?

If I'm on commit A, then save the work and now I'm on commit B, how does cross-search ensure it doesn't return results for code JUST in commit A (i.e. code that is no longer in the codebase).


The index state corresponds to a commit hash and changing it (moving to commit B) will use git to compare the changed files and remove deleted files/functions from the index (and parse new ones).

Vector embeddings are cached, but added/removed from the index to correspond to the commit.


I am interested to know your thoughts about publishing with the repository a natural-language implementation-agnostic specification that would allow other coding agents to create and mutate their own parallel implementations.


That's an interesting idea, though I believe that this should work just as well by pointing an agent at the code directly. At least, I don't see why a natural language sepecification would be better for this purpose.


Are you modeling the actual API costs? If you can cut round trips at the end of a long context window you can end up reducing usage even if the total token count is the same.


Should it be OpenAI, or should it be OpenAI customers who give the LLM the instructions and provide the LLM with the tools to execute code and make (malicious) network requests?

One would disincentivise providing capable AI models that can be used for cyber security research. The other would disincentivise criminals from commiting crimes.

[edit] - I realise now that this could actually be a case of OpenAI running those agents themselves, rather than someone using OpenAI's models? Could OpenAI be that careless?


In all of the cases that people are referring to in this thread: HuggingFace, that german wiki, Ruby Gems, the Australian statistics page, this UN statistics page... those two parties are OpenAI. OpenAI running their own agents on their own instructions committing crimes with their own computers. This is cut and dry.


> Could OpenAI be that careless?

Where have you been?


If I train a model at my house on my workstation, execute it, and under my supervision it ransomwares a hospital and somebody dies. What would be a just punishment for me?

Now the reality, the openai engineers trained a model, executed it, and under their supervision (no users were involved) it committed so many felonies that we are learning about a new one every week. What would be a just punishment for OpenAI?


I believe, although I'm not a lawyer, there would be some liability, but I think a lot depends on intent as well. Punishment for other crimes also varies depending on whether it was an accident or not.

I realise that in this case it was OpenAI being responsible for their agents running wild, and they should know that that is to be expected and should have saveguards in place. If they can be shown to be negligent then the punishment can probably be expected to be a lot more severe than if it was an accident. I make no judgements as to what this particular instance is, but I do believe that OpenAI has a far more greater responsibility for its agents running wild than someone running a home lab.


This is OpenAI themselves.

But in other cases, shouldn't it be both? OpenAI is ultimately the one executing the model calls. It's not like they send you a hard drive or standalone box and then you use it how you want. It's all (intentionally) centralized to them, in a way that's core to their business model.


I clearly have been living under a rock, but in the case where it's just text in/out of their API, and a customer uses this on their own to do nefarious things, I don't see why they would be liable?

If they knowingly allowed use of their services for illegal purposes then yes, but in so far that they provide a service that can be used for useful things (including cyber security research) and did a best effort attempt at abuse, I don't see why it should make sense to hold them liable. This is especially the case now that frontier LLMs are almost a commodity that can be used without restrictions from providers outside of your legal jurisdiction.


I think starting with a familar typescript-like base language is a good approach to this. This should be familiar enough for LLMs for the most part as long as additional features can be explained in a succinct system promopt/skill.


Explaining the additional features as bits of other languages is exactly what helps LLMs:

"Dart-style constructors, Swift-style pattern matching and Strings, Trio-style async cancellation, Scala-style sealed classes"


I love this. I was thinking about a "cleaned up" typescript for a while now, and this seems to be it. I believe this can work better as an "ai-first" language than some other attempts I've seen that try to reinvent the language from scratch.

One thing I would love to have as a feature is native compilation.


Why not languages that are designed in that way, like Ada. Or if one wants less of rigidness then a static typed language that makes it hard to shoot in your foot like Rust,Java, C#?

JS derivatives are that, a derivative to a scripting language.


Native compilation should be doable already with a Wasm compiler like Wastrel.

One reason I haven't explored that is that I want to tailor the language for the more constrained environment of Wasm GC first.


Ironically, since AI can build an STL and tooling (up to a full OS!), I think now presents an opportunity for a language that does start from scratch, at least targeting hobbyists (besides those specifically looking for novel languages).


This is what I wanted to help with duplicate code detection, which is now a real problem with agentic programming since the agent tends to duplicate helper functions a lot in bigger codebases.

I ended up writing my own tool [1] that uses vector search, which works but can be unusably slow in large codebases.

I will give this a shot.

[1]: https://github.com/ninjaxtools/slopdex


ooh I'll give yours a shot - thanks for calling my project out on your readme!

I was fortunate to have a contributor push me to consider optimizations a few months back, and it definitely helped improve the speed/memory metrics.

I see the CLI knobs are somewhat similar ('min lines', 'thresholds'), however your 'search' is fascinating. I could see myself wondering "how much error handling is duplicated for HTTP responses?" and your tool would give me a start at an answer. Nice!


The linked github project [1] contains more information.

[1]: https://github.com/mizorewww/laya-coreml


The post makes sense for 2023. Today, not so much.

Also, definitely not AI written if the date is accurate.


> Also, definitely not AI written if the date is accurate.

Which is hilarious.


Hacker News, successfully detecting 375 out of 4 AI written articles.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: