Pascal AI Labs

The intelligence layer for buildings.

Pascal exists to make buildings autonomous. The bet: the more verifiable, instrumented, and partially-autonomous Pascal becomes internally, the cheaper and safer it gets to ship building autonomy externally.

The recursion

The shape of the product mirrors the shape of the company that builds it.

We are building an operating system for buildings. So we run Pascal as an operating system — a small kernel of humans plus many concurrent processes — agents — operating on shared, verifiable state.

The framework is only proving itself if our customers feel it: fewer missed visits, faster dispatch, lower manual scheduling load, higher first-time-resolution. If a quarter passes with internal-velocity wins and no movement on field metrics, the recursion is failing — and the framework gets cut, not extended.

Eight principles

Non-negotiable inside Pascal.

Verifiability is the autonomy gate.

You may automate exactly what you can automatically verify. No more, no less. A green test proves the spec was met, not that the spec was right — so the choice of frame stays human.

One source of truth.

Humans and agents read the same files. No separate handbook. If a rule lives in a Slack pin instead of the repo, the contract is forked.

Specs are durable. Vibes are disposable.

For anything that lives more than a day, write the spec first. Vibe-mode for scaffolds and throwaway scripts. Never confuse the two.

Build the factory while shipping the product.

Each quarter, name one factory item that removes a measurable pain. Ship it. The compounding curve is on the factory side, embedded in feature work — not as a separate AI initiative.

The agent is a teammate, not a copilot.

Brief it like a colleague. Give it a workspace. Hold it to the same standard. Roles, not models — when a better model arrives, swap it without rewriting the playbook.

Context engineering, not prompt engineering.

The unit of work is the context window. Curate the inputs and the output follows. Most "the model got it wrong" failures trace to the wrong docs being loaded.

Small pods. Deep ownership. Founder in the diff.

We don't scale velocity with headcount. Agents are the additional headcount. We add a human only when the role can't be done by a human-with-N-agents.

One velocity number. Watch its trend.

You can't manage what you don't measure; you destroy what you over-measure. Metric is a thermometer, not a target. The "% of code by AI" number is gameable and worthless.

How to use this

A living document. The recursion only works if the manual edits itself.

Pascal is what a building's operating manual looks like — the durable contract between humans, agents, and the building's verifiable systems. We're publishing the company's manual because the two are the same shape, on purpose.