IBM/Rational currently offer two products to support analysis and design using UML. The first, and older, product is called Rational Rose. The second, newer product is called Rational Software Architect. Each has its merits, and drawbacks, so it is only prudent to evaluate the differences in order to make an informed selection or to use the chosen tool properly.
Product Support. Rational Rose is the elder product and has been around since the early/mid 90's - Rational Software Architect is a much newer product. Because Rose is older, there is a much larger installed base of documentation (books, white papers, commercial courses, etc.) on how to use the tool and a much larger installed base of practitioners. Organizations are also much more likely to have an installed base of product (i.e. licenses) which they apply to a project/program needs for modeling. IBM is very enthusiastic about supporting Architect but the reality of the total support situation in the IT world is that (for now) Rose still has more resources in this area.
Support for UML 2. Rational Rose is fundamentally a UML 1.x tool and Rational Software Architect is intended as more of a UML 2 tool. The differences here are not enormous (since most of UML 1 is still a part of UML 2) and may not mean very much if your project lacks UML 2 needs or practitioners. The gap is also narrowed in that many of the enhancements in UML 2 (e.g. regions in sequence diagrams) can be improvised fairly easily in Rational Rose. Finally both omit support for some UML 2 features - including some of the ones which are the most novel and potentially valuable.
Language (C++, Java, etc.) Support. Rational Rose provides at least some level of modeling (code-generation and reverse-engineering) for a very large number of programming languages - including C++ (ANSI and Microsoft API), Java (J2SE and versions of J2EE), XML, Database, Ada, Visual Basic, etc. While the language support in Rose is broad, it isn't very deep and the tool is best thought of as a design tool that can be coupled to some of the code - I've rarely found full code generation (or reverse engineering) between any language and Rose to be effective. In contrast, Architect primarily supports Java and C++ only but does so much more deeply. In this regard Architect draws from the XDE legacy and can not only be used as a design tool but as uber-IDE tool. Whether tight integration between the analysis/design effort and the coding is necessary, or a good idea, depends upon the project.
Support for modern design techniques. In this area Architect enjoys an advantage - though some improvisation can be done in Rose. For example, while patterns have been part of the UML/OOAD world for many years now, Rose does not have any specific support for patterns - the modeler has to do all the work "by hand". Architect is more similar to the contemporary competitors (e.g. Borland Together) in providing more explicit support for pattern-based modeling. Similarly, Rose draws from a tradition of analysis/design as more discrete from requirements, testing, etc. - Architect draws more from the traditions of RUP and XP. On can argue about if iterative and overlapping the development disciplines is a good idea but, if you've chosen this route, you will probably find Architect better suits your needs.
Extensibility. Both tools provide mechanisms for you to customize or extend the tool but do so differently. Rose provides the Rose Extensibility Interface (REI) which is basically a VB-like scripting engine. It is pretty powerful as demonstrated by that most of the items on the Tools menu were at one time products of a cottage industry in Rose scripting. Architect takes a slightly different path in that it runs as part of the Eclipse platform or workbench. An increasing number of tools (IDEs, modeling, testing, etc.) also run under Eclipse and while using them doesn't per se extend Architect they are extending the "workbench" in which Architect is running. Further, one can write their own plug-ins to the the Eclipse workbench - extending either the Rational products (like Architect) or the workbench as a whole. This is a conceptual difference you may have to see and use to fully evaluate.
These are some of the differences. There are of course more but this should give you an idea of the relative strengths/weaknesses of the two products relative to your needs. If you want to get started with either or learn more about the these two products, I recommend the following books:
Visual Modeling with Rational Rose 2002 (3rd edition) by Terry Quatrani. Even though this says "Rose 2002" it is a good introduction to all of the Rose products including this year's 2006/v7 product.
Visual Modeling with Rational Software Architect and the UML by Terry Quatrani. This book covers is comparable to the Rose 2002 book (covering many of the same topics and examples) but for the Architect product.
Also, relative to the cost of a project, taking courses in both tools is a pretty economical way to learn about the capabilities of each.