The Provider Contract: designing for graceful degradation across the suite
How a shared Provider Contract lets each Agent Software Suite product keep working, in a reduced form, when another product it depends on is unavailable.
By Agent Software
Four products, four ways to fail together
A suite made of four separate products that talk to each other has an obvious risk: if every integration is a hard dependency, one product going down can take the rest with it. A terminal that hard-requires a memory service to function at all turns a memory-service outage into a terminal outage too — a fragile chain, not a resilient system.
What a Provider Contract actually is
The Provider Contract is a shared pattern used across the suite: any product that depends on another product's service defines that dependency through an explicit interface, and is built from the start to handle that interface being unavailable. It's a contract in the literal sense — an agreed shape for the dependency, plus an agreed behavior for when the other side isn't there.
Degraded mode, not dead mode
The practical result is what gets called degraded mode: when Agent Brain is unavailable, Agent Terminal keeps launching work and managing sessions rather than refusing to start. What it can't do — pull relevant memory context, for instance — it reports clearly as unavailable, rather than silently skipping it or pretending the context was retrieved when it wasn't.
Why honest failure reporting is the harder half
The easy part of graceful degradation is "keep running." The harder part is telling the user, clearly, what's not working and why — instead of either crashing loudly or failing silently in a way that's invisible until something downstream goes wrong. A Provider Contract that only handled the first half would just trade one kind of failure for a quieter one.
Why this belongs at the suite level, not per-product
If each product invented its own approach to handling a dependency outage, the suite would end up with four different failure philosophies, which makes reasoning about system-wide behavior much harder. A shared contract means a developer who understands how Terminal handles a Brain outage already understands the shape of how Familiar handles the same thing.
