We're now at version 0.2, but this is every bit as much of a beta as version 0.1, since large chunks of the most important part of the compiler, the code generator, have been entirely rewritten.
More in detail, the functional subset of the language is the only part that has been been used to write a non-trivial application (the Cell compiler itself), and it has been working reliably for me for at least a couple years now, but it needs to be tested by more people, with different programming styles.
Relational automata have so far been used only to write small toy applications, and still need to be tested extensively.
Reactive automata are at this stage very experimental. Not only they too haven't been tested anywhere enough but unlike their relational counterparts their design is still tentative and in a state of flux, and their implementation much more complex.
The documentation on this website is another work in progress. It covers almost all the features of the language, but rational, design guidelines and examples are still incomplete at this stage. And there's no documentation for the standard library yet.
So, again, this is a beta version, don't use it for anything important quite yet.
The next version of Cell, 0.3, will be about implementing the basic features of relational automata that are still missing. Most of these features are described either in the introductory example or in the relational automata page: things like foreign keys, better support for hierarchical classification and polymorphic entities, less verbose delete statements, support for symmetric relations, maybe (just maybe) aggregate query operators, and so on.
Version 0.4 will be the first version of the language meant for actual use. It won't introduce any new major language feature, but it will focus on things like testing, providing a minimal standard library with documentation, and improving the interface with the host language. It will also provide a code generator for C. Other languages may also be considered at that point.
After that, for relational automata, the most important new features will be Datalog-like inference rules with memoization, and more powerful update models. The current update model has clear limitations, but it has a couple of important properties: state transitions are atomic (that is, only the states before and after the transition can be observed, and all intermediate ones are just an implementation detail that is hidden from the developer) and it is amenable to a parallel implementation. The new models will preserve these properties, while adding more flexibility and modularity.
As for reactive automata, the list of planned new features is simply too long, too weird and too tentative to be discussed extensively here. Suffice it to say that reactive automata in their current form are just a preview, and that there's a lot more to come.
Longer term plans are still hazy at this point, but they include an implementation that can deal efficiently with large persistent data sets, and declarative ways to build distributed applications, among other things.