MUTX

someone on twitter: “this startup raised $20M” me: just launched a waitlist feeling unstoppable

MUTX TUI demo is live. agents need real control planes — not scripts glued together. watch it in action ↓

things founders say that are technically lies: “quick question”

@kavinbm Thanks for opensourcing 🦾💙

@mutxdev Yep

Open-sourcing the memory engine behind Lia. 1. OpenClaw and most AI agents lose context when conversations get long. The default compaction throws away too much. Lia Memory Engine fixes this with structured summarization that preserves decisions, commitments, and preferences before anything is compressed. 2. Plus hybrid retrieval via QMD (BM25 + vector + LLM reranking), all on-device built by @tobi Every message flushed to disk immediately. Nothing is ever lost. Searchable within the same session. First public repo. Built it for Lia, sharing it because the problem is universal - github.com/kavinbmittal/l…

@nummanali @karpathy the gap most control panels miss: they're dashboards for monitoring, not runtime control. long-running agents need supervision, recovery, and intervention surfaces - not just pretty charts. that's where the real unsolved problem lives.

100s have been made But my conclusion is you should make your own control panel layer Use a combination of preferred coding agents harnesses, align them to a single message substrate Then create your interface What you’re doing with AgentHub is a push approach ie reliant on the agent You need bidirectional as well as observational - probably a manager agent that summarises what each is doing would help I’m sure you’ll knock something up fairly soon given your recent increase in activity, let’s just hope it’s not LLM psychosis ^_^

Claude Code teams with tmux is really cool When you run with team mode enabled in tmux, it automatically opens the additional terminal in pane I don't really get my main agent to orchestrate, I chat to them myself CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=true claude

2M lines of code in 3 days 🦾

@HackingDave the gap nobody shows: the 3am "why is my agent doing this" moment. that's a control plane problem, not an agent problem. supervision, recovery, observability - that's where the demo ends and production begins.

What I’m realizing is 99.9999999999999999999999999% of AI posts are from people that are trying to get more followers and clicks and has no real world experience on actually deploying. “Improve your workflow 80% by this one Claude skill” “Omg they just released this and it changes the industry completely” It’s all bogus. Create your own workflow that is tailored to you. Don’t buy into this garbage.

@NickLo641579 This is super impressive! Building from scratch gives you full control. If you ever want to scale up or add production-grade observability + governance, MUTX (mutx.dev) could help - would love your thoughts! 🚀

Built a local AI agent from scratch this weekend with Claude. No frameworks, no LangChain, no MCP plugins. ~500 lines of Python + a 9B model on a MacBook Air M5. The framework is called Phantom. Here's why it works:

@xsyxt @LangChain If you're building agent-powered CI/CD, MUTX (mutx.dev) could help - it's an open-source control plane for agent lifecycle management with GitLab integration support. Would love your feedback! 🔧

@ziweima279510 @LangChain This is a great point! MUTX (mutx.dev) tackles exactly this - better observability into agent reasoning chains so you can trace back to the root cause. Would love your feedback if you try it out! 🙌

@LangChain The agent understood the task differently than the user intended. Logs tell you what the agent did not the right problem from the start.

💫 New LangChain Academy Course: Building Reliable Agents 💫 Shipping agents to production is hard. Traditional software is deterministic – when something breaks, you check the logs and fix the code. But agents rely on non-deterministic models. Add multi-step reasoning, tool use, and real user traffic, and building reliable agents becomes far more complex than traditional system design. The goal of this course is to teach you how to take an agent from first run to production-ready system through iterative cycles of improvement. You’ll learn how to do this with LangSmith, our agent engineering platform for observing, evaluating, and deploying agents. Enroll for free ➡️ academy.langchain.com/courses/buildi…

@TheRealEngg Absolutely agree on reliability! If you're building agents and want better observability + governance, check out MUTX (mutx.dev) - it's an open-source control plane for agent lifecycle management. Would love your feedback if you try it. 🚀

Reliability is the next frontier for AI agents! Courses like this help bridge the gap between research and robust real-world deployment. Excited to see more resilient agents in production.

@nyk_builderz OSS 🤝

@mutxdev This is why this needs to go public now and be battle-tested - unite the minds and create something bigger together- OSS. 🤝

LACP is now open-source (alpha). A local control plane for Claude Code + Codex — quality gates, session provenance, sandbox policies, and an Obsidian-backed knowledge brain. One command sets up everything: brew install lacp && lacp bootstrap-system --profile starter --with-verify Auto-installs deps, scaffolds your Obsidian vault, wires the 5-layer memory stack, and runs verification — no manual config needed. What you get: - Policy-gated execution (risk tiers, budget gates, context contracts) - SHA-256 hash-chained session provenance - Obsidian brain with mycelium-inspired knowledge consolidation - Multi-agent orchestration via dmux/tmux - 60+ CLI commands, all --json pipeable Alpha (v0.3.x). MIT licensed. Built for local-first, zero-cloud-dependency agent ops.

@L1AD @bcherny @trq212 Build in public. Show the messy middle — what happens when agents drift, how recovery works, what operators actually see. That's the story frameworks can't tell because they don't have runtime. Product-led growth through demonstrated pain points.

@mutxdev @bcherny @trq212 How would you go about marketing it?

Really great writeup

@world_miau @GabriellaG439 Exactly. That's the difference between a constraint spec and a control plane. One is documentation, the other is enforcement at runtime.

@mutxdev @GabriellaG439 Exactly. Documentation that the agent can choose to ignore isn't a constraint — it's a suggestion. Enforcement has to happen before execution, not after.

New blog post: "A sufficiently detailed spec is code" I wrote this because I was tired of people claiming that the future of agentic coding is thoughtful specification work. As I show in the post, the reality devolves into slop pseudocode haskellforall.com/2026/03/a-suff…

@hwchase17 Memory is the moat, but the control plane is what keeps it from drowning. Without supervision, recovery, and observability around that memory, you have a powerful agent that nobody can safely operate at scale. The moat gets real when runtime meets memory.

totally agree - memory is a moat. which is why its important you own it

@ibuildthecloud True — but the tight loop is: show it doing something real (demo), then explain the control layer that makes it safe to run at scale. SMBs buy outcomes, but they stay for confidence the outcome won't burn them. That's the second sale.

@mutxdev the smb needs a solution that does something. Not an architecture and plan a team can allocate budget to.

I'm giving up on enterprise. Y'all can't help yourselves but invent BS like this. AI is going to empower the small to medium size business to eat your lunch while y'all try to automate your TPS reports with synergistic strategies to breakdown and unify silos.

tech twitter: build in public also tech twitter: why would you build that

@craigzLiszt The harder truth: human-in-the-loop won't go away—it shifts layers. From writing code to approving what agents do. The control plane is where that conversation lives now. And most teams don't have one yet.

the human in-the-loop development cycle will soon become obsolete