Collaboration

Architecture is collaborative by nature. A project develops through the combined judgment of architects, designers, engineers, consultants, fabricators, contractors, clients, and countless others. Corvus gives everyone one living project to work from, with drawings, models, objects, worksheets, quantities, comments, and presentations connected to the same underlying information. Work together in real time when you need to. Work independently when you do not. See what others are doing, understand what changed, and keep the project moving without turning collaboration into another job.

The project should bring people together.

Architecture depends on conversation. A senior architect sketches an idea. A junior designer develops it. An engineer tests it. A client questions it. A fabricator finds a better way to make it. These contributions should happen around the work itself, not across a trail of files, screenshots, emails, and meeting notes. Corvus gives everyone an appropriate way into the same project, preserving the context that makes each contribution useful.

Work together without waiting for one another.

Most changes do not truly conflict. One person can refine a façade while another develops the plan. Someone can edit a worksheet while someone else resolves a detail. Corvus lets independent work proceed independently, without unnecessarily locking large parts of the project or forcing people to coordinate every action in advance. Everyone can keep moving while remaining aware of the work happening around them.

No checkout. No check-in. No locking by default.

Collaboration should not require borrowing an object, claiming a workset, creating a local copy, or remembering to relinquish what you touched. Corvus synchronizes changes at the level of objects, properties, and operations rather than passing an entire model file back and forth. Independent changes appear as they happen, and broad ownership rules do not stand between you and the work you need to do.

See the work while it is happening.

Presence should communicate without becoming noise. See who is in the project, where they are working, and what they are changing. Understand when someone is active nearby before you begin making a related decision. Corvus provides the awareness people need to coordinate naturally, without filling the screen with distractions or turning every action into a notification.

Let independent changes remain independent.

Two people working at the same time does not automatically mean their work is in conflict. Corvus understands the identity of objects, the operations being performed, and the relationships between them. Changes that do not interfere with one another can proceed without interruption. Collaboration becomes faster because the software distinguishes an actual collision from the simple fact that more than one person is working.

When changes collide, show exactly where.

Some conflicts are real. Two people may change the same property differently. One person may remove an object while another creates something that depends on it. Corvus identifies the specific objects, relationships, and decisions involved rather than blocking an entire area of the project. Routine changes can resolve naturally. Decisions that require design judgment remain visible and in the hands of the people making them.

A change should arrive with everything it changes.

Move a wall and the consequences may extend to doors, dimensions, rooms, areas, quantities, drawings, and schedules. Corvus understands these dependencies and carries related updates through the project together. Collaborators see one coherent result rather than receiving the original change first and discovering its disconnected consequences later. The project stays understandable while many people continue shaping it.

Undo your work without undoing everyone else’s.

In a shared project, history should belong both to the project and to the people working within it. Step back through your own actions without rewinding the work of the entire team. See what changed, who changed it, and when it happened. Corvus preserves the sequence and authorship of decisions so experimentation remains safe, accountability remains clear, and one person’s correction does not become everyone’s setback.

There should never be a latest file.

A local model, a central model, a downloaded copy, an emailed attachment, and yesterday’s PDF should not compete to represent the same project. Corvus keeps the authoritative project in one shared environment. Open it and see what is current. Return tomorrow and continue from where the work actually is. Versions remain available through history without multiplying into separate files that someone must later compare and reconcile.

Everyone can see the just the parts that they need to.

An architect may need to edit geometry. An engineer may need to inspect relationships. A client may need to explore and comment. A contractor may need to understand what changed. Corvus gives each collaborator the view, information, and level of access appropriate to their role without creating a separate project for each of them. Different people can work differently while continuing to work from the same underlying truth.

Bring clients into the project, not another presentation.

Share the current work through a browser and let clients explore, review, and comment in context. A question can remain attached to the room, object, drawing, or decision it concerns. Make a change during the conversation and see its spatial, visual, and numerical consequences together. The project itself becomes the place where understanding develops, rather than something repeatedly flattened into slides and PDFs for discussion.

A comment should know what it is about.

Feedback loses value when it becomes separated from the work that prompted it. Corvus keeps comments connected to the relevant object, view, location, moment, and project state. Return to a conversation and understand what everyone was seeing when it began. Resolve the issue without reconstructing its context from screenshots, email threads, meeting notes, and someone’s memory of an earlier version.

Explore alternatives without dividing the project.

Design rarely develops in a single direction. Let different people or teams explore possibilities in parallel while preserving their relationship to the shared project. Compare options with their geometry, drawings, quantities, and presentations intact. Carry the strongest direction forward without manually rebuilding it or allowing every study to become another disconnected file that must be maintained.

A drawing, model, and worksheet should never disagree.

Collaboration happens across representations as much as it happens across people. One person may work spatially in the model while another works systematically in a worksheet and another refines the drawing. In Corvus, they are acting on the same objects and information. A decision made in one view becomes visible in the others, reducing the coordination work created when each representation becomes a separate source of truth.

Keep senior architects close to the act of designing.

Software should not force a studio to separate the people who make decisions from the people who operate the tools. Corvus makes the shared project direct enough for experienced architects to remain inside the work and accessible enough for newer contributors to participate meaningfully. Direction, development, learning, and execution can happen together, strengthening both the project and the people growing through it.

Let small studios collaborate like large ones without becoming large ones.

The coordination capacity of a practice should not depend on dedicated model managers, elaborate server infrastructure, or layers of specialist administration. Corvus takes responsibility for shared state, history, permissions, relationships, and dependencies beneath the surface. Small teams can work with extraordinary depth and sophistication while preserving the intimacy, direct communication, and creative mixture that make them valuable.

Stop coordinating the project with itself.

Architects spend enormous amounts of time checking that models agree with drawings, drawings agree with schedules, schedules agree with spreadsheets, and the latest PDF agrees with whatever changed after it was issued. Much of this work exists only because connected information has been allowed to become separate. Corvus brings the project back together. Change it once and let every collaborator, representation, and connected view tell the same story.

Collaboration should be part of the architecture.

Real collaboration cannot be added at the edge of a monolithic file. It depends on objects with persistent identities, relationships the system understands, operations that can be shared precisely, and a history that preserves how the project developed. Corvus is being built around these ideas from the beginning. Collaboration is not another mode to enter or service to manage. It is part of what the project is.

Join our waitlist.

You’ve already waited 49 years. What’s another two? AEC professionals have spent decades jumping through hoops and creating workarounds for convoluted software. No one dares to build something that will challenge the status quo. It's time for something fundamentally different and unapologetically human. Join the waitlist.