Engineering
Scheduling is unglamorous and easy to get subtly wrong, which is exactly why so few tools do it. Everything an agent recommends rests on the plan being computed correctly, the data being isolated correctly and every change being on the record, so those came first. A few of the decisions underneath ProjectMetrix.
Two pieces are open source, if you would rather read code than prose: the scheduling engine, which is dependency-free, has 25 tests, and carries a performance budget asserting a 1,200-task plan computes in milliseconds. And the interactive prototype (source) that every screenshot on this site was captured from.
Clients write inputs: durations, dependencies, constraints, calendars. Every computed field is written only by the scheduling engine, which is pure and deterministic: same plan in, same dates out, byte for byte. That's what makes what-if simulation trivial and testing honest.
The engine has no database access and no clock. Simulating a change is copying the plan, applying the change and running it again, with no special code path and nothing written. That is why every agent proposal can show its consequences before a human approves it.
A full recompute of a 1,000-plus task network runs in milliseconds. The first implementation was two orders of magnitude slower; profiling pointed at calendar arithmetic, and memoizing the working-day map fixed it. Measured, not assumed.
Tenant isolation is enforced by the database itself through row-level security, not by remembering to add a filter in application code. Cross-tenant reads return nothing and cross-tenant writes are rejected, verified by tests that deliberately try.
An append-only audit log captures who changed what, when, and what it looked like before, including which AI assistant proposed it and which human approved. It's the compliance story and the training corpus at the same time.
Single sign-on via OIDC, federating whatever directory a company already runs. Access and permissions follow existing groups, joiners and leavers sync automatically, and people who should be nameable (sponsors, vendors, SMEs) don't need accounts.
A single specification drives the product surface and the assistant's tool registry, so anything the interface can do can be asked for in plain language. Chat capabilities can't drift from the product because they're generated from the same source.
Schema versions are explicit, migrations are forward-only and checksum-protected, and the service refuses to start against a database version it wasn't built for. Failing loudly at boot beats serving errors from columns that don't exist yet.
A stateless API, configuration entirely from the environment, and no local disk state, so scaling out is more instances behind a load balancer, and running inside a customer's own environment is a deployment choice rather than a rewrite.
The browser draws; the API authorizes, persists and audits; the engine computes. Nothing else is allowed to produce a date, which is what makes every number on screen explainable and reproducible.
The plan grid and Gantt render what they are told and capture edits. They perform no date arithmetic. A dragged bar reports where it was dropped and waits to be told what the plan now looks like.
Authentication, tenancy, validation, transactions and the audit trail. It applies the edit, loads the plan, calls the engine, and saves the results and the audit entry in a single transaction, so the stored dates always follow from the stored inputs.
A pure module with no database, no clock and no network. Plan in; dates, float, critical path and a list of conflicts out. A bad plan is always reported, never thrown away.
PostgreSQL holds the declared inputs and the computed results, with tenant isolation enforced in the database. Computed values are a cache of the last run, always deletable always reproducible.
Agents are ordinary API clients with scoped tokens. They read through the same contract the UI uses and write only proposals, so there is no privileged back door into the plan.
Imports, scheduled syncs and agent runs execute on a queue, separately from the request path, so a large import never slows anyone's page load.
Happy to go deeper on any of it, the scheduling engine especially. The open-source engine is the shortest route to seeing how the determinism and the test approach actually work.