diff --git a/lib/axe.js b/lib/axe.js
index 535fd909..88b6c9ea 100644
--- a/lib/axe.js
+++ b/lib/axe.js
@@ -13,6 +13,8 @@ function start(root){
 	console.log("AXE relay enabled!");
 	var axe = root.axe = {}, tmp, id;
 	var mesh = opt.mesh = opt.mesh || Gun.Mesh(root); // DAM!
+	var dup = root.dup;
+
 	mesh.way = function(msg){
 		if(!msg){ return }
 		if(msg.get){ return GET(msg) }
@@ -30,26 +32,47 @@ function start(root){
 		if(!(ref = (ref||'')._)){ return fall(msg) }
 		ref.asked = +new Date;
 		(ref.route || (ref.route = new Object.Map)).set(via.id, via); // this approach is not gonna scale how I want it to, but try for now.
-		var c = 0, route = ref.route;
-		setTimeout.each(Object.maps(route), function(id){ var peer;
-			if(!(peer = route.get(id))){ return }
-			if(!peer.wire){ route.delete(id); return } // bye!
-			if(!mesh.say(msg, peer)){ return } // self
-			c++;
+		GET.turn(msg, ref.route, 0);
+	}
+	GET.turn = function(msg, route, turn){
+		var tmp = msg['#'], tag = dup.s[tmp], next;
+		if(!tmp){ return }
+		// Ideas: Save a random seed that sorts the route, store it and the index. // Or indexing on lowest latency is probably better.
+		clearTimeout(tag.lack);
+		if(tag.ack && (tmp = tag['##']) && msg['##'] === tmp){ return } // hashes match, stop asking other peers!
+		next = (Object.maps(route||opt.peers)).slice(turn = turn || 0);
+		if(!next.length){
+			if(!route){ return } // asked all peers, stop asking!
+			GET.turn(msg, u, 0); // asked all subs, now now ask any peers. (not always the best idea, but stays )
+			return;
+		}
+		setTimeout.each(next, function(id){
+			var peer = opt.peers[id]; turn++;
+			if(!peer || !peer.wire){ route && route.delete(id); return } // bye!
+			if(mesh.say(msg, peer) === false){ return } // was self
+			if(0 == (turn % 3)){ return 1 }
 		}, function(){
-			if(c){ return }
-			mesh.say(msg, opt.peers);
-		});
+			tag['##'] = msg['##']; // should probably set this in a more clever manner, do live `in` checks ++ --, etc. but being lazy for now. // TODO: Yes, see `in` TODO, currently this might match against only in-mem cause no other peers reply, which is "fine", but could cause a false positive.
+			tag.lack = setTimeout(function(){ GET.turn(msg, route, turn) }, 25);
+		}, 3);
 	}
 	function fall(msg){ mesh.say(msg, opt.peers) }
-	
+	root.on('in', function(msg){ var tmp;
+		if((tmp = msg['@']) && (tmp = dup.s[tmp])){
+			tmp.ack = (tmp.ack || 0) + 1; // count remote ACKs to GET. // TODO: If mismatch, should trigger next asks.
+		} 
+		this.to.next(msg);
+	});
+
 	root.on('create', function(){
+		var Q = {};
 		root.on('put', function(msg){
 			var eve = this, at = eve.as, put = msg.put, soul = put['#'], has = put['.'], val = put[':'], state = put['>'], id = msg['#'], tmp;
 			eve.to.next(msg);
 			if(!soul || !has){ return }
 			var ref = root.$.get(soul)._, route = (ref||'').route;
 			if(!route){ return }
+			if(Q[soul+has]){ return; } (Q[soul+has] = setTimeout(function(){ delete Q[soul+has]; // TODO: add debounce here!? hmm, scope would need sub. // Q is a quick hack!
 			setTimeout.each(Object.maps(route), function(id){ var peer, tmp;
 				if(!(peer = route.get(id))){ return }
 				if(!peer.wire){ route.delete(id); return } // bye!
@@ -66,6 +89,7 @@ function start(root){
 				if(peer.to){ return }
 				peer.to = setTimeout(function(){ flush(peer) }, opt.gap);
 			});
+			}, 9));
 		});
 	});
 	function flush(peer){