diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5d25eac..293538f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,10 @@
+## 1.7.1
+
+* Make `Trace.parse()`, `Chain.parse()`, treat the VM's new causal asynchronous
+  stack traces as chains. Outside of a `Chain.capture()` block, `new
+  Chain.current()` will return a stack chain constructed from the asynchronous
+  stack traces.
+
 ## 1.7.0
 
 * Add a `Chain.disable()` function that disables stack-chain tracking.
diff --git a/lib/src/chain.dart b/lib/src/chain.dart
index 7045e19..4543eff 100644
--- a/lib/src/chain.dart
+++ b/lib/src/chain.dart
@@ -6,6 +6,7 @@
 import 'dart:math' as math;
 
 import 'frame.dart';
+import 'lazy_chain.dart';
 import 'stack_zone_specification.dart';
 import 'trace.dart';
 import 'utils.dart';
@@ -134,7 +135,15 @@
   /// single-trace chain.
   factory Chain.current([int level=0]) {
     if (_currentSpec != null) return _currentSpec.currentChain(level + 1);
-    return new Chain([new Trace.current(level + 1)]);
+
+    var chain = new Chain.forTrace(StackTrace.current);
+    return new LazyChain(() {
+      // JS includes a frame for the call to StackTrace.current, but the VM
+      // doesn't, so we skip an extra frame in a JS context.
+      var first = new Trace(
+          chain.traces.first.frames.skip(level + (inJS ? 2 : 1)));
+      return new Chain([first]..addAll(chain.traces.skip(1)));
+    });
   }
 
   /// Returns the stack chain associated with [trace].
@@ -147,8 +156,8 @@
   /// If [trace] is already a [Chain], it will be returned as-is.
   factory Chain.forTrace(StackTrace trace) {
     if (trace is Chain) return trace;
-    if (_currentSpec == null) return new Chain([new Trace.from(trace)]);
-    return _currentSpec.chainFor(trace);
+    if (_currentSpec != null) return _currentSpec.chainFor(trace);
+    return new LazyChain(() => new Chain.parse(trace.toString()));
   }
 
   /// Parses a string representation of a stack chain.
@@ -158,6 +167,10 @@
   /// and returned as a single-trace chain.
   factory Chain.parse(String chain) {
     if (chain.isEmpty) return new Chain([]);
+    if (chain.contains(vmChainGap)) {
+      return new Chain(
+          chain.split(vmChainGap).map((trace) => new Trace.parseVM(trace)));
+    }
     if (!chain.contains(chainGap)) return new Chain([new Trace.parse(chain)]);
 
     return new Chain(
diff --git a/lib/src/lazy_chain.dart b/lib/src/lazy_chain.dart
new file mode 100644
index 0000000..55b9897
--- /dev/null
+++ b/lib/src/lazy_chain.dart
@@ -0,0 +1,33 @@
+// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'chain.dart';
+import 'frame.dart';
+import 'lazy_trace.dart';
+import 'trace.dart';
+
+/// A thunk for lazily constructing a [Chain].
+typedef Chain ChainThunk();
+
+/// A wrapper around a [ChainThunk]. This works around issue 9579 by avoiding
+/// the conversion of native [StackTrace]s to strings until it's absolutely
+/// necessary.
+class LazyChain implements Chain {
+  final ChainThunk _thunk;
+  Chain _inner;
+
+  LazyChain(this._thunk);
+
+  Chain get _chain {
+    if (_inner == null) _inner = _thunk();
+    return _inner;
+  }
+
+  List<Trace> get traces => _chain.traces;
+  Chain get terse => _chain.terse;
+  Chain foldFrames(bool predicate(Frame frame), {bool terse: false}) =>
+      new LazyChain(() => _chain.foldFrames(predicate, terse: terse));
+  Trace toTrace() => new LazyTrace(() => _chain.toTrace());
+  String toString() => _chain.toString();
+}
diff --git a/lib/src/stack_zone_specification.dart b/lib/src/stack_zone_specification.dart
index 7125249..948ef30 100644
--- a/lib/src/stack_zone_specification.dart
+++ b/lib/src/stack_zone_specification.dart
@@ -4,8 +4,10 @@
 
 import 'dart:async';
 
-import 'trace.dart';
 import 'chain.dart';
+import 'lazy_trace.dart';
+import 'trace.dart';
+import 'utils.dart';
 
 /// A function that handles errors in the zone wrapped by [Chain.capture].
 typedef void _ChainHandler(error, Chain chain);
@@ -170,7 +172,7 @@
   /// [_createNode] is called. If [level] is passed, the first trace will start
   /// that many frames up instead.
   _Node _createNode([int level=0]) =>
-    new _Node(new Trace.current(level + 1), _currentNode);
+    new _Node(_currentTrace(level + 1), _currentNode);
 
   // TODO(nweiz): use a more robust way of detecting and tracking errors when
   // issue 15105 is fixed.
@@ -201,7 +203,7 @@
   final _Node previous;
 
   _Node(StackTrace trace, [this.previous])
-      : trace = trace == null ? new Trace.current() : new Trace.from(trace);
+      : trace = trace == null ? _currentTrace() : new Trace.from(trace);
 
   /// Converts this to a [Chain].
   Chain toChain() {
@@ -214,3 +216,22 @@
     return new Chain(nodes);
   }
 }
+
+/// Like [new Trace.current], but if the current stack trace has VM chaining
+/// enabled, this only returns the innermost sub-trace.
+Trace _currentTrace([int level]) {
+  level ??= 0;
+  var stackTrace = StackTrace.current;
+  return new LazyTrace(() {
+    // Ignore the VM's stack chains when we generate our own. Otherwise we'll
+    // end up with duplicate frames all over the place.
+    var text = stackTrace.toString();
+    var index = text.indexOf(vmChainGap);
+    if (index != -1) text = text.substring(0, index);
+
+    var trace = new Trace.parse(text);
+    // JS includes a frame for the call to StackTrace.current, but the VM
+    // doesn't, so we skip an extra frame in a JS context.
+    return new Trace(trace.frames.skip(level + (inJS ? 2 : 1)));
+  });
+}
diff --git a/lib/src/trace.dart b/lib/src/trace.dart
index ad55fc7..eb8ecd8 100644
--- a/lib/src/trace.dart
+++ b/lib/src/trace.dart
@@ -51,7 +51,7 @@
     r"$", multiLine: true);
 
 /// A RegExp to match this package's stack traces.
-final _friendlyTrace = new RegExp(r"^[^\s]+( \d+(:\d+)?)?[ \t]+[^\s]+$",
+final _friendlyTrace = new RegExp(r"^[^\s<][^\s]*( \d+(:\d+)?)?[ \t]+[^\s]+$",
     multiLine: true);
 
 /// A stack trace, comprised of a list of stack frames.
@@ -137,7 +137,9 @@
       : this(_parseVM(trace));
 
   static List<Frame> _parseVM(String trace) {
-    var lines = trace.trim().split("\n");
+    // Ignore [vmChainGap]. This matches the behavior of
+    // `Chain.parse().toTrace()`.
+    var lines = trace.trim().replaceAll(vmChainGap, '').split("\n");
     var frames = lines.take(lines.length - 1)
         .map((line) => new Frame.parseVM(line))
         .toList();
diff --git a/lib/src/utils.dart b/lib/src/utils.dart
index 5189760..838a093 100644
--- a/lib/src/utils.dart
+++ b/lib/src/utils.dart
@@ -6,6 +6,10 @@
 /// the gap between traces.
 const chainGap = '===== asynchronous gap ===========================\n';
 
+/// The line used in the string representation of VM stack chains to represent
+/// the gap between traces.
+const vmChainGap = '<asynchronous suspension>\n';
+
 // TODO(nweiz): When cross-platform imports work, use them to set this.
 /// Whether we're running in a JS context.
 final bool inJS = 0.0 is int;
diff --git a/pubspec.yaml b/pubspec.yaml
index 6984445..4289a6e 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -7,7 +7,7 @@
 #
 # When the major version is upgraded, you *must* update that version constraint
 # in pub to stay in sync with this.
-version: 1.7.0
+version: 1.7.1
 author: "Dart Team <misc@dartlang.org>"
 homepage: https://github.com/dart-lang/stack_trace
 description: >