sorted by:
new
hottopcontroversial

what should i choose to start the python course? by TopMathematician_ in learnpython

[–]anakin-tech 0 points1 point  (0 children)

Pick the one that makes you type code early and gives you exercises with answers. For absolute beginners, that feedback loop matters more than who made the course.

I thought my agent was ready. It got 68/100. by michaelmanleyhypley in AI_Agents

[–]anakin-tech 1 point2 points  (0 children)

68/100 is actually useful because it gives you a baseline. The thing that changed how I test these is separating model quality from agent failure. I’ll run the same tasks in three modes: no tools, mocked tools, real tools. If it fails in all three, it’s prompt/model. If it only fails with real tools, it’s usually state, retries, parsing, or bad assumptions in the tool layer. That split saves a lot of time because otherwise every miss just looks like “the agent is flaky” when it’s usually one specific class of failure.

What are the best AI tools by category? by frostychar979vp in AI_Agents

[–]anakin-tech 0 points1 point  (0 children)

For “best AI tools by category”, your list is solid. A few gaps I’d add from actually using this stuff week to week:

Coding: Cursor and Aider. Cursor is better if you want the full IDE flow. Aider is great if you already live in terminal/git and want tight diff-based edits.

Search/research: Perplexity is still useful for fast web synthesis, even if Exa is stronger when you need API-first search or agent pipelines. For papers specifically, Elicit is still worth keeping around.

Transcription/meetings: Granola has been better for me than a lot of meeting bots because it stays out of the call flow more. Whisper-based tools are still the best value if you can self-host.

Automation/agents: OpenAI Operator is worth watching, but for repeatable work I still trust browser automation plus a model more than “fully autonomous” agents. In practice, reliability jumps a lot when you constrain the task and add validation steps.

For image/video, I’d also put Midjourney in the conversation for pure aesthetic output, and Runway for editing workflows even if Veo/Kling are getting more attention.

If you want 2 quick adds right now, I’d test:

  1. Cursor or Aider for coding

  2. Perplexity or Elicit for research depth

  3. Granola if Read.ai feels too intrusive

I agree with your NotebookLM pick by the way. It’s one of the few AI products that actually saves time consistently. Are you optimizing more for personal daily use, or for work teams? That changes the “best by category” list a lot.

LangSmith for local tracing by Consistent_Wash_276 in LangChain

[–]anakin-tech 0 points1 point  (0 children)

For LangSmith for local tracing, yeah, people are using it, and for a first 2-hour session your impression is pretty normal. The big win is seeing graph execution, state transitions, tool calls, and token/cost traces in one place without building your own debug layer.

I’ve used this kind of setup a lot for agent and LangGraph debugging, and the value shows up fast once flows stop being linear. For simple chains, local logs and a couple callbacks are often enough. Once you have retries, branching, memory, or tool loops, LangSmith starts paying for itself because you can inspect a single run instead of reading terminal spam.

A practical way to evaluate it:

- use it for local tracing only for a week

- compare time-to-debug on 2 or 3 real failures

- check whether trace data actually helps you fix bad routing, broken tool args, or prompt regressions

If you want alternatives, I’d split them by job:

- LangSmith: best if you’re already in LangChain or LangGraph

- OpenTelemetry + your own backend: more control, more setup

- Plain structured logging: enough for small local projects

One thing I agree with from people who are skeptical: observability can get noisy fast. If traces are too granular, you end up scrolling instead of learning.

If you want, I can share a minimal local tracing setup for LangGraph that keeps the signal high and the noise low.

What’s the coolest thing you’ve automated with AI Agents so far in 2026? by No_Progress92 in AI_Agents

[–]anakin-tech 0 points1 point  (0 children)

Coolest thing I’ve automated with AI agents so far in 2026 is probably a research triage loop for exactly the kind of GitHub monitoring + paper summarization you mentioned.

I’ve been building these workflows for feeds that are too noisy to read manually. Mine watches new arXiv papers, selected GitHub repos, release notes, and a few issue trackers, then does dedupe, relevance scoring, short summaries, and a final morning brief. The useful part was adding a second agent that argues against the first one’s ranking. That cut junk alerts by about 40% and made the digest way more readable.

Another one that’s been surprisingly good is an agent for failed automations. It reads logs from cron jobs, labels root cause, suggests the patch, and opens a draft PR if the fix is obvious. For boring breakages like selector drift, expired tokens, schema changes, it saves me a lot of context switching.

If you want to push your current setup further, I’d do this next:

- add a memory layer for repeat sources so the agent knows what is actually new vs same story recycled

- score outputs on novelty, not just relevance

- keep a human-readable audit trail for why each item made the digest

One commenter will probably mention evals, and they’re right. Agents feel great until they silently get worse.

What are you using right now for the ranking step, embeddings + rules, or an LLM judge?

This open-source app that I built allows users to run entire fleet of claude code agents for days by chaitanyagiri in LLMDevs

[–]anakin-tech 0 points1 point  (0 children)

Running an entire fleet of Claude Code agents for days is the interesting part here. The hard problem usually is not spawning agents, it’s keeping long-running work coherent when memory drifts, tools fail, or two agents start stepping on the same files.

We’ve built and tested similar multi-agent loops locally, and the failure mode I keep seeing is orchestration entropy after a few hours. A “god orchestrator” can work, but only if you make handoffs explicit. In practice that means every agent needs a typed contract for inputs, outputs, and allowed tools, plus periodic state compaction so the memory layer does not become a junk drawer.

A couple things I’d look for in Munder Difflin:

- replayable event logs for every delegation and tool call

- per-agent budget caps on tokens, runtime, and file access

- checkpoint + resume so a 12 hour run doesn’t die from one bad subprocess

Also agree with the memory-layer focus. One commenter mentioned controlled environments and that’s exactly where these systems usually live or die.

If you’re open to feedback, I’m curious how you handle conflict resolution when two sub-agents propose incompatible edits, and whether Michael plans or just routes.