kaicianflone

Fantastic tq I feel stupid because I’ve seen that for a while now. Do you know more about the autocompaction process? I could use some help there too with ghcp. I don’t see my context going up while abusing smaller context models with long inputs nor do I see a compaction indicator after turns.

feel like we’re close to a customized compute era where ads get filtered out by default via something like a diffusion browser or diffusion based Mixed Reality. Feels like it’s already possible with LLMs with enough test time compute to RE endpoints users want to keep and exclude those they don’t.

Which it’s kind of strange VSCode ghcp lacks basic attributes like context % used compared to some TUIs where it’s default.

What is the professional consensus on AI governance?

It seems like governments and large corporations already struggle with governance in general, so I’m skeptical that AI governance will be solved quickly.

Do you expect the next few years to be defined by painful trial and error? I could imagine billion dollar companies disappearing almost overnight due to litigation, compliance failures, security incidents, or outright fraud enabled by AI-assisted development and weak governance.

Or are these risks overstated?

Additionally, why would the AI model for implementation even matter? It might take one dev o3 and another dev sonnet like Fable is a prerequisite to make the implementation happen. Super clickbait

Looks like it based on Anthropic’s own multi-agent orchestration research:

https://www.anthropic.com/engineering/multi-agent-research-s...

Their findings suggest multi-agent systems result in better performance attributed mostly to token usage (80% of variance).

I stopped paying for Wyze subscription after replacing the camera backend service. Saving me about $30/m and a much finer tuned OpenCV to Claude API vision model.

I don’t have a dog in the fight but it’s super scary to think about for the astronauts and their families. This issue’s been going on for a while now. Surprised that there’s not more AI or robotics that could be utilized for such cases.

Rumors are that Elon gets spaceX to buy tesla so tele-operated Optimus robots do the hard space work from now on. Not a bad idea per se but I’m not educated on the topic. Curiosity has me asking if we really want humans to go to mars or in space at all.

Wow Angular Aria looks fantastic. Even have full docs for the more complicated scenarios like autocomplete. Can't wait to get this in my hands and see if it replaces the custom screen reader autocomplete I had to make.

Is that a pretext zoom effect when changing screen dimensions? Very cool.

If I bring my own Anthropic/OpenAI key and have usage available, why does Vercel's account balance determine whether my request executes?

Dissent and consensus among frontier models is a good thing.

Just like on a team of high performers, there are a million ways to skin a grape.

In my research, I've found that models perform better when they operate as a collective system with reputation, incentives, and accountability instead of isolated oracles answering alone.

Agreement, dissent, and correctness should all carry rewards and consequences. Just like in real life.

Collective machine intelligence, not AGI.

It's expensive, but it's also naive to believe a single model will consistently produce profoundly correct answers to profoundly novel questions.

Sure the core primitive is a runtime wrapper that turns any function into a governed decision point:

  import { consensus } from "@consensus-tools/wrapper";

  const safeSend = consensus(sendEmail, {
    reviewers: [humanReviewer, aiSafetyReviewer],
    strategy: { mode: "unanimous" },
    hooks: { onBlock: (ctx) => audit.log("blocked", ctx) },
  });

  await safeSend({ to: "user@example.com", body: "Hello" });

The call to sendEmail doesn't execute until every reviewer votes. Strategy modes handle the consensus logic (unanimous, majority, weighted, etc.), and guards can ALLOW, BLOCK, REWRITE, or escalate to REQUIRE_HUMAN before anything fires.

The monorepo has 9 built-in policy types and 7 guard types designed so you can drop governance into an existing agent system without rewriting your orchestration.

Repo's at github.com/consensus-tools if you want to poke around.

We’ve been building exactly this as an open-source ecosystem at consensus-tools. It’s a governance layer for multi-agent systems with a runtime wrapper that intercepts agent decisions before they execute: .consensus(fn, opts).

The coordination and consistency problems the paper describes are what the monorepo is designed around. Giving agents auditable stake in decisions. Happy to share more if anyone’s working in this space.

There’s a bit of irony here. A lot of commercial kitchens already rely heavily on microwaves and rapid heating equipment. In many restaurants the microwave is a very important tool in the workflow rather than something unusual. Do your friends not eat out much?

It doesn’t look like it. The AirPods Max “bra” case used to feel like it was the bane of my existence when I would always return to my dead AirPods outside the case, after I hurriedly took the headphones off.

But now, thanks to makerworld and 3D printers, I have a stand with integrated neodymium magnets for home that puts them to sleep on my desk and nightstand.

I’m equally surprised I had to print something Apple doesn’t sell and Apple hasn’t improved the design for what feels like a decade (other than USB-C and lossless and now old H2)

Thank you for the post. It's a good read. I'm working on governance/validation layers for n-LLMs and making them observable so your comments on runaway AIs resonated with me. My research is pointing me to reputation and stake consensus mechanisms being the validation layer either pre inference or pre-execution, and the time to verify decisions can be skipped with enough "decision liquidity" via reputation alone aka decision precedence.

I’ve been running OpenClaw Docker agents in Slack in a similar setup, using Gemini 2.5 Flash Lite through OpenRouter for most tasks, then Opus 4.6 and Codex 5.3 for heavier lifts. They share context via embeddings right now, but I’m going to try parameterizing them like you suggested because they can drift prettyy hard once a hallucinated idea takes off. I’m trying to get to a point where I don’t have to babysit them. I’ve also been thinking about giving them some “democracy” under the hood with a consensus policy engine. I’ve started tinkering an open-source version of that called consensus-tools that I can swap between agentic frameworks. Checking out if it can work with openswarm to work for me too.

Go Momo go! If you want to hook up multiple dogs and have them reach consensus I'm down. I have a 15 lb havapoo I can volunteer ( he needs to help with rent )

Fair I cleaned up the wording with ChatGPT with my review prompt. The substance matters more than the style. If a model flips 3/10 times on a trivial constraint, that’s a reliability issue, not a reasoning ceiling.

This doesn’t look like a reasoning ceiling. It looks like a decision reliability problem.

The unstable tier is the key result. Models that get it right 70–80% of the time are not “almost correct.” They are nondeterministic decision functions. In production that’s worse than being consistently wrong.

A single sampled output is just a proposal. If you treat it as a final decision, you inherit its variance. If you treat it as one vote inside a simple consensus mechanism, the variance becomes observable and bounded.

For something this trivial you could:

    -run N independent samples at low temperature

    -extract the goal state (“wash the car”)

    -assert the constraint (“car must be at wash location”)

    -reject outputs that violate the constraint

    -RL against the "decision open ledger"

No model change required. Just structure.

The takeaway isn’t that only a few frontier models can reason. It’s that raw inference is stochastic and we’re pretending it’s authoritative.

Reliability will likely come from open, composable consensus layers around models, not from betting everything on a single forward pass.

Great read. The bilingual shadow reasoning example is especially concerning. Subtle policy shifts reshaping downstream decisions is exactly the kind of failure mode that won’t show up in a benchmark leaderboard.

My wife is trilingual, so now I’m tempted to use her as a manual red team for my own guardrail prompts.

I’m working in LLM guardrails as well, and what worries me is orchestration becoming its own failure layer. We keep assuming a single model or policy can “catch” errors. But even a 1% miss rate, when composed across multi-agent systems, cascades quickly in high-stakes domains.

I suspect we’ll see more K-LLM architectures where models are deliberately specialized, cross-checked, and policy-scored rather than assuming one frontier model can do everything. Guardrails probably need to move from static policy filters to composable decision layers with observability across languages and roles.

Appreciate you publishing the methodology and tooling openly. That’s the kind of work this space needs.

For some reason before reading I thought this was going to be an AI thought leadership piece but it's even better than I expected.

I’m not sure if I prefer coding in 2025 or 2026 now

This is why I’m using the open source consensus-tools engine and CLI under the hood. I run ~100 maintainer-style agents against changes, but inference is gated at the final decision layer.

Agents compete and review, then the best proposal gets promoted to me as a PR. I stay in control and sync back to the fork.

It’s not auto-merge. It’s structured pressure before human merge.

I’m working on an open source project that treats this as a consensus problem instead of a single model accuracy problem.

You define a policy (majority, weighted vote, quorum), set the confidence level you want, and run enough independent inferences to reach it. Cost is visible because reliability just becomes a function of compute.

The question shifts from “is this output correct?” to “how much certainty do we need, and what are we willing to pay for it?”

Still early, but the goal is to make accuracy and cost explicit and tunable.

This matches how I’ve been thinking about it.

With consensus.tools we split things intentionally. The OSS CLI solves the single user case. You can run local "consensus boards" and experiment with policies and agent coordination without asking anyone for permission.

Anything involving teams, staking, hosted infra, or governance sits outside that core.

Open source for us is the entry point and trust layer, not the whole business. Still early, but the federation vs stadium framing is useful.

This is interesting. I’m experimenting with something adjacent in an open source plugin, but focused less on orchestration and more on decision quality.

Instead of just wiring agents together, I require stake and structured review around outputs. The idea is simple: coordination without cost trends toward noise.

Curious how entire.io thinks about incentives and failure modes as systems scale.

I’m working on an open source CLI that experiments with governance at inference time for autonomous systems.

The idea is to let multiple agents propose, critique, and stake on decisions before a single action is taken, rather than letting one model silently decide. It’s model-agnostic and runs locally, with no blockchain or financial layer involved.

I’m mostly exploring whether adding explicit disagreement and cost at decision time actually improves outcomes in high-stakes or automated workflows.

https://github.com/consensus-tools/consensus-tools

I've also created an AgentSkill to interact with the cli:

https://github.com/kaicianflone/consensus-interact

I think the core insight here is about incentives and friction, not crypto specifically.

I’m working on an open source CLI that experiments with this at a local, off-chain level. It lets maintainers introduce cost, review pressure, or reputation at submission time without tying anything to money or blockchains. The goal is to reduce low-quality contributions without financializing the workflow or creating new attack surfaces.