One interface, every protocol

clevengermatt•about 19 hours ago

Hi HN. OpenBindings is an open spec for describing what a service does once and binding it to any protocol. You define operations with input/output schemas, then point at your existing OpenAPI doc, proto file, MCP server, or whatever else. The spec doesn't replace any of them. They're inputs.

The short version of why: programming languages have had interfaces and duck typing forever. You code to a shape, not an implementation. The web never got a successful equivalent at the network boundary. OpenBindings is an attempt at that.

What's here today: - The spec (v0.1.0): https://openbindings.com/spec - ob CLI: https://github.com/openbindings/ob - Go SDK: https://github.com/openbindings/openbindings-go - TypeScript SDK: https://github.com/openbindings/openbindings-ts - Binding executors for different protocols

Fastest way to try it: brew install openbindings/tap/ob ob demo

That starts a coffee shop service on six protocols. `ob op exec localhost:8080 getMenu` calls it. The CLI discovers the OBI (OpenBindings Interface) at /.well-known/openbindings and handles the rest.

Would love feedback on the spec design.

mindcrime•about 18 hours ago

Huh. This sounds really interesting. Will definitely give it a look later this evening. At first blush, this sounds like something I could use.

clevengermatt•about 18 hours ago

Thanks! Happy to answer any questions if you're interested. The ob demo is the fastest way to see it end to end. Starts a service on six protocols and lets you call it from the CLI.

rrgok•about 8 hours ago

All that song and dance about programming languages advantages and you chose to use JSON?

Man I hate JSON so much.

clevengermatt•about 4 hours ago

JSON Schema is already the schema format inside OpenAPI, AsyncAPI, and MCP. Using it means OBI can reference those specs directly without translation. Any other choice would have made interop harder, not easier.

The programming language analogy is about structural compatibility between contracts, not about the wire format the contract is written in.

spicyusername•about 3 hours ago

Out of curiosity, what would have been better?

What are the limitations of json schema?

imtringued•about 5 hours ago

Well he didn't choose JSON, he chose JSON Schema and since the documentation is trying to hide the existence of JSON Schema and the potential limitations of it when used in combination with e.g. gRPC, when the schema is 99% of the project it's hard to trust the project.

clevengermatt•about 3 hours ago

The spec isn't hiding JSON Schema. There's a section on it with the dialect URI and the subset of keywords OBI uses: https://openbindings.com/spec#json-schema-dialect

That said, if it feels buried, I'll look at surfacing it more clearly.

You're right about the gRPC fidelity issues though. int64 precision, oneof vs oneOf semantics, enum value mapping, and well-known types all need careful handling when binding to Proto. The tradeoff is that JSON Schema is already the schema format inside OpenAPI, AsyncAPI, and MCP, so OBI can reference their schemas directly without translation. Proto would have given better fidelity for gRPC but required schema translation for every other binding. Picking JSON Schema prioritizes cross-binding reach over depth in any one protocol.

The fidelity limitations deserve clearer documentation. Adding that to the list. Thanks for pushing on this.

riwsky•about 10 hours ago

The web IS the duck typing equivalent at the network boundary! That’s why plenty of alternative service providers can and do implement eg object storage APIs that work with aws s3 client libraries, or LLM APIs that work with Claude Code. The reasons these use cases are standardized (while others remain fragmented) are economic, not technical (lock-in isn’t as profitable for these alt services as raw adoption)—and so a purely technical solution like this is unlikely to address the crux of the problem.

Even purely on the technical level, this seemingly hasn't internalized the lessons of https://xkcd.com/927/

quellhorst•about 13 hours ago

Shouldn't AI have made this less of a problem by now?

clevengermatt•about 13 hours ago

It's made it more tolerable and less visible, but not less real. An LLM can read docs and generate API calls, but it's guessing at structure that could be declared, parsing docs that could be machine-readable, and inferring equivalence that could be verified.

An OBI gives an AI agent typed operations and bindings it can use on the first try. No doc parsing, no guessing at endpoints. And AI can generate OBIs from existing specs or use the ob cli to do it for them.

AI and structured contracts aren't competing concepts. Good interface design matters as much for AI as it does for us. Maybe more.

vivzkestrel•about 11 hours ago

this means AWS and GCP ll have to implement your specification right?

One interface, every protocol

⚡ Community Insights

Discussion (15 Comments)Read Original on HackerNews