diff --git a/rpc/api.go b/rpc/api.go
index 26330b124351921ae3beb585db5b1990c843aa6d..427032995a4e7e890841462d481109e2b2c46ee8 100644
--- a/rpc/api.go
+++ b/rpc/api.go
@@ -17,20 +17,15 @@ type EthereumApi struct {
 	eth    *xeth.XEth
 	xethMu sync.RWMutex
 	db     common.Database
-
-	// Miner agent
-	agent *Agent
 }
 
 func NewEthereumApi(xeth *xeth.XEth, dataDir string) *EthereumApi {
 	// What about when dataDir is empty?
 	db, _ := ethdb.NewLDBDatabase(path.Join(dataDir, "dapps"))
 	api := &EthereumApi{
-		eth:   xeth,
-		db:    db,
-		agent: NewAgent(),
+		eth: xeth,
+		db:  db,
 	}
-	xeth.Backend().Miner().Register(api.agent)
 
 	return api
 }
@@ -349,13 +344,13 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
 		*reply = NewLogsRes(api.xeth().AllLogs(opts))
 	case "eth_getWork":
 		api.xeth().SetMining(true)
-		*reply = api.agent.GetWork()
+		*reply = api.xeth().RemoteMining().GetWork()
 	case "eth_submitWork":
 		args := new(SubmitWorkArgs)
 		if err := json.Unmarshal(req.Params, &args); err != nil {
 			return err
 		}
-		*reply = api.agent.SetResult(args.Nonce, args.Digest, args.Header)
+		*reply = api.xeth().RemoteMining().SubmitWork(args.Nonce, args.Digest, args.Header)
 	case "db_putString":
 		args := new(DbArgs)
 		if err := json.Unmarshal(req.Params, &args); err != nil {
diff --git a/xeth/miner_agent.go b/xeth/miner_agent.go
new file mode 100644
index 0000000000000000000000000000000000000000..181ab950aa26a112a2b83eaf70a1eaa89e22e239
--- /dev/null
+++ b/xeth/miner_agent.go
@@ -0,0 +1,81 @@
+package xeth
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/miner"
+)
+
+type Agent struct {
+	work        *types.Block
+	currentWork *types.Block
+
+	quit     chan struct{}
+	workCh   chan *types.Block
+	returnCh chan<- miner.Work
+}
+
+func NewAgent() *Agent {
+	agent := &Agent{}
+	go agent.run()
+
+	return agent
+}
+
+func (a *Agent) Work() chan<- *types.Block {
+	return a.workCh
+}
+
+func (a *Agent) SetWorkCh(returnCh chan<- miner.Work) {
+	a.returnCh = returnCh
+}
+
+func (a *Agent) Start() {
+	a.quit = make(chan struct{})
+	a.workCh = make(chan *types.Block, 1)
+}
+
+func (a *Agent) Stop() {
+	close(a.quit)
+	close(a.workCh)
+}
+
+func (a *Agent) GetHashRate() int64 { return 0 }
+
+func (a *Agent) run() {
+out:
+	for {
+		select {
+		case <-a.quit:
+			break out
+		case work := <-a.workCh:
+			a.work = work
+		}
+	}
+}
+
+func (a *Agent) GetWork() [3]string {
+	// TODO return HashNoNonce, DAGSeedHash, Difficulty
+	var res [3]string
+
+	// XXX Wait here untill work != nil ?.
+	if a.work != nil {
+		res[0] = a.work.HashNoNonce().Hex() // Header Hash No Nonce
+		res[1] = common.Hash{}.Hex()        // DAG Seed
+		res[2] = common.Hash{}.Hex()        // Difficulty
+	}
+
+	return res
+}
+
+func (a *Agent) SubmitWork(nonce uint64, mixDigest, seedHash common.Hash) bool {
+	// Return true or false, but does not indicate if the PoW was correct
+
+	// Make sure the external miner was working on the right hash
+	if a.currentWork != nil && a.work != nil && a.currentWork.Hash() == a.work.Hash() {
+		a.returnCh <- miner.Work{a.currentWork.Number().Uint64(), nonce, mixDigest.Bytes(), seedHash.Bytes()}
+		return true
+	}
+
+	return false
+}
diff --git a/xeth/xeth.go b/xeth/xeth.go
index d3c3131d4b3c00d97969bb0bdf2efca13f7fbdfe..fba61230f39505aba2b33ac969e379ce5370ad05 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -100,6 +100,9 @@ type XEth struct {
 
 	// regmut   sync.Mutex
 	// register map[string][]*interface{} // TODO improve return type
+
+	// Miner agent
+	agent *Agent
 }
 
 // New creates an XEth that uses the given frontend.
@@ -117,7 +120,10 @@ func New(eth Backend, frontend Frontend) *XEth {
 		frontend:       frontend,
 		logs:           make(map[int]*logFilter),
 		messages:       make(map[int]*whisperFilter),
+		agent:          NewAgent(),
 	}
+	eth.Miner().Register(xeth.agent)
+
 	if frontend == nil {
 		xeth.frontend = dummyFrontend{}
 	}
@@ -164,6 +170,8 @@ func (self *XEth) stop() {
 func (self *XEth) DefaultGas() *big.Int      { return defaultGas }
 func (self *XEth) DefaultGasPrice() *big.Int { return defaultGasPrice }
 
+func (self *XEth) RemoteMining() *Agent { return self.agent }
+
 func (self *XEth) AtStateNum(num int64) *XEth {
 	chain := self.Backend().ChainManager()
 	var block *types.Block