When you drive past a solar project on the side of the road, you see the solar technology producing energy. But in order for a bank to fund $100M to construct the project, it has to be "developed" as if it were a long-term financial product across 15 or so major agreements (power offtake, lease agreement, property tax negotiations, etc). The fragmentation of tools and context among all the various counterparties involved to pull this sort of thing together into a creditworthy package for funding is enormously inefficient and as a result, processes which should be parallelize-able can't be parallelized, creating large amounts of risk into the project development process.

While all kinds of asset class-specific tools exist for solar or real estate or whatever, most of them are extremely limited in function because almost of those things abstract down into a narrative that you're communicating to a given party at any given time (including your own investment committee), and a vast swath of factual information represented by deterministic financial calculations and hundreds if not thousands of pages of legal documentation.

We build technology to centralize/coordinate/version control these workflows in order to unlock an order of magnitude more efficiency across that entire process in its totality. But instead of selling software, we sell those development + financing outcomes (which is where _all_ of the value is in this space), because we're actually able to scale that work far more effectively than anyone else right now.

The most unique/useful applications of it in production are based on combining dependent types with database/graph queries as a means. This enables you to take something like RDF which is neat in a lot of ways but has a lot of limitations, add typing and logic to the queries, in order to generally reimagine how you think about querying databases.

For those interested in exploring this space from a "I'd like to build something real with this", I'd strongly recommend checking out TypeDB (typedb.com). It's been in development for about a decade, is faster than MongoDB for vast swaths of things, and is one of the most ergonomic frameworks we've found to designing complex data applications (Phosphor's core is similar in many ways to Palantir's ontology concept). We went into it assuming that we were exploring a brand new technology, and have found it to work pretty comprehensively for all kinds of production settings.

Phosphor builds recursively self-improving systems (via malleable software and natural language interfaces) to enable the efficient development and financing of the physical world (infrastructure, energy, real estate).

Our product is built around a powerful object model which combines document editors with proprietary programming languages for financial modeling, computable contracts, etc, in order to build one of the more unique RLHF feedback loops that we've seen to date.

A primary technical bet is that if we can productize version control properly, we can capture annotated "diffs" of user information with user-validated annotations. By doing so, we create path-dependence, which enables us to specify system-level goals for agents to solve for.

Our product is similar a combination of Linear and Wolfram, with components and objects that enable advanced financial modeling, legal/regulatory analysis, and geospatial analysis of infrastructure development opportunities.

We're venture-backed by one of the best deeptech funds in the market and are hiring for roles spanning product engineers, CRDT wizards, and compiler/calculation engine leads.

Job listings can be found at the bottom of phosphor.co.

It's one of the most consequential problems imaginable to solve, particularly as the US begins to realize that we need to compete with decades of China's subsidized energy and industrialization/manufacturing capacity.

Taking it a level deeper, what most don't realize is that infrastructure is an asset class: before someone funds the construction of $100M of solar technology, a developer will spend 2-5 years developing 15 or so major commercial agreements that enable a lender/financier to take comfort that when they deploy such a large amount of cash, they'll achieve a target yield over 20+ years. Orchestrating these negotiations (with multiple "adversaries") into a single, successfully bankable project is remarkably difficult and compared to the talent needed, very few have the slightest clue how to do this successfully.

Our bet at Phosphor is that this is actually solvable by combining natural language interfaces with really sophisticated version control and programming languages that read like english for financial models and legal agreements, which enables program verification. This is a really hard technical challenge because version control like Git really doesn't work: you need to be able to synchronize multiple lenses of change sets where each lens/branch is a dynamic document that gets negotiated. Dynamically composable change sets all the way down.

We are definitely solving this at Phosphor (phosphor.co) and we're actively hiring for whoever is interested in working at the intersection of HCI, program verification, natural language interfaces and distributed systems.

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

Points: 3

# Comments: 1

Phosphor enables the development of the built world (e.g. from real estate to energy projects) to be managed agentically by building programming languages and observability primitives (like version control) on top of a hypergraph.

Our primary technical bet is that if you capture annotated "diffs" of user information with the appropriate annotation, you can create path-dependence to train AI models in an AlphaGo like context. By doing so, we achieve agentic experiences for markets that have never even had an opportunity to imagine what life would be like with basic observability.

Our product is similar a combination of Linear and Wolfram, with components and objects that enable advanced financial modeling, legal/regulatory analysis, and geospatial analysis of infrastructure development opportunities.

We're in stealth, but recently venture-backed by one of the best deeptech funds in the market. We're hiring for a few roles at the senior/staff levels: 1. HCI Engineer - You're a prosemirror wizard who probably follows Ink & Switch or the UCSB HCI lab on Twitter; front-end/rich-text/typescript focused; lots of architectural/sync engine work 2. Systems/Compiler Engineer - We design and build dev tools for languages we create that compile into various graph representations. These range from financial modeling calcs (which need to go very fast to support a seamless UX), to computable representations of legal agreements. Extra points if you've worked with hypergraphs. This in Rust but we're exploring a few other languages.

Email resume/linkedin/twitter to oliver@phosphor.co if you might fit somewhere in here, or if you've taken a credible attempt at building end-user programming tools.

Even on the edge cases, most of it just relates to what primitives are exposed in the API, and we've found the library's author to be highly engaged in creating solutions.

We've found it to be an incredibly well designed library.

I'd love to get some commentary from any active users on tradeoffs re: adopting tech like LiveView vs the community size and scale of JS land.

For example, JS land benefits massively from libraries like ProseMirror or even any of the more advanced CRDT libraries like Loro or Automerge. How about the AI story?

Is there a clear path to adopting this JS-based tech? Is it not needed? Would love to get a better understanding of the tradeoffs from folks who live in both worlds.

After over a year of trying to make it work, we completely rewrote the application in Typescript and Rust. The product we're building is an end-user programming tool where the traditional lines between front-end and back-end work blur, and the .NET ecosystem really didn't lend itself well to this.

Our hope was that we'd be able to use the Fable library to maintain type safety across a variety of technologies while being able to interop and in and out as needed: Fable compiles F# code to JS, Rust, .NET, etc. The reality was that the interop story between the various libraries we'd use was much harder to achieve than initially expected, and managing and updating multiple dependencies and their bindings was an absolute PITA.

The assumption that F# makes for beautiful, efficient code is still a safe one, I think. But the ecosystem and the way that it was designed makes it (in my view) applicable only for applications and software that have very traditional frontend/backend lines. F# would be used for the back-end only in that case.

Today, two of the technologies I'm most excited by (and which we're using internally) are the Effect library, whose Schema library fills in a lot of the gaps in TS's type system, and Moonbit, which is what I imagine a modern version of F# would like, free of the MS/.NET dependencies. Moonbit is really, really well designed (designed by the creator of OCAML's version of Fable, ReScript), and it compiles directly to highly optimized JS, WASM or Native output. We're using Effect in production, and not yet Moonbit, but the promise Moonbit holds as a language built for an AI-first world is pretty fantastic.

Would Perspective work for a similar use case as Causal's where the data tables have a large amount of interactivity, tree-based information and/or master-detail style UI concerns?

We're building a product that is more oriented around the interactive DAG concept and less about big data. The snappiness of those examples is very impressive.

With all the work they're doing on durable workflows, hard to imagine that 2025 is anyone else's year.