Make the business model executable.
TCA is a declarative backend application framework being built to eliminate the separately authored layer that translates a business model into application behavior.
Developers describe business values, rules, relationships, and intended outcomes. The framework derives what can be constructed and which operations are justified by the available evidence.
When the business changes, change the model. Execution follows from its declarations.
A business rule rarely lives in one place. It appears in a model, then again in service methods, SQL transformations, integration mappings, pipelines, or workflow code. Changing the rule means finding and updating the implementations that give it effect.
TCA makes those relationships executable. A condition, the evidence that establishes it, and the operation it permits belong to the same declared program.
For an order that ships only after payment, the application describes the required payment evidence and its relationship to shipment. The engine obtains what is needed, waits when evidence is missing, and releases shipment when its prerequisites hold. The developer does not also write the sequence that coordinates those facts.
Database queries and external calls still happen through reusable capabilities. The work removed is the application-specific procedure that repeatedly translates business meaning into those operations.
An agent maintaining conventional software must keep the implementation faithful to a business description. With TCA, the agent changes the executable model itself.
Declared constraints govern which values can construct. Explicit prerequisites govern which operations can run. Execution retains the evidence that explains why an action was justified.
This gives humans and agents the same structured program to inspect, change, and test. Review still establishes whether the model expresses the right business requirements; the framework enforces the relationships that were actually declared.
TCA brings together type-driven development, declarative modeling, and domain-driven design around construction: valid values and business conclusions are built from the evidence they require.
Early work explored that approach as a pattern developers and agents could follow. The difficult part remained implementing the construction and execution mechanics correctly.
The project now puts that responsibility in an engine. Python and Pydantic supply native value construction; reusable primitives express computations and conditions; explicit relationships supply execution meaning. The same model governs immediate work and continuation as evidence arrives over time.
TCA is in active architectural development and implementation. There is not yet a working product ready to install and evaluate.
The world package implements native values, computations, conditions, and selections. Its foundation has passed architectural review; additional adversarial tests and an independent package CI gate are the current pre-merge work. The engine is not yet implemented.
The product and architecture documents describe that design and its required behavior. They are the best starting point for understanding and assessing the project.
| Read | What it explains |
|---|---|
| Product definition | The developer experience, capabilities, scope, and intended value |
| Architecture | The components, contracts, and execution semantics |
| Architectural decisions | The binding engineering requirements |
- ✅ Native world values, computations, conditions, and selections.
- Next: engine records and complete construction boundaries.
- Then: declaration compiler, evaluation, evidence admission, and local execution.
- Then: durable execution and recovery.
See the implementation plan for the seven stages and their completion criteria.
Apache License 2.0, for the whole repository, agent instructions and skills included.