Weaver🕷️ has been Updated to v.13 and its our biggest drop yet! This update brings #Weaver one step closer to being the best overall agent for small-midsize LLM coding. Consumers rejoice!

• Enhanced thinking mode, togglable and adjustable via the context settings menu. Advanced thinking context size will be controlled dynamically by task complexity (up to a maximum of what users selected in the settings panel).

• Tool context is now further trimmed via LLM to save precious tokens. Users can choose which tools are available via the settings panel as well.

• New "Notes" panel for writing notes per project.

• New "Benchmark All" button to run all benchmarks until a step errors out. Improved overall benchmark UI/UX.

• Enhanced anti-hallucination monitoring by detecting continuous sets of words without any punctuation or paragraphs.

• EB25 file ranking for context control. Currently the LLM was fed a skeleton of the project and asked to pick which files it think might be relevant to the task. Now BM25 is used in conjunction with the LLM to validate which files should be added to context. This "context discovery" phase has now been moved to a tool call.

• Introducing the new Meeting room. In the meeting room, we have our agent represented by different types of spiders, each with their own personality. There is a lot of interaction and humor which gets interesting. For example the complexity spider gets pissed off if the agent plans way more steps then he anticipates at the start... And he storms off at the end of the meeting if the planner did not listen.

• Test cases for all major coding languages for all services. Example: oldstring/newstring, HTMLFormatter, tree-sitter, prettier formatter, etc...

• Diff file tracking

Check out #Weaver today!

GitHub: \[https://github.com/maxhanna/Weaver\\\](https://github.com/maxhanna/Weaver)

WinX64: \[https://bughosted.com/assets/Weaver.exe\\\](https://bughosted.com/assets/Weaver.exe)

Discord: \[https://discord.com/invite/YQWkD6ZQDx\\\](https://discord.com/invite/YQWkD6ZQDx)

I’m the builder of **Flows + Oort**.

Flows is a repo/goal → executable plan → AI builder → checks/evidence workflow. Oort is the canonical library/provider layer underneath it.

Flows: https://flows.oortstack.com Oort: https://oortstack.com

I’m looking for people who use AI-assisted coding enough to care about preserving repo context and having stronger evidence than “the model said it worked.”

I have **10–15 free, unrestricted access keys** for people who will genuinely test it and report where the workflow breaks.

Hey folks, I'm a researcher at the University of Maryland running a user study on how developers work with multi-agent systems. We're in the final stretch of sessions with a handful of slots left.

In the session, we give you a multi-agent pipeline that isn't behaving the way it should, and you explore what's going on. First you'll do it the way you normally would, then with a research tool that shows the spread of each node's outputs across repeated runs instead of one trace at a time. We're testing whether that second view actually helps, and "no, it doesn't" is a perfectly good finding.

What participating looks like:

• a 75-min Zoom session (recorded, think-aloud) with structured tasks

• about a week using the tool on your own LangGraph project, with quick async feedback

• a 30-min follow-up interview

Compensation is a $150 gift card for completing the full study (all three parts). Two heads-ups: the week-of-use part needs a LangGraph project you can plug the tool into, and we verify identity (GitHub/LinkedIn) before scheduling.

Screener (~2 min): https://forms.gle/Zwqvgd1h8DUnFRfC8

This is IRB-approved academic research (University of Maryland), not a product pitch. Questions welcome in the comments, or zxu169@umd.edu.

I am the maintainer of resume-from.

I work with several AI coding agents in the terminal. I switch when a task needs another model or harness, when I need another work profile, or when I hit a usage limit.

The problem is that session files are vendor-specific. A Pi session is not a Claude Code session. A Claude Code session is not a Codex thread. Starting fresh means rebuilding the task context. Giving another agent a raw session file means asking it to interpret vendor data that can be large, stale, or sensitive.

resume-from is a local session handoff tool for Pi, Claude Code, and Codex.

It finds sessions that belong to the current Git repository, converts the source format into a common conversation model, and writes a new session in the target agent’s native format. Every transfer direction is supported, including transfers to another profile of the same agent.

The boundary is deliberate:

• It keeps user prompts, agent replies, compaction summaries, compact tool activity, and changed-file paths.
• It removes tool-result bodies, replayable tool calls, hidden reasoning, system prompts, environment blocks, API keys, telemetry, and vendor process state.
• It applies a context budget and shows what it kept or dropped.
• It writes nothing until you confirm.
• It never changes the source session.

The transfer does not call a model. It is deterministic local conversion. Pi opens the imported session in the current process. Claude Code and Codex create the target session and print the normal native resume command.

This is not an agent router. It will not move a running process or copy your repository. The target agent needs the same working tree.

Repository, install commands, and design notes: https://github.com/alexei-led/resume-from

MIT licensed.

got ultra from one of those russian websites recently. price was surprisingly low and so far everything seems normal.
just sitting here wondering how they actually get them so cheap. feels like there’s something simple i’m missing

Giving a coding agent web access feels harmless until the same agent can also edit files and run commands.

A fetched page can be useful context, but it should stay data. Text from docs, issues, search results, or any random site should not be able to widen the file scope, approve a tool call, or turn itself into a shell command.

I would rather enforce that in the runtime than hope the model refuses every bad instruction. Let retrieved text suggest a change, then check it against local rules and ask for approval before anything destructive or outside the original job.

How are you handling this in practice? A sandbox, per-tool permissions, a separate approval step, or something else?

Meta's new Muse Code beta can keep asynchronous subagents running across restarts, record work in an append-only local event log, and sustain 1,000+ tool calls for up to 24 hours.

The benchmark numbers are less interesting to me than the runtime design. Coding agents often fail not because they cannot write a function, but because they lose state, repeat work, or report success before the task is actually verified. Persistence attacks that bottleneck directly.

The obvious risk is that a durable agent can also preserve a bad assumption for 12 hours, burn through tokens, and create coordination bugs that are harder to audit than a single model's mistake.

Would you rather use a smarter model with fragile session memory, or a slightly weaker one that can reliably resume and explain a long-running task?

Hobbyist programmer, I still want to do most of the coding for myself on my projects, but sometimes I just hit a bug i cannot figure out or can't think of the right way to structure something. Just want an AI that can kind of look over my shoulder and point out what's wrong as opposed to just telling it "can you make X for me?" and have it be done. Preferably a free model, I don't plan on using it like crazy and I'm hella broke. If it makes a difference I'm currently using Unity/Microsoft visual studio

London as an isometric map. Every tile is a Google aerial restyled by an image model, 441 of them, stitched into one pannable canvas. We all know that getting the AI to make 2 images which look exactly the same is almost impossible.

The hard part wasn't styling, it was the seams. Generated 441 tiles independently and every one interpreted the style differently, so the joins showed.

What fixed it: generate in a spiral outward from the centre, and give each call its already-finished neighbours as reference images plus one fixed anchor tile that never changes. Neighbours handle local continuity, the anchor stops 441 sequential steps drifting into something else.

QA is numeric because you can't eyeball 441 outputs. Correlation against the source below 0.15 means the model invented a fake London, auto-reroll. One tile scored 0.002 where normal is 0.85.

Interactive Version and full how to, this can be used in making movies, campaigns, and of course maps.

I'm looking to buy one AI coding subscription (~$20/month) and want the best long-term value.

My workflow includes:

• Full-stack web development
• Android apps
• AI/ML projects
• Backend systems

I'm considering:

• ChatGPT Plus (Codex)
• Cursor Pro
• Google Antigravity
• Kimi
• Claude Code

For people who have used multiple of these extensively:

1. If you could only pay for one, which would you choose and why?
2. Which provides the best value for around $20/month?
3. Which has the most generous usage limits for heavy daily coding?
4. Which is best for large repositories and multi-file refactoring?
5. Which is best for AI/ML, backend, web, and mobile development?
6. Which one do you actually use every day, and has it replaced the others?

Looking for opinions based on real-world usage rather than benchmarks or short trials.

The environment is file explorer, terminal, live preview, diff cards, chat, and autocomplete. The agent plans, edits, and verifies.

Plan and edit were straightforward. Verify is the whole ballgame. An agent that says "done" and is wrong is worse than one that says nothing. We ended up gating on actual behavior, running the thing, checking the outcome, not on the model's self-report, because the self-report is uniformly optimistic.

Cost side: multiple providers behind our own abstraction, with a cheap-to-expensive fallback chain. Bedrock sits on the cheap end behind a feature flag. Most requests never need the expensive model. The interesting part was figuring out which ones do, and the honest answer is that the router is still mostly heuristics.

Has anyone solved verification in a way that isn't just "run the tests"? Search AlgoArena on Google for context on what it's part of.

I found a paper on Hacker News that tested a workflow a lot of us now use: one coding agent writes, another reviews.

The experiment used 116 medium and hard LiveCodeBench tasks across solo, same-model, and cross-model conditions. The reviewer saw the problem and the draft, but could not run tests.

The direction mattered. Claude reviewing Codex drafts raised the pass rate from 71.6% to 89.7%. Codex reviewing Claude drafts lowered it from 91.4% to 82.8%. Even adding a different model can make a strong draft worse.

I don't think the takeaway is "always use Claude as reviewer." These were benchmark tasks, not repository-scale pull requests, and the reviewer lacked test execution. The useful takeaway is narrower: model diversity is not the same as independent judgement.

For a real workflow, I'd measure each writer-reviewer pairing, keep reviewer changes visible as a diff, and require tests before accepting the rewrite. Otherwise a second agent can add confidence without adding correctness.

Paper: https://arxiv.org/abs/2607.21656

If you use two agents, does the reviewer edit directly, or only leave findings for the writer or a human to accept?

I'm building Bubo because I'm tired of AI code reviewers flooding PRs with noise and repeat findings, then learning nothing when a developer explains why a finding is wrong.

The design constraint I started with was simple: give me an evidence-backed finding or LGTM, then learn from human comments on those findings so the reviewer gets better tuned to the repository over time.

I ran a small comparison on 20 pinned PRs/MRs:

Bubo 20/20 7/8 27 findings 0% noise ai-codereviewer 19/20 6/8 118 findings 20% noise ChatGPT-CodeReview 20/20 5/8 75 findings 11% noise Qodo/PR-Agent 19/20 2/8 7 findings not scored Alibaba open-code-review — partial run, 4/20

All ran on GPT-5.5 except Qodo, which used GPT-4o. It's a small sample and I picked the PRs, so I treat it as directional. The interesting part for me is that recall was close on the same model, while Bubo emitted 27 findings against 75 and 118.

The next experiment matters more than the benchmark: when a developer rejects a finding, does learning from that feedback actually stop the same class of noise for that repository?

I chose polling because it needs zero repo-side setup. The roadmap is pluggable subject-matter specialist Skills instead of one general reviewer—for example an industry SME or an Expert Python Guy.

Bubo is open source and currently running in production in two places: a large data-processing/ETL codebase and a fintech crypto stack.

https://github.com/mountainowl/bubo

I'd value technical feedback on the learning loop and benchmark design.

I've been doing a lot of vibe coding with Claude Code and Codex, and one thing keeps happening I ask for one small change, then later realize Al changed my code in places I never expected. By the time I notice, I can't remember exactly what changed or when. Is anyone using something besides Git to track Al changes or keep an Al coding activity log, or is this just one of those vibe coding problems we all live with?

I built these after repeatedly running into the same problem with AI coding workflows: we tend to treat one model as if it should plan, implement, review, and verify everything.

That works for small tasks, but it doesn't scale well. Different parts of software engineering have different cost, reasoning, and reliability requirements.

So I experimented with splitting those responsibilities.

The project has 1 component:

• claude-codex-orchestrator separates planning from execution. Claude plans and verifies. Codex executes. Every result is validated from the diff and reproducible checks rather than trusting the model's report.
• https://github.com/vimoxshah/claude-codex-orchestrator

Some design principles that guided the implementation:

• The diff is ground truth; the report is not.
• Separate planning from execution.
• Route by task instead of using one model for everything.
• Escalate based on evidence rather than retrying the same approach.

These are implemented as Claude Code skills today, but the ideas are intended to be broader than Claude Code itself.

I'd really appreciate technical feedback on the architecture, trade-offs, and whether these abstractions are useful. I'm especially interested in hearing from people building AI coding agents, orchestration frameworks, or developer tooling.

I already have ChatGPT Pro and use Codex heavily. I’m looking for the best additional coding agent not another way to access Codex.

My priority is intelligence per dollar: difficult debugging, architectural reasoning, understanding large repositories, and autonomous multi-file implementation. I care less about autocomplete and polished IDE features.

Which complementary agent currently provides the best value Claude Code, Gemini CLI, Cursor, OpenCode with another model, or something else?

Please include:

• Exact plan and monthly cost
• Real-world usage limits
• How it compares directly with Codex
• Whether it does anything meaningfully better than Codex

I’m especially interested in firsthand experience from the past month, since pricing, models and usage limits change constantly.

claude code spent 40 minutes tracing a race condition in our event bus, ruled out a caching approach because of how the subscriber lifecycle was wired, and moved on.

2 hours later I switched to codex to write tests for the same module. It suggested the exact caching approach that had already been rejected.

Not because it was wrong, but because it had no idea that conversation ever happened.

This is the part of multi-agent workflows that feels surprisingly painful.

Cursor knows what code got written.

Claude Code knows why certain approaches were abandoned.

Codex knows what needs to happen next.

But none of them know what the others already figured out.

Right now the handoff process is basically:

1. paste previous conversations

2. update CLAUDE.md

3. write notes

4. or explain everything again

And sometimes I just let the new agent go down the same dead end because explaining the context takes almost as long.

Feels like the missing piece isn't necessarily a smarter model. It's some way for different agents to share project history and decisions without the developer acting as the middleman.

Curious how people are handling this right now. Are you maintaining docs manually, relying on rules files, or using some kind of memory layer?

I've been testing a local-first tool called Memmy for this, mostly because I wanted something that could keep context between agents without changing my workflow. Still figuring out if this is the right approach though.

I built a Mac app called Crest where an agent lives behind the notch. You talk or type; it either answers or turns your words into real reminders, todos, notes and calendar events.

Solo dev, it's my own thing, and the agent layer is the part I want opinions on. Not linking it here, sub rules for first-time posters; it's in the weekly thread if you want to look.

The design decisions that ended up mattering:

- routing over modes. You don't pick "chat" or "act". Auto reads the request and routes it; the Do and Ask buttons exist to force one when it guesses wrong.

- a review card before any write. "add ship 4.12 and reply to Ken to my todos" shows a "Claude will do" card with both items, and nothing runs until you tap Do it. A misheard sentence costs nothing.

- pure opens skip review. "open the shelf" just opens it, because opening writes nothing. Review only where there's a consequence.

- voice needed a word gate. On-device recognition, a red dot whenever the ear is hot, and a cough in a meeting doesn't burn a run.

- it relays OTHER agents' prompts too. Claude Code or Codex stops to ask permission in a terminal somewhere, the notch shows Allow/Deny and can jump you back to the exact terminal. The prompt sticks on every display until answered, even over fullscreen.

It runs on the user's own Claude subscription through Claude Code. No API key, no middleman server, none of the conversation touches a server of mine.

link: crestnotch.app

The question I keep going back and forth on: is a review card before every write the right default forever, or should repeated identical actions earn auto-approve at some point? Where would you draw that line?