connections-tui VS langroid

NYT Connections definitely has less red herrings than Only Connect's wall (and doesn't have the pressure of the timer, either...), but the quality has gone up significantly in the past year and half.

If anyone wants to try, I actually built a command line player of the NYT Connections game here: https://github.com/jleclanche/connections-tui (for some definition of the word "I")

I ran into this question when thinking about the approach for a recent project. Yes CLI coding tools are good agents for interactive use, but if you are building a product then you do need an agent abstraction.

You could package Claude Code into the product (via agents-sdk or Claude -p) and have it use the API key (with metered billing) but in my case I didn’t find it ergonomic enough for my needs, so I ended up using my own agent framework Langroid for this.

https://github.com/langroid/langroid

(No it’s not based on that similarly named other framework, it’s a clean, minimal, extensible framework with good dx)

https://github.com/langroid/langroid

[B] With the explosion of Claude Code and similar CLI coding agents, there were several interesting problems to solve for myself, and I started collecting them here: https://github.com/pchalasani/claude-code-tools

Relatedly, I haven’t seen two issues discussed much in agent design, but repeatedly come up in real world use cases:

(1) LLM forgets to call a tool (and instead outputs plain text). Contrary to some of the comments here saying that these concerns will disappear as frontier models improve, there will always be a need for having your agent scaffolding work well with weaker LLMs (cost, privacy, etc).

(2) Determining when a task is finished. In some cases, we want the LLM to decide that (e.g search with different queries until desired info found), but in others, we want to specify deterministic task completion conditions (e.g., end the task immediately after structured info extraction, or after acting on such info, or after the LLM sees the result of that action etc).

After repeatedly running into these types of issues in production agent systems, we’ve added mechanisms for these in the Langroid[1] agent framework (I’m the lead dev), which has blackboard-like loop architecture that makes it easy to incorporate these.

For issue (1) we can configure an agent with a `handle_llm_no_tool` [2] set to a “nudge” that is sent back to the LLM when a non-tool response is detected (it could also be set as a lambda function to take other possible actions)

For issue (2) Langroid has a DSL[3] for specifying task termination conditions. It lets you specify patterns that trigger task termination, e.g.

- "T" to terminate immediately after a tool-call,

- "T[X]" to terminate after calling the specific tool X,

- "T,A" to terminate after a tool call, and agent handling (i.e. tool exec)

- "T,A,L" to terminate after tool call, agent handling, and LLM response to that

[1] Langroid https://github.com/langroid/langroid

> using these tools as a massive force multiplier…

Even before tools like CC it was the case that LLMs enabled venturing into projects/areas that would be intimidating otherwise. But Claude-Code (and codex-cli as of late) has made this massively more true.

For example I recently used CC to do a significant upgrade of the Langroid LLM-Agent framework from Pydantic V1 to V2, something I would not have dared to attempt before CC:

https://github.com/langroid/langroid/releases/tag/0.59.0

I also created nice collapsible html logs [2] for agent interactions and tool-calls, inspired by @badlogic/Zechner’s Claude-trace [3] (which incidentally is a fantastic tool!).

[2] https://github.com/langroid/langroid/releases/tag/0.57.0

[3] https://github.com/badlogic/lemmy/tree/main/apps/claude-trac...

And added a DSL to specify agentic task termination conditions based on event-sequence patterns:

https://langroid.github.io/langroid/notes/task-termination/

Needless to say, the docs are also made with significant CC assistance.

Agreed. CC lets you attempt things that you wouldn’t have dared to try. For example here are two things I recently added to the Langroid LLM agent framework with CC help:

Nice collapsible HTML logs of agent conversations (inspired by Mario Zechner’s Claude-trace), which took a couple hours of iterations, involving HTML/js/CSS:

https://langroid.github.io/langroid/notes/html-logger/

A migration from Pydantic-v1 to v2, which took around 7 hours of iterations (would have taken a week at least if I even tried it manually and still probably):

https://github.com/langroid/langroid/releases/tag/0.59.0-b3

I really like the repo-mix tool for generating targeted LLMs.txt files.

https://github.com/yamadashy/repomix

I use this in a pre-commit hook to generate a few versions of these (of various token lengths) in Langroid:

https://github.com/langroid/langroid

For example I can dump one of the LLMs.txt into Gemini 2.5 pro and ask it about how certain Langroid features work, or ask it to implement simple agent systems, and it does a good (not perfect) job. I find this to be a convenient way to onboard people to Langroid, since LLMs don’t (yet) “know” Langroid too well (they know a little and hallucinate quite a bit)

github.com/langroid/langroid

In the Langroid[1] LLM library we have a clean, extensible RAG implementation in the DocChatAgent[2] -- it uses several retrieval techniques, including lexical (bm25, fuzzy search) and semantic (embeddings), and re-ranking (using cross-encoder, reciprocal-rank-fusion) and also re-ranking for diversity and lost-in-the-middle mitigation:

[1] Langroid - a multi-agent LLM framework from CMU/UW-Madison researchers https://github.com/langroid/langroid

[2] DocChatAgent Implementation -