from your remarks I understand the tesselators are not programmable to do something like those Pixar Subdivison surfaces where you can have sharp edges using edge weighting, and doubling an edge loop for sharp creases is not really feasible for a game engine (waste of geometry)
DX11 tessellators are programmable, and quite flexible. That's not the problem. The problem is that you practically cannot tessellate down to single pixel triangles ("micropolygons"). GPU pixel shader execution is based on 2x2 quads. If a triangle hits even a single pixel in a quad, the whole quad is processed (and pixels outside the triangle are discarded). Tessellation down to single pixel would waste 75% of the pixel shader resources, in addition to being very heavy to triangle setup engines (and vertex/hull shaders). For good efficiency you want to keep triangles larger than 8 pixels (and preferably even larger).
Simple example:
Imagine a brick wall (a building wall for example). Each brick is 20x10 cm in size. There are deep 2 cm gaps between the bricks. A 10 x 10 meter building wall would have approximately 5000 bricks. When the building is far away we want to draw the wall using a single polygon (view from a city from a nearby hill, and there's hundreds of visible buildings).
When we move closer to the wall, the continuous tessellation starts to add new vertices, by sliding them from existing triangle vertices to their new place. Every time a vertex crosses over the deep gaps between the bricks, it goes rapidly down and then up again. This makes the surface look wobbly and unstable. To fix this problem, you need to add edges to each of the gaps (and in generally over all sharp geometry features). This completely fixes the wobbling issues... however now you have 2*5000 = 10000 fixed edges on the building wall (20000 triangles), and it is no longer efficient for far away rendering. You need LODs to solve this issue.
If you have a continuous smooth surface, you can usually perfectly LOD it by tessellation alone. This is often used for terrain rendering... however a high end terrain might have also sharp features such as cobblestone roads, and the problem arises again. We cannot tessellate the road down to 1 pixel micropolygons, and it looks wobbly if we try to keep the average triangle (screen space) size around 8 pixels. W could add add some geometry (edges) to the road, but then the roads would be expensive to render from further away. So basically our options are to add some geometry LODs, or use per pixel (ray cast) based techniques (such as POM or quadtree displacement mapping). Per pixel techniques have perfect LOD (1:1 screen pixel mapping, and around 1:1 memory access), however many of the currently used techniques are limited to height displacement only (cannot be used to form all kinds of meshes). DX11 conservative depth output improves the performance of per pixel techniques (for silhoutte cases and for real depth output), so we might also see them more in the future games.