Areibman

Could you say more about how caching works? One major advantage of sticking with a single model is saving money on cached input tokens. I'd imagine if you swap between a bunch of models, you may improve performance but cost would would balloon out of control

Author here. Took out some of the technical details about the harness, but it was mostly just OpenCode's default compaction.

The harness was extremely simple: A handful of MCPs + Skill.MDs and OpenCode with a stayalive daemon inserting "continue" every time it went idle

I gave my Clawdbot Exa + Firecrawl + Playwriter to scan Zillow/Redfin/Craigslist for apartments, rate their quality, and validate their availability for rent. I scheduled it to send me rental listings every day.

Your goal should be to run agents all the time, all in parallel. If you’re not hitting limits, you’re massively underutilizing the VC intelligence subsidy

https://hyperengineering.bottlenecklabs.com/p/the-infinite-m...

I've found criticism like this comes from people who feel as if LLMs pose a threat to their intelligence.

What's the main synergy between Cursor and Graphite that led you to join? Stacked PRs? AI code review? Something else?

I've found this list of "undocumented rules" to be useful https://github.com/minimaxir/hacker-news-undocumented

My biggest frustration is the lack of a good universal REPL to just play around with. It's frustrating how I have to run `uvx --with x,y,z ipython` every single time I just want to spin up some python code which may or may not use packages. (Hard to overstate how annoying it is to type out the modules list).

To me, Python's best feature is the ability to quickly experiment without a second thought. Conda is nice since it keeps everything installed globally so I can just run `python` or iPython/Jupyter anywhere and know I won't have to reinstall everything every single time.

To rephrase: "You should trust political volunteers."

Surely we could do better? Testimony doesn't assuage my concerns that the process may not be tamper proof.

From a process perspective, how can a constituent know with absolute certainty that their vote was counted, every voter in the system was legal, and the final tally was authentic? Especially when there's no way to even audit what you voted for after the fact?

Every time I try to get to the bottom of this, it always boils down to "trust the system" which makes me uneasy.

"Vibe coding" implies it's newbies throwing prompts and hoping some of them stick.

For the experienced lot of us, I've heard many call it "hyper engineering"

>AI-generated code needs to be reviewed, which means the natural bottleneck on all of this is how fast I can review the results

I also fire off tons of parallel agents, and review is hands down the biggest bottleneck.

I built an OSS code review tool designed for reviewing parallel PRs, and way faster than looking at PRs on Github: https://github.com/areibman/bottleneck

For fans of the game, Aspyr just announced Deus Ex: Remastered https://www.youtube.com/watch?v=f1RdKezTYNk

However, fans of the game are calling it "Demastered".

Commenting feels so much better. You can comment on entire files, and you can leave review comments that actually "block" (rather than just get appended to the conversation)

The biggest grip I have with Github is the app is painfully slow. And by slow, I mean browser tab might freeze level slow.

Shockingly, the best code review tool I've ever used was Azure DevOps.

Similar project used to organize PDFs with Ollama https://github.com/iyaja/llama-fs

Played with https://www.freestyle.sh this weekend, really solid

Here's my full list: https://gist.github.com/areibman/b1f66a9a037005b2d4bbf5ba2e5...

I've been keeping a rolling list of LLMOps/AI agent observability products funded by YC. What problems does Lucidic solve that the others do not?

https://hegel-ai.com https://www.vellum.ai/ https://www.parea.ai http://baserun.ai https://www.traceloop.com https://www.trychatter.ai https://talc.ai https://langfuse.com https://humanloop.com https://uptrain.ai https://athina.ai https://relari.ai https://phospho.ai https://github.com/BerriAI/bettertest https://www.getzep.com https://hamming.ai https://github.com/DAGWorks-Inc/burr https://www.lmnr.ai https://keywordsai.co https://www.thefoundryai.com https://www.usesynth.ai https://www.vocera.ai https://coval.ai https://andonlabs.com https://lucidic.ai https://roark.ai https://dawn.so/ https://www.atla-ai.com https://www.hud.so https://www.thellmdatacompany.com/ https://casco.com https://www.confident-ai.com

There are actually a handful of great libraries to help with RL/LLM agents in Pokemon Showdown.

I did a solo hackathon project [0] using poke-env[1] and found it to be pretty easy to get started with. Hoping for an easy-to-use API with this as well.

[0] https://x.com/ditzikow/status/1922004651790000521 [1] https://github.com/hsahovic/poke-env

In similar fashion, this site has saved me countless hours fixing common git issues https://ohshitgit.com

The OpenAI dash is great but is clearly missing a lot of features (i.e. data export, alerts, non-oai model compatibility). Believe it or not, but they don't even report response API costs on spans

Nice to finally see one of the labs throwing weight behind a much needed simple abstraction. It's clear they learned from the incumbents (langchain et al)-- don't sell complexity.

Also very nice of them to include extensible tracing. The AgentOps integration is a nice touch to getting behind the scenes to understand how handoffs and tool calls are triggered

Congrats on the launch!

Given the size of the niche (developers building voice agents), do you find there's a lot of demand for testing and observability? From my anecdata, many of the voice AI agent builders are using SDKs and builder tools (Voiceflow, Vapi, Bland, Vocode, etc). Observability is usually already baked-in pattern with these SDKs (testing I'm not so sure of).

One conversation I had with a voice agent builder: "Our product is complex enough where external testing tools don't make sense. And we know when things are not working because we have close relationships with power users and companies." Whose problem are you solving?

Your tool looks very powerful, but might the broader opportunity be just to use your evals to roll out the best voice agents yourself?

Yes, here's a directory of many of them https://staf.ai

This is unnecessarily harsh. Not every model has a publicly available tokenizer, and using a fallback like cl100k is usually a decent enough estimator from my experience.

Besides, there's a warning message for when you specify a model without a known tokenizer.

If you're upset with the implementation, you can always raise an issue or fix it yourself

Best one I've found out there. If there's another, very open to replacing

Perhaps at some point! Right now, we haven't been seeing most demand on the language side of things as multi-modal image really hasn't popped off yet

Anthropic actually has a Claude 3 tokenizer tucked away in one of their repos: https://github.com/anthropics/anthropic-tokenizer-typescript

At this moment, Tokencost uses the OpenAI tokenizer as a default tokenizer, but this would be a welcome PR!

No— you have to explicitly checkmark it for the change to happen. We saw the famous OpenInterpreter tweet where the agent deleted every file on someone’s computer. We wanted to avoid that