Comments URL: https://news.ycombinator.com/item?id=48459397

Points: 2

# Comments: 0

I got tired of Claude Code asking me "what does this service do?" on a codebase I've worked on for two years. The context is all there (git history, dependency graph, past decisions), it's just not in a format the agent can use.

Repowise indexes your codebase into four layers: dependency graph (tree-sitter → NetworkX), git intelligence (hotspots, ownership, co-change patterns), auto-generated docs, and architectural decision records. These get exposed via 8 MCP tools. On each commit, only changed files get re-indexed. No full rebuilds, under 30 seconds.

The decisions layer is the part I'm most excited about. It surfaces architectural intent from commit history: large diffs, migration patterns, tradeoff language. It also tracks staleness as code evolves. Works well on repos with decent commit messages, less well on "fix" history.

pip install repowise repowise init # ~25 min first time, <30s incremental repowise serve # MCP server + local dashboard

Works with Claude Code, Cursor, and any MCP-compatible agent. AGPL-3.0, self-hosted, your code stays on your machine.

I'm running early benchmarks on SWE-Bench and SWE-QA. Results are promising, especially on tasks where grounded context matters. Publishing the full methodology soon.

What's rough: Windows untested, language coverage is Python/TS/Go/Rust/Java/C/C++, decisions UX needs work. Happy to hear what breaks. Pre-indexed demos (FastAPI, Starlette) on the site. Working on Slack, Jira, and Linear integrations for the hosted team version.

GitHub: github.com/repowise-dev/repowise Site: repowise.dev

Comments URL: https://news.ycombinator.com/item?id=47666413

Points: 1

# Comments: 0

One is techno utopia: AI does everything, productivity explodes, humans are free to create and chill.

The other is collapse: AI replaces jobs, wealth concentrates, consumption dies, society implodes.

What I don’t see discussed enough is the mechanism between those states.

If AI systems genuinely outperform humans at most economically valuable tasks, wages are no longer the primary distribution mechanism. But capitalism today assumes wages are how demand exists. No wages means no buyers. No buyers means even the owners of AI have no customers.

That feels less like a social problem and more like a systems contradiction.

Historically, automation shifted labor rather than deleting it. But AI is different in that it targets cognition itself, not just muscle or repetition. If the marginal cost of intelligence trends toward zero, markets built on selling human time start to behave strangely.

Some questions I keep circling:

Who funds demand in a post labor economy Is UBI enough, or does ownership of productive models need to be broader Do we end up with state mediated consumption rather than market mediated consumption Does GDP even remain a meaningful metric when production is decoupled from employment

I’m not arguing AI doom or AI salvation here. I’m trying to understand the transition dynamics. The part where things either adapt smoothly or break loudly.

Curious how others here model this in their heads, especially folks building or deploying these systems today.

Comments URL: https://news.ycombinator.com/item?id=46567421

Points: 5

# Comments: 1

Here is a ground level comparison from someone who has built, broken, and rebuilt agents across several stacks, focusing less on benchmarks and more on lived behavior.

First, the big shift. In 2024, frameworks mostly wrapped prompting and tool calls. In 2026, the real differentiator is how a framework models time, memory, and failure. Agents that cannot reason over long horizons or learn from their own mistakes collapse under real workloads no matter how clever the prompt engineering looks in a demo.

LangGraph style DAG based agents remain popular for teams that want control and predictability. The mental model is clean. State flows are explicit. Debugging feels like debugging software rather than psychology. The downside is that truly open ended behavior fights the graph. You can build autonomy, but you are always aware of the rails.

Crew oriented frameworks excel when the problem decomposes cleanly into roles. Researcher, planner, executor, reviewer still works remarkably well for business workflows. The magic wears off when tasks blur. Role boundaries leak, and coordination overhead grows faster than expected. These frameworks shine in clarity, not in emergence.

AutoGPT descendants finally learned the lesson that unbounded loops are not a feature. Modern versions add budgeting, goal decay, and self termination criteria. When tuned well, they feel alive. When tuned poorly, they still burn tokens while confidently doing the wrong thing. These systems reward teams who understand control theory as much as prompting.

The most interesting category in 2026 is memory first frameworks. Systems that treat memory as a first class citizen rather than a vector store bolted on. Episodic memory, semantic memory, working memory, all with explicit read and write policies. These agents improve over days, not just conversations. The cost is complexity. You are no longer just building an agent, you are curating a mind.

A quiet but important trend is the collapse of framework boundaries. The strongest teams mix and match. Graphs for safety critical paths. Autonomous loops for exploration. Human checkpoints not as a fallback, but as a designed cognitive interrupt. Frameworks that resist composition feel increasingly obsolete.

One prediction for the rest of 2026. The winning frameworks will not advertise autonomy. They will advertise recoverability. How easily can you inspect what the agent believed, why it acted, and how to correct it without starting over. The future belongs to agents that can be wrong without being useless.

HN crowd, curious what others are seeing. Not which framework is best in theory, but which one survived contact with production and taught you something uncomfortable about how intelligence actually works.

Comments URL: https://news.ycombinator.com/item?id=46509130

Points: 1

# Comments: 1

A few failure modes showed up almost immediately.

The biggest one was memory. Long term memory sounds clean on paper, but in practice it drifts. Old assumptions leak into new tasks, context gets overweighted, and agents become confidently wrong in ways that are hard to debug. Resetting memory often improved results more than adding more.

Tools were the second problem. Most agent architectures assume tools are deterministic and cheap. They aren’t. APIs fail, return partial data, change formats, or time out. Agents don’t just need tools, they need strategies for tool failure, retries, and graceful degradation.

Evaluation broke next. Benchmarks didn’t help much once tasks became multi step and open ended. We tried success heuristics, human review, and partial credit scoring. None were satisfying. Measuring “did this agent actually help” turned out to be far harder than measuring accuracy.

Cost and latency quietly limited everything. An agent that feels smart at 10 dollars per task or 30 seconds per response is unusable in most real systems. Optimizing prompts and models mattered less than reducing unnecessary reasoning steps.

Finally, trust degraded faster than expected. Once an agent makes a confident but wrong decision, users mentally downgrade it. Recovering that trust is much harder than preventing the failure in the first place.

The main lesson so far is that building useful agents feels more like distributed systems work than model tuning. Failure handling, observability, and clear contracts matter more than clever prompting.

Curious how others are handling these tradeoffs, especially evaluation and memory management.

Comments URL: https://news.ycombinator.com/item?id=46497654

Points: 1

# Comments: 0