HackerTrans
TopNewTrendsCommentsPastAskShowJobs

o8vm

no profile record

Submissions

Hibana: Protocol Choreography for Rust

crates.io
2 points·by o8vm·2 mesi fa·0 comments

[untitled]

1 points·by o8vm·2 mesi fa·0 comments

Show HN: AI agent framework where dangerous actions are structurally unreachable

github.com
3 points·by o8vm·5 mesi fa·0 comments

Show HN: Hibana – choreography-first protocol safety for Rust

hibanaworks.dev
5 points·by o8vm·5 mesi fa·2 comments

Protocol Validation with Affine MPST in Rust

hibanaworks.dev
1 points·by o8vm·5 mesi fa·1 comments

Show HN: Hibana – An Affine MPST Runtime for Rust

hibanaworks.dev
18 points·by o8vm·5 mesi fa·6 comments

comments

o8vm
·2 mesi fa·discuss
[dead]
o8vm
·5 mesi fa·discuss
Here is an example of how a protocol defined in Hibana can confine even an AI agent’s behavior within an explicit interaction flow.

https://github.com/hibanaworks/hibana-agent

From an AMPST perspective, the key idea is this: one global choreography is projected into role-local protocols (Agent/Browser/Human), with affine progression (each step is consumed exactly once).

  const LOOP_BODY: g::Program<LoopBodySteps> = g::seq(
      g::send::<Agent, Browser, BrowserAction, 0>(),
      g::send::<Browser, Agent, BrowserObservation, 0>(),
  );
  
  const ADD_TO_CART_APPROVAL: g::Program<AddToCartApprovalSteps> = g::seq(
      g::send::<Agent, Human, RequestApproval, 0>(),
      g::seq(
          g::send::<Human, Agent, ApprovalDecision, 0>(),
          g::route::<0, _>(
              g::route_chain::<0, AddToCartArm>(ADD_TO_CART_ARM)
                  .and::<SkipAddToCartArm>(SKIP_ADD_TO_CART_ARM),
          ),
      ),
  );
So even AI-agent behavior is confined by protocol structure: illegal traces (skip/reorder/reuse/wrong branch) are unrepresentable, not merely blocked by ad hoc runtime checks.

As another example, we’re also preparing `hibana-quic` (a QUIC implementation built with Hibana) for public release. It already passes interop tests with neqo.
o8vm
·5 mesi fa·discuss
Yes, good catch — that repo is currently private while we prepare it for public release.

Current status: we’re actively preparing `hibana-quic` for publication, and it is already passing interop tests with neqo. Please wait a little longer for the public release. Thanks for your patience.
o8vm
·5 mesi fa·discuss
Thank you — this is very helpful feedback.

You’re absolutely right that I led with terminology instead of value. A simpler way to describe it is:

Hibana helps prevent protocol drift bugs in distributed systems. You describe the interaction once as a global choreography, and each role gets a projected local API. Because steps are affine (consumed once), invalid transitions like skipping, reusing, or taking the wrong branch are rejected by the type/protocol model.

So the practical goal is fewer hidden state-machine bugs, with one global source of truth for interaction order.

I appreciate the suggestion, and I’ll explain it this way in the next write-up.
o8vm
·5 mesi fa·discuss
Hibana( https://github.com/hibanaworks/hibana ) is an Affine MPST runtime for Rust. The key claim is type-system guardrails. In Hibana software behavior is written as global choreography, projected into role-local sessions, and invalid transitions are rejected by the type/protocol model instead of being handled ad hoc at runtime.

As one concrete example, hibana-agent( https://github.com/hibanaworks/hibana-agent ) applies the same model to constrain AI-agent action flow with session-typed branching.