One-liner for you:

 Math.max.apply(Math, $.map(array, function (el) { return el.length }));

Working example: http://jsfiddle.net/5SDBx/

You can do it without jQuery in newer browsers (or even older browsers with a compatibility implementation of Array.prototype.map) too:

Math.max.apply(Math, array.map(function (el) { return el.length }));

The maximum length until "it gets sluggish" is totally dependent on your target machine and your actual code, so you'll need to test on that (those) platform(s) to see what is acceptable.

However, the maximum length of an array according to the ECMA-262 5th Edition specification is bound by an unsigned 32-bit integer due to the ToUint32 abstract operation, so the longest possible array could have 2³²-1 = 4,294,967,295 = 4.29 billion elements.

There is no native way to do this so your general logic seems sound. Here's some improvements, you might consider:

1. Make sure the pushMax function is not enumerable so people who iterate arrays with for (var index in array) won't see the pushMax property.

2. Ensure the array stays below max length even if it was previously above max

3. Return the new length of the array, the same as .push():

Here's a working snippet:

Object.defineProperty(Array.prototype, "pushMax", {
    configurable: false,
    enumerable: false,
    writable: false,
    value: function(value, max) {
        if (this.length >= max) {
           this.splice(0, this.length - max + 1);
     	}
     	return this.push(value);
    }
});



var x = [0,1,2,3,4,5,6,7,8,9,10];
x.pushMax(11, 10);
x.pushMax(12, 10);
x.pushMax(13, 10);

// wrong way to iterate an array, but just testing enumerability
for (var i in x) {
    document.write(i + ": " +  x[i] + "<br>");
}

You could also consider making the max length be a non-enumerable property of the array so you don't have to pass it to .pushMax() every time.

I'd really rather see this in a subclass of an Array rather than modifying the built-in Array object, but alas we can't subclass the Array object yet in most browsers.

Available since Javascript 1.8/ECMAScript 5 and available in most older browsers:

var longest = arr.reduce(
    function (a, b) {
        return a.length > b.length ? a : b;
    }
);

Otherwise, a safe alternative:

var longest = arr.sort(
    function (a, b) {
        return b.length - a.length;
    }
)[0];