Urbicana
UrbicanaClaw · Vision · 2026

UrbicanaClaw

An operating system for agents and the principals they act for

It does not do the work; it owns the resources around the work. The agent carries the tools; the principal keeps the discipline, the decisions and the signature; vendors become capabilities the agent calls.

01 Who acts The principal, their agent, a counterpart.
02 What is proven What the principal declares, and what a register attests.
03 What waits for a person The release. The agent drafts; the person releases.
Urbicana builds your AI operating system. You keep the decisions.
The agent, the computer it works on, and the rules it works under: who it is, what it may do alone, where it answers, and what it records.
Principal
A person, a firm, a building
D1 identity · D2 authority
asks · decides · releases
Files
Structured, unstructured
D4 · open formats hold truth
Computer use
Screen, browser, apps
D7 · isolated, one principal
Tools
CLI, MCP, vendor platforms
D5 · minimum scope, checked
Memory
What it accumulates
D4 · per principal, unshared
LLM
Any provider
D7 · the principal's choice
Sub-agents
Delegated work
D2 · policy at every step
Its own computer
Agent
D2 · allow · ask · deny
D8 · every effect recorded
agent-to-agent
Counterparts
Other principals' agents, their own installs
D6 · documents, not access
visitors in · it answers
Address
A website for people, an agent card for agents
D3 · reach
Black: what your agent can do. Coral: the rule you set for it.
How it is set up
One principal, one agent, one install
The operating system owns the resources around the work. The tools sit below it as capabilities the agent calls.
Principal · a person, a firm, a building
keeps the discipline, the decisions and the signature
Agent
carries the tools, acts in the principal's name
URBICANACLAW INSTALL · ONE PRINCIPAL · ONE TRUST BOUNDARY
D1 Identity
who it is, proven to others
D2 Authority
alone, ask first, or never
D3 Reach
where people and agents find it
D4 Knowledge
where the truth is kept
D5 Capabilities
what it drives and acquires
D6 Counterparts
whom it works with, how
D7 Compute and model
where it runs, on what
D8 Accountability
what is recorded, who signs
Design tools
authoring, models, drawings
Systems of record
the firm's own data
Public registers
filings, permits, deeds
Exchanges
conversions, with a receipt
Runtime below · OpenClaw · not ours, changed only through contracts its owners would accept
decides and releases
runs inside its own install
calls, under policy and budget

Executive summary

Seven positions define this vision

Unit Not a person, not a trusting team, but an industry of mutually untrusting firms coordinating on a shared artifact. Work between installs is the main event.
Purpose A redistribution of knowledge. The agent absorbs the tool tax; the human keeps the discipline, the decisions and the signature.
Vendors Callable capabilities behind open formats. The principal's agent owns the workflow.
Ground truth Industry standards, federated per firm, with native files as private working state.
Procurement Agents acquire capabilities at runtime under policy and budget, including paid relays.
Maintenance Agents repair shared procedures, and the repairs flow back to everyone who uses them.
Economics Exchanges, fidelity receipts, token budgets and markets for capabilities.

What Urbicana aims to be

The firm's own strategy, not the platform's

Urbicana helps firms define and deploy their agentic operating system strategy, and builds that operating system for the built environment: architecture, engineering, construction and real estate.

A platform's agentic strategy Adopt the platform's agents inside the platform's product
  • The platform decides who the agent is and what it may do
  • The platform keeps the truth and the record
  • The firm's intent enters through the platform's door
An agentic operating system strategy The firm's own answers to eight decisions, compiled to an install it owns
  • Every platform, including the ones already paid for, is a capability the agent calls
  • The firm's address belongs to the firm: a website for people, an agent for agents
  • Urbicana interviews, checks, compiles, deploys and proves
The register The public record of the built environment as cited, daily-refreshed knowledge any agent can read.
The registry Attested agents the industry queries before it hires, bids, lends or buys.
The procedures Shared, maintained with the industry's agents, lifting open tools to parity.
The exchange The counter where conversions and other capabilities are procured, with a receipt.
What success looks like
  • A project runs as a federation of installs, one per firm
  • The filing cycle runs agent to agent with the authority
  • A building has an agent of its own that answers for it
  • A professional practices on any tool without paying the tool tax
How Urbicana measures itself
  • Coordination hours that disappear
  • Agents standing on an attestation rather than an assertion
  • Procedures the industry's agents maintain in common

The argument

Who owns the top of the stack

VENDOR'S ASSISTANT AGENTAGENTAGENT you THE VENDOR'S STACK your agents plug into its assistant WHO OWNS THE TOP? the place where intent enters PRINCIPAL AGENT CADERPREGISTERCONVERT THE PRINCIPAL'S STACK vendors become capabilities it calls
01

What an operating system is for

An operating system does not do the work. It owns the shared resources so applications can multiply without each one re-solving identity, permissions, scheduling, storage and I/O. An assistant does tasks. A platform owns the user. An operating system owns the resources around the work and lets the principal own everything else.

the agent does the work THE OS OWNS WHAT IS AROUND IT IDENTITYAUTHORITYCAPABILITIESMEMORY CHANNELSSCHEDULEISOLATIONAUDIT TRAIL an assistant does tasks · a platform owns the user
The OS owns
For the agent
Users
Whose authority it acts under
Drivers
Capabilities it can call
Storage
Durable memory and state
I/O
Channels where people meet it
Scheduler
Work that runs without being asked
Processes
Isolation
Logs
An audit trail
02

The tool tax

For thirty years professional software has charged a tax in years of learning before it does anything. Two kinds of knowledge were bundled in "learning the tool", and vendors charged for both as one package. The agent separates them. The principal verifies the output, not the mechanism, the way they already verify a colleague's work.

BEFOREAFTER MENUSEXPORTSAPIs years paid to the tool judgment TOOLS the agent carries the tools the discipline stays with the person
MOVES TO THE AGENT Operational knowledge Which menu, which parameter, which export sequence, what the API wants.
STAYS WITH THE PRINCIPAL Judgment Whether the building works, whether the simulation was the right question, whether the number is plausible.
03

The inversion

For thirty years the vendor owned the workflow and the person adapted to it. Now the principal's agent owns the workflow and the vendors become callable. The vendors' answer is an assistant inside their own product into which you may plug your agents. Look at the direction of the arrows.

OWNERARCHITECTENGINEERCONTRACTOR ? re-keyedstale copydid anyone see this? hours in transit between four systems and four firms
04
procedure forty connectors = linear one fix, every install

Where impact scales

Forty connectors is a power user, and linear. Composition is not: one agent raising an open tool to parity becomes every agent's. Parity means conformant documents in the exchange standard, produced and consumed.

05
ARCHITECTENGINEERCONTRACTOR native, privatenative, privatenative, private STANDARD DOCIFC · BCF each writes its own; the exchanged doc is the truth

Ground truth

Where no vendor owns the truth, industry standards do. Each party authors in its own tool and publishes the standard document; nobody edits another party's model.

06
RELEASE the wire carries the task, not trust your installtheir install deny by default · scoped keys · a person's release

Between organizations

The agent-to-agent protocol is the wire; it does not carry trust. Trust is the arrangement around it: separate installs, deny by default, scoped credentials, and a person's release on anything binding.

07
.rvt CONVERSIONS losslesspriced per job .ifc keptlost receipt a counter an agent walks up to

Exchanges

Lossless conversion becomes a counter an agent walks up to: a declared interface, a price per conversion, and a receipt stating what was preserved and what was not.

08

Declared and attested, never merged

Identity has two parts: what the principal declares, and what a register can know. An agent that says "this license, these filings, this authority" is a different object from one that says "I am an architect", and a counterpart can tell the difference.

Declared I am an architect
Attested License [NUMBER], [STATE] Source: [REGISTER]

Why now

Six things became true in 2026 at the same time

The runtime exists An open agent runtime became the fastest-growing open-source project in history. The argument is now about what sits on top.
The wire exists; trust does not Agent-to-agent reached 1.0 in March. Delegation, authority and cross-organization identity are left to each implementation.
The window is about a year The dominant design vendor shipped agents inside its platform in September. Once its assistant is where intent enters, the inversion is lost.
Models carry the tool Drawings, filings, permits, deeds and inspections are digital, verifiable and valuable. The tax can move off the person today.
The standards are mandated Open exchange and information-management standards carry legal weight on public work. Ground truth is inherited, not invented.
Isolation became the minimum Agents in separate sandboxes traded credentials through a shared cache. A computer of one's own, with secrets held by the install, is the floor.

And almost nobody is on the other side of the wire yet: fewer than five hundred valid agent manifests among nearly twenty-eight thousand providers. The registry that fills first, with verified identities in one industry, is the one that industry's agents will call.

Specification

A strategy is eight decisions that compile

A strategy D = (D1 … D8) compiles deterministically to a configuration Conf(D) of an install. D and Conf(D) are the same object in two representations. A strategy that cannot be compiled is a document.

D1 … D8 ⇄ compile / read back ⇄ Conf(D) → running install
D1 Identity Who is the agent, in whose name does it act, how is that proven to a third party. Test: a third party fetches the manifest and can tell declared from attested.
D2 Authority What may the agent do alone, what waits for a person, what may it never do.
Allowed Awaiting release Denied
Test: each effect class shows all three outcomes. Default is deny.
D3 Reach Where does the agent live, at which addresses does it answer, who may find and call it. Test: an unnamed caller is refused; a named peer's request lands under D2.
D4 Knowledge What does the agent know, where is truth kept, in which formats. Test: the authoritative copy exists in the designated format; statements trace to a source.
D5 Capabilities Which systems does it drive, which procedures does it hold, how does it acquire what it lacks. Test: every procedure's check passes; acquiring an unlisted capability is gated.
D6 Counterparts Which other principals' agents does it work with, under what agreement and vocabulary. Test: a request round-trips between installs, correlation id preserved, release observed.
D7 Compute and model Where does it run, on which models, who pays, where does the data reside. Test: secrets absent from every transcript; runs on an alternative provider.
D8 Accountability What is recorded, who signs, who is liable. Test: effect → decision → approval → approver → artifact, from the record alone.

The release is the binding act

Anything with contractual weight crossing the boundary waits for a person on the sending side. The agreement between principals states that the release, not the message, binds. Every task carries a correlation identifier both records keep.

Awaiting your release Awaiting release
Effect[EFFECT, e.g. submit filing] Counterpart[COUNTERPART AGENT] Correlationcorr [ID] May release[NAMED PERSON]

Lifecycle

1DefineAnswer D1 … D8, each checked against its invariants.
2CompileThe same D always yields the same configuration.
3DeployThe install runs Conf(D).
4ProveRun the acceptance tests against the live install.
5ReviseChange D, recompile. Drift is a defect, not a variant.
CompleteAll eight answers pass their invariants and compile.
ProvenA recorded run exercises every test, including one counterpart exchange.
In forceComplete, proven, and the current version is the one running.
Between organizations
One request, two installs, one release
The wire carries the task. The policy, the person's release and the record stay on each side of it.
ARCHITECT'S INSTALL
THE WIRE · AGENT-TO-AGENT · CARRIES NO TRUST
ENGINEER'S INSTALL
Agent drafts
an RFI to the engineer
Policy
at the effect
Awaiting release
the named approver
Person releases
the binding act
Joined to the record
effect, approval, artifact
Denied · recorded
task · corr [ID]
reply · corr [ID]
Named peer?
enters as a request
Engineer's agent
answers in a standard document
approval
deny
released
Allowed · proceeds alone
Awaiting release · waits for a person
Denied · refused and recorded
The release, not the message, is the binding act. Neither install ever writes to the other's systems.
From interview to install
A strategy that compiles, deploys and proves
What Urbicana sells is not a document. It is the eight answers, the install they compile to, and the proof that it works.
D and Conf(D): one object, two forms
Interview
eight questions
Strategy
D1 … D8
Compile
Conf(D)
Deploy
an install of its own
Prove
every acceptance test
In force
complete, proven, current
Revise: change D, recompile
Drift is a defect, not a variant. A change to identity, authority, counterparts or accountability renews the approvals that depended on it.

Not a strategy

What does not compile

A list of capabilitiesD5 only
A model choicepart of D7
A vendor's assistant in its productD1 D2 D4 D8 are the vendor's
A platform's "agentic strategy"none answered
A consulting documentdoes not compile

What UrbicanaClaw supplies

Interview, check, compile, deploy, prove

D1Principal–agent pairing; the manifest with declared and attested facts kept apart.
D2The approval surface and the standing orders the principal writes.
D3The endpoint, the peer table, the registry of agents by what they do.
D4Answered by the principal. The distribution designates nothing on their behalf.
D5Procurement under policy and budget; the shared procedure registry.
D6Wiring between installs: protocol, scoped credentials, correlation ids, the release gate.
D7An isolated install per principal; secrets held by the install; the principal's model.
D8The record joining effect, decision, approval, approver and artifact.
The ecosystem
A project is a federation of installs
Each firm runs its own install and writes only to its own systems. Standard documents cross the wire; Urbicana's shared layer sits between them, owned by none.
OWNER · INSTALL
Owner + agent
native files · private
ARCHITECT · INSTALL
Architect + agent
native model · private
ENGINEER · INSTALL
Engineer + agent
native model · private
URBICANA · SHARED BY EVERY INSTALL, OWNED BY NONE
Register
the cited public record
Registry
attested agents, by what they do
Procedures
shared, checked, repaired
Exchange
capabilities with a receipt
CONTRACTOR · INSTALL
Contractor + agent
native files · private
AUTHORITY · INSTALL
Authority + agent
public record · authoritative
BUILDING · INSTALL
Building + agent
its permits, inspections, documents
RFIs
IFC models
filings
inspections
reads · lists · procures
Standard documents cross the boundary. Native files never do. Anything binding waits for a person's release on the sending side.

The built environment

What this opens for architecture, engineering, construction and real estate

A project is a federation of installs.Each firm owns its model and writes only to its own systems. Standard documents are the shared truth; the stamp stays with the licensed person.
The filing cycle runs agent to agent.Application, objections, permit, inspections, sign-off, with the licensed person's stamp at each step. The authority is not a vendor.
Counterparts are already known.The register records who filed with whom. For a firm in it, the peer table writes itself.
Identity is attested by the authority.License numbers and recorded filings, carried separately from what the principal declares.
Open design tools reach parity.A conformant exchange model, produced and consumed. Where the kernel is weak, the claim is not made.
Conversion becomes a counter.Translation kernels behind a declared interface, priced per conversion, with a receipt.
A building is a principal.Its install watches permits, inspections and violations, and answers a buyer's agent with citations.
Real estate transacts on the record.Deeds, mortgages, liens, zoning and permits, joined on the parcel, read by every party's agent.
Associations and authorities as hubs.Published schemas for RFIs, submittals and filings: once two firms share a vocabulary, every pairing does.

The position

A platform cannot put its own products beneath someone else's agent. The project crosses the boundary.

Urbicana keeps everything vertical at the edges. The runtime below is not ours and is changed only through contracts its owners would accept.