diff --git a/lutinMacro_zeus.py b/lutinMacro_zeus.py
index 4644928..03be390 100644
--- a/lutinMacro_zeus.py
+++ b/lutinMacro_zeus.py
@@ -63,6 +63,8 @@ def remove_start_stop_spacer(data):
 		dataout = dataout[:-1]
 	return dataout
 
+def capital_first(data):
+	return data[0].upper() + data[1:]
 
 class AttributeDefinition:
 	def __init__(self):
@@ -85,7 +87,7 @@ class AttributeDefinition:
 		debug.info("       BRIEF: " + self.brief)
 		debug.info("       " + self.type + " " + self.name + ";")
 	
-	def generate_doxy_get(self, space):
+	def generate_doxy_get(self, space, object):
 		out = ""
 		out += space + "/**\n"
 		out += space + " * @brief Get parameter " + self.brief + "\n"
@@ -93,7 +95,7 @@ class AttributeDefinition:
 		out += space + " */\n"
 		return out
 	
-	def generate_doxy_set(self, space):
+	def generate_doxy_set(self, space, object):
 		out = ""
 		out += space + "/**\n"
 		out += space + " * @brief Set parameter " + self.brief + "\n"
@@ -101,36 +103,36 @@ class AttributeDefinition:
 		out += space + " */\n"
 		return out
 	
-	def generate_cpp(self, space):
+	def generate_cpp(self, space, object):
 		out = "";
 		# TODO : Set it in protected
 		out += space + convert_type_in_cpp(self.type) + " m_" + self.name + "; //!<" + self.brief + "\n"
 		# TODO: set it in public ...
-		out += self.generate_doxy_get(space)
-		out += space + "virtual " + convert_type_in_cpp(self.type) + " get" + self.name.title() + "() {\n"
-		out += space + "	return m_" + self.name.title() + ";\n"
+		out += self.generate_doxy_get(space, object)
+		out += space + "virtual " + convert_type_in_cpp(self.type) + " get" + capital_first(self.name) + "() {\n"
+		out += space + "	return m_" + self.name + ";\n"
 		out += space + "}\n"
-		out += self.generate_doxy_set(space)
-		out += space + "virtual void set" + self.name.title() + "(" + convert_type_in_cpp(self.type) + " _value);\n"
-		out += space + "	m_" + self.name.title() + " = _value;\n"
+		out += self.generate_doxy_set(space, object)
+		out += space + "virtual void set" + capital_first(self.name) + "(const " + convert_type_in_cpp(self.type) + "& _value) {\n"
+		out += space + "	m_" + self.name + " = _value;\n"
 		out += space + "}\n"
 		return out;
 		
-	def generate_hpp_proxy(self, space):
+	def generate_hpp_proxy(self, space, object):
 		out = "";
-		out += self.generate_doxy_get(space)
-		out += space + "virtual zeus::Future<" + convert_type_in_cpp(self.type) + "> get" + self.name.title() + "();\n"
-		out += self.generate_doxy_set(space)
-		out += space + "virtual zeus::Future<void> set" + self.name.title() + "(" + convert_type_in_cpp(self.type) + " _value);\n"
+		out += self.generate_doxy_get(space, object)
+		out += space + "virtual zeus::Future<" + convert_type_in_cpp(self.type) + "> get" + capital_first(self.name) + "();\n"
+		out += self.generate_doxy_set(space, object)
+		out += space + "virtual zeus::Future<void> set" + capital_first(self.name) + "(const " + convert_type_in_cpp(self.type) + "& _value);\n"
 		return out;
 	
-	def generate_cpp_proxy(self, space, class_name):
+	def generate_cpp_proxy(self, space, class_name, object):
 		out = "";
-		out += space + "zeus::Future<" + convert_type_in_cpp(self.type) + "> " + class_name + "::get" + self.name.title() + "() {\n"
-		out += space + '	return m_srv.call("' + self.name + '.get");\n'
+		out += space + "zeus::Future<" + convert_type_in_cpp(self.type) + "> " + class_name + "::get" + capital_first(self.name) + "() {\n"
+		out += space + '	return m_obj.call("' + self.name + '.get");\n'
 		out += space + "}\n"
-		out += space + "zeus::Future<void> " + class_name + "::set" + self.name.title() + "(" + convert_type_in_cpp(self.type) + " _value) {\n"
-		out += space + '	return m_srv.call("' + self.name + '.set", _value);\n'
+		out += space + "zeus::Future<void> " + class_name + "::set" + capital_first(self.name) + "(const " + convert_type_in_cpp(self.type) + "& _value) {\n"
+		out += space + '	return m_obj.call("' + self.name + '.set", _value);\n'
 		out += space + "}\n"
 		return out;
 
@@ -191,7 +193,7 @@ class FunctionDefinition:
 			debug.info("               " + elem["type"] + " " + elem["name"] + ", # " + elem["brief"])
 		debug.info("       )")
 	
-	def generate_doxy(self, space):
+	def generate_doxy(self, space, object):
 		# generate doxygen comment:
 		out = space + "/**\n"
 		if self.brief != "":
@@ -211,9 +213,9 @@ class FunctionDefinition:
 		out += space + " */\n"
 		return out
 	
-	def generate_cpp(self, space):
+	def generate_cpp(self, space, object):
 		out = "";
-		out += self.generate_doxy(space)
+		out += self.generate_doxy(space, object)
 		out += space + "virtual "
 		out += convert_type_in_cpp(self.return_type) + " " + self.name + "("
 		param_data = ""
@@ -231,9 +233,9 @@ class FunctionDefinition:
 		out += ") = 0;\n"
 		return out;
 		
-	def generate_hpp_proxy(self, space):
+	def generate_hpp_proxy(self, space, object):
 		out = "";
-		out += self.generate_doxy(space)
+		out += self.generate_doxy(space, object)
 		out += space + "virtual zeus::Future<" + convert_type_in_cpp(self.return_type) + "> " + self.name + "("
 		param_data = ""
 		id_parameter = 0
@@ -249,7 +251,7 @@ class FunctionDefinition:
 		out += param_data
 		out += ");\n"
 		return out;
-	def generate_cpp_proxy(self, space, class_name):
+	def generate_cpp_proxy(self, space, class_name, object):
 		out = "";
 		out += space + "zeus::Future<" + convert_type_in_cpp(self.return_type) + "> " + class_name + "::" + self.name + "("
 		param_data = ""
@@ -266,7 +268,7 @@ class FunctionDefinition:
 		out += param_data
 		out += ") {\n"
 		space += "	"
-		out += space + 'return m_srv.call("' + self.name + '"'
+		out += space + 'return m_obj.call("' + self.name + '"'
 		id_parameter = 0
 		for elem in self.parameters:
 			id_parameter += 1
@@ -295,7 +297,7 @@ class ServiceDefinition:
 	def set_name(self, value):
 		self.name = value
 		# TODO : Check range ...
-		self.name[-1] = self.name[-1].title()
+		self.name[-1] = capital_first(self.name[-1])
 	
 	def set_brief(self, value):
 		self.brief = remove_start_stop_spacer(value)
@@ -328,7 +330,7 @@ class ServiceDefinition:
 		for elem in self.functions:
 			elem.display();
 	
-	def generate_header(self):
+	def generate_header(self, object):
 		filename = ""
 		for elem in self.name[:-1]:
 			filename += elem + "/"
@@ -371,10 +373,10 @@ class ServiceDefinition:
 		out += space + "virtual ~" + self.name[-1] + "() = default;\n"
 		
 		for elem in self.attributes:
-			out += elem.generate_cpp(space)
+			out += elem.generate_cpp(space, object)
 		
 		for elem in self.functions:
-			out += elem.generate_cpp(space)
+			out += elem.generate_cpp(space, object)
 		
 		space = space[:-2]
 		out += space + "};\n"
@@ -384,7 +386,80 @@ class ServiceDefinition:
 			out += space + "}\n"
 		return [filename, out]
 	
-	def generate_register_header(self):
+	def generate_source(self, object):
+		filename = ""
+		for elem in self.name[:-1]:
+			filename += elem + "/"
+		filename += self.name[-1] + ".cpp";
+		out = ""
+		
+		class_name = ""
+		for elem in self.name[:-1]:
+			class_name += "" + elem + "::"
+		class_name += self.name[-1];
+		
+		namespace = ""
+		for elem in self.name[:-1]:
+			namespace += elem + "::"
+		
+		out += "/** @file\n"
+		out += " * @note Generated file !!! Do not modify !!!\n"
+		out += " * @license APACHE-2\n"
+		out += " * @copyright none\n"
+		out += " */\n"
+		out += "\n"
+		out += "#include <" + filename.replace(".cpp",".hpp") + ">\n"
+		out += "#include <etk/types.hpp>\n"
+		out += "#include <zeus/Buffer.hpp>\n"
+		out += "#include <zeus/BufferData.hpp>\n"
+		out += "#include <zeus/debug.hpp>\n"
+		out += "#include <zeus/ParamType.hpp>\n"
+		out += "#include <etk/stdTools.hpp>\n"
+		out += "#include <zeus/AbstractFunction.hpp>\n"
+		out += "#include <climits>\n"
+		out += "#include <etk/os/FSNode.hpp>\n"
+		out += "#include <zeus/mineType.hpp>\n"
+		out += "#include <zeus/WebServer.hpp>\n"
+		out += "\n"
+		
+		# now gebnerate the get and set parameter object ...
+		out += "namespace zeus {\n"
+		"""
+		out += "	template<> const zeus::ParamType& createType<" + class_name + ">() {\n"
+		out += "		static zeus::ParamType type(\"obj:" + class_name + "\", zeus::paramTypeObject, false, false);\n"
+		out += "		return type;\n"
+		out += "	}\n"
+		"""
+		out += "	template<>\n"
+		out += "	void BufferParameter::addParameter<" + class_name + ">(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const ememory::SharedPtr<" + class_name + ">& _value) {\n"
+		out += "		std::vector<uint8_t> data;\n"
+		"""
+		out += "		addType(data, createType<" + class_name + ">());\n"
+		"""
+		out += "		addTypeObject(data, \"" + class_name + "\");\n"
+		out += "		int32_t currentOffset = data.size();\n"
+		out += "		int32_t startOffset = data.size();\n"
+		out += "		data.resize(data.size()+4);\n"
+		out += "		uint32_t fullId = 0;\n"
+		# convert the object in a real System Object ....
+		out += "		if (_iface != nullptr) {\n"
+		out += "			uint16_t id    = _iface->getAdress();\n"
+		out += "			uint16_t idObj = _iface->getNewObjectId();\n"
+		out += "			ememory::SharedPtr<zeus::ObjectType<" + class_name + ">> obj(_iface, idObj, _value);\n"
+		out += "			" + namespace + "register" + self.name[-1] + "(_value);\n"
+		out += "			_iface->addObject(obj)\n"
+		out += "			fullId = (uint32_t(id)<<16)+idObj\n"
+		out += "		}\n"
+		# return Object ID and interface adress
+		out += "		memcpy(&data[currentOffset], &fullId, 4);\n"
+		out += "		m_parameter.push_back(std::make_pair(startOffset,data));\n"
+		out += "	}\n"
+		
+		out += "}\n"
+		
+		return [filename, out]
+	
+	def generate_register_header(self, object):
 		filename = ""
 		for elem in self.name[:-1]:
 			filename += elem + "/"
@@ -404,7 +479,10 @@ class ServiceDefinition:
 		out += "#pragma once\n"
 		out += "\n"
 		out += "#include <etk/types.hpp>\n"
-		out += "#include <zeus/Service.hpp>\n"
+		if object == True:
+			out += "#include <zeus/Object.hpp>\n"
+		else:
+			out += "#include <zeus/Service.hpp>\n"
 		out += "#include <zeus/Client.hpp>\n"
 		out += "#include <" + class_name.replace("::","/") + ".hpp>\n"
 		out += "#include <string>\n"
@@ -422,40 +500,44 @@ class ServiceDefinition:
 			MACRO_BASE_NAME += elem.upper() + "_"
 		
 		out += space + "\n"
-		out += space + "void register" + self.name[-1] + "(zeus::ServiceType<" + class_name + ">& _serviceInterface);\n"
-		out += space + "\n"
-		out += space + "template<class " + MACRO_BASE_NAME + "TYPE>\n"
-		out += space + "zeus::Object* create" + self.name[-1] + "(zeus::Client* _client, uint16_t _objectId, uint16_t _clientId, zeus::ServiceType<" + class_name + ">::factory _factory) {\n"
-		out += space + "	zeus::ServiceType<" + class_name + ">* tmp = nullptr;\n"
-		out += space + "	tmp = new zeus::ServiceType<" + class_name + ">(_client, _objectId, _clientId, _factory);\n"
-		out += space + "	zeus::service::register" + self.name[-1] + "(*tmp);\n"
-		out += space + "	return tmp;\n"
-		out += space + "}\n"
+		if object == True:
+			out += space + "void register" + self.name[-1] + "(zeus::ObjectType<" + class_name + ">& _interface);\n"
+		else:
+			out += space + "void register" + self.name[-1] + "(zeus::ServiceType<" + class_name + ">& _interface);\n"
 		out += space + "\n"
+		if object == False:
+			out += space + "template<class " + MACRO_BASE_NAME + "TYPE>\n"
+			out += space + "zeus::Object* create" + self.name[-1] + "(zeus::Client* _client, uint16_t _objectId, uint16_t _clientId, zeus::ServiceType<" + class_name + ">::factory _factory) {\n"
+			out += space + "	zeus::ServiceType<" + class_name + ">* tmp = nullptr;\n"
+			out += space + "	tmp = new zeus::ServiceType<" + class_name + ">(_client, _objectId, _clientId, _factory);\n"
+			out += space + "	zeus::service::register" + self.name[-1] + "(*tmp);\n"
+			out += space + "	return tmp;\n"
+			out += space + "}\n"
+			out += space + "\n"
 		for elem in self.name[:-1]:
 			space = space[:-1]
 			out += space + "}\n"
 		out += space + "\n"
-		
-		out += space + "#define " + MACRO_BASE_NAME + "DECLARE(type) \\\n"
-		out += space + "	ETK_EXPORT_API zeus::Object* SERVICE_IO_instanciate(zeus::Client* _client, uint16_t _objectId, uint16_t _clientId) { \\\n"
-		out += space + "		return " + namespace + "create" + self.name[-1] + "<type>(_client, _objectId, _clientId, \\\n"
-		out += space + "		                                 [](uint16_t _clientId){ \\\n"
-		out += space + "		                                 	return ememory::makeShared<type>(_clientId); \\\n"
-		out += space + "		                                 }); \\\n"
-		out += space + "	}\n"
-		out += space + "\n"
-		"""
-		out += space + "#define " + MACRO_BASE_NAME + "DECLARE_FACTORY(type, factory) \\\n"
-		out += space + "	ETK_EXPORT_API zeus::Service* SERVICE_IO_instanciate() { \\\n"
-		out += space + "		return " + namespace + "create" + self.name[-1] + "<type>(factory); \\\n"
-		out += space + "	}\n"
-		"""
+		if object == False:
+			out += space + "#define " + MACRO_BASE_NAME + "DECLARE(type) \\\n"
+			out += space + "	ETK_EXPORT_API zeus::Object* SERVICE_IO_instanciate(zeus::Client* _client, uint16_t _objectId, uint16_t _clientId) { \\\n"
+			out += space + "		return " + namespace + "create" + self.name[-1] + "<type>(_client, _objectId, _clientId, \\\n"
+			out += space + "		                                 [](uint16_t _clientId){ \\\n"
+			out += space + "		                                 	return ememory::makeShared<type>(_clientId); \\\n"
+			out += space + "		                                 }); \\\n"
+			out += space + "	}\n"
+			out += space + "\n"
+			"""
+			out += space + "#define " + MACRO_BASE_NAME + "DECLARE_FACTORY(type, factory) \\\n"
+			out += space + "	ETK_EXPORT_API zeus::Service* SERVICE_IO_instanciate() { \\\n"
+			out += space + "		return " + namespace + "create" + self.name[-1] + "<type>(factory); \\\n"
+			out += space + "	}\n"
+			"""
 		
 		
 		return [filename, out]
 	
-	def generate_register_code(self):
+	def generate_register_code(self, object):
 		filename = ""
 		for elem in self.name[:-1]:
 			filename += elem + "/"
@@ -486,42 +568,41 @@ class ServiceDefinition:
 		for elem in self.name[:-1]:
 			class_name += "" + elem + "::"
 		class_name += self.name[-1];
+		if object == True:
+			out += space + "void " + function_name + "(zeus::ObjectType<" + class_name + ">& _interface) {\n"
+		else:
+			out += space + "void " + function_name + "(zeus::ServiceType<" + class_name + ">& _interface) {\n"
 		
-		out += space + "void " + function_name + "(zeus::ServiceType<" + class_name + ">& _serviceInterface) {\n"
 		space += "	"
 		
-		
-		
-		
 		out += space + 'ZEUS_INFO("===========================================================");\n';
 		out += space + 'ZEUS_INFO("== Instanciate service: ' + self.name[-1] + '");\n';
 		out += space + 'ZEUS_INFO("===========================================================");\n';
 		#out += space + '_serviceInterface.propertyNameService.set("' + self.name[-1].lower() + '");\n'
 		if self.brief != "":
-			out += space + '_serviceInterface.setDescription("' + self.brief + '");\n';
+			out += space + '_interface.setDescription("' + self.brief + '");\n';
 		if self.version != "":
-			out += space + '_serviceInterface.setVersion("' + self.version + '");\n';
+			out += space + '_interface.setVersion("' + self.version + '");\n';
 		if self.api != "":
-			out += space + '_serviceInterface.setType("' + self.api + '");\n';
+			out += space + '_interface.setType("' + self.api + '");\n';
 		for elem in self.authors:
-			out += space + '_serviceInterface.addAuthor("' + elem.split("<")[0] + '", "' + elem.split("<")[1].replace(">","") + '");\n';
-		if len(self.functions) != 0:
+			out += space + '_interface.addAuthor("' + elem.split("<")[0] + '", "' + elem.split("<")[1].replace(">","") + '");\n';
+		if    len(self.functions) != 0 \
+		   or len(self.attributes) != 0:
 			out += space + "zeus::AbstractFunction* func = nullptr;\n"
 		for elem in self.attributes:
-			out += space + 'func = _serviceInterface.advertise("' + elem.name.title() + '.set", &' + class_name + '::set' + elem.name.title() + ');\n'
+			out += space + 'func = _interface.advertise("' + elem.name + '.set", &' + class_name + '::set' + capital_first(elem.name) + ');\n'
 			out += space + 'if (func != nullptr) {\n'
-			space += "	"
 			if elem.brief != "":
-				out += space + 'func->setDescription("Set parameter ' + elem.brief + '");\n'
+				out += space + '	func->setDescription("Set parameter ' + elem.brief + '");\n'
 			out += space + '}\n'
-			out += space + 'func = _serviceInterface.advertise("' + elem.name.title() + '.get", &' + class_name + '::get' + elem.name.title() + ');\n'
+			out += space + 'func = _interface.advertise("' + elem.name + '.get", &' + class_name + '::get' + capital_first(elem.name) + ');\n'
 			out += space + 'if (func != nullptr) {\n'
-			space += "	"
 			if elem.brief != "":
-				out += space + 'func->setDescription("Get parameter ' + elem.brief + '");\n'
+				out += space + '	func->setDescription("Get parameter ' + elem.brief + '");\n'
 			out += space + '}\n'
 		for elem in self.functions:
-			out += space + 'func = _serviceInterface.advertise("' + elem.name + '", &' + class_name + '::' + elem.name + ');\n'
+			out += space + 'func = _interface.advertise("' + elem.name + '", &' + class_name + '::' + elem.name + ');\n'
 			out += space + 'if (func != nullptr) {\n'
 			space += "	"
 			if elem.brief != "":
@@ -549,7 +630,7 @@ class ServiceDefinition:
 		out += "\n"
 		return [filename, out]
 	
-	def generate_proxy_header(self):
+	def generate_proxy_header(self, object):
 		filename = ""
 		for elem in self.name[:-1]:
 			filename += elem + "/"
@@ -588,7 +669,7 @@ class ServiceDefinition:
 		space += "	"
 		out += space + "public:\n"
 		out += space + "	const Proxy" + self.name[-1] + "& operator= (const zeus::ServiceRemote& _srv) {\n"
-		out += space + "		m_srv = _srv;\n"
+		out += space + "		m_obj = _srv;\n"
 		out += space + "		return *this;\n"
 		out += space + "	}\n"
 		out += space + "	~Proxy" + self.name[-1] + "() = default;\n"
@@ -599,7 +680,7 @@ class ServiceDefinition:
 		out += space + "	}\n"
 		"""
 		out += space + "	bool exist() const {\n"
-		out += space + "		return m_srv.exist();\n"
+		out += space + "		return m_obj.exist();\n"
 		out += space + "	}\n"
 		"""
 		out += space + "public:\n"
@@ -611,9 +692,9 @@ class ServiceDefinition:
 		out += space + "virtual ~" + self.name[-1] + "() = default;\n"
 		"""
 		for elem in self.attributes:
-			out += elem.generate_hpp_proxy(space)
+			out += elem.generate_hpp_proxy(space, object)
 		for elem in self.functions:
-			out += elem.generate_hpp_proxy(space)
+			out += elem.generate_hpp_proxy(space, object)
 		
 		space = space[:-2]
 		out += space + "};\n"
@@ -623,17 +704,20 @@ class ServiceDefinition:
 			out += space + "}\n"
 		return [filename, out]
 	
-	def generate_proxy_code(self):
+	def generate_proxy_code(self, object):
 		filename = ""
 		for elem in self.name[:-1]:
 			filename += elem + "/"
 		filename += "Proxy" + self.name[-1] + ".cpp";
 		out = ""
 		
+		proxy_class_name = ""
 		class_name = ""
 		for elem in self.name[:-1]:
+			proxy_class_name += "" + elem + "::"
 			class_name += "" + elem + "::"
-		class_name += "Proxy" + self.name[-1];
+		proxy_class_name += "Proxy" + self.name[-1];
+		class_name += self.name[-1];
 		
 		out += "/** @file\n"
 		out += " * @note Generated file !!! Do not modify !!!\n"
@@ -645,10 +729,11 @@ class ServiceDefinition:
 		out += "\n"
 		
 		for elem in self.attributes:
-			out += elem.generate_cpp_proxy("", class_name)
+			out += elem.generate_cpp_proxy("", proxy_class_name, object)
 		
 		for elem in self.functions:
-			out += elem.generate_cpp_proxy("", class_name)
+			out += elem.generate_cpp_proxy("", proxy_class_name, object)
+		
 		return [filename, out]
 	
 
@@ -814,14 +899,17 @@ def tool_generate_idl(target, module, data_option):
 	
 	#service_def.display()
 	
-	service_header = service_def.generate_header()
-	register_header = service_def.generate_register_header()
-	register_code = service_def.generate_register_code()
-	proxy_header = service_def.generate_proxy_header()
-	proxy_code = service_def.generate_proxy_code()
+	service_header = service_def.generate_header(data_option["type"] == "object")
+	service_source = service_def.generate_source(data_option["type"] == "object")
+	register_header = service_def.generate_register_header(data_option["type"] == "object")
+	register_code = service_def.generate_register_code(data_option["type"] == "object")
+	proxy_header = service_def.generate_proxy_header(data_option["type"] == "object")
+	proxy_code = service_def.generate_proxy_code(data_option["type"] == "object")
 	
 	debug.verbose("-----------------  " + service_header[0] + "  -----------------")
 	debug.verbose("\n" + service_header[1])
+	debug.verbose("-----------------  " + service_source[0] + "  -----------------")
+	debug.verbose("\n" + service_source[1])
 	debug.verbose("-----------------  " + register_header[0] + "  -----------------")
 	debug.verbose("\n" + register_header[1])
 	debug.verbose("-----------------  " + register_code[0] + "  -----------------")
@@ -833,6 +921,7 @@ def tool_generate_idl(target, module, data_option):
 	
 	tmp_path = os.path.join(target.get_build_path_temporary_generate(module.get_name()), "idl_src")
 	module.add_generated_header_file(service_header[1], service_header[0], install_element=True)
+	module.add_generated_src_file(service_source[1], service_source[0])
 	module.add_generated_header_file(register_header[1], register_header[0], install_element=True)
 	module.add_generated_src_file(register_code[1], register_code[0])
 	module.add_generated_header_file(proxy_header[1], proxy_header[0], install_element=True)
diff --git a/lutin_zeus.py b/lutin_zeus.py
index 261e3cd..f044e8b 100644
--- a/lutin_zeus.py
+++ b/lutin_zeus.py
@@ -88,6 +88,7 @@ def configure(target, my_module):
 	    'zeus/RemoteProcessCall.hpp',
 	    'zeus/Service.hpp',
 	    'zeus/ServiceRemote.hpp',
+	    'zeus/WebObj.hpp',
 	    'zeus/WebServer.hpp',
 	    'zeus/mineType.hpp',
 	    'zeus/BaseProxy.hpp',
diff --git a/tools/service-user/appl/zeus-clientProperty.obj.zeus.idl b/tools/service-user/appl/zeus-clientProperty.obj.zeus.idl
new file mode 100644
index 0000000..74390b9
--- /dev/null
+++ b/tools/service-user/appl/zeus-clientProperty.obj.zeus.idl
@@ -0,0 +1,13 @@
+#elem-brief: Client Property object
+#elem-version: 1.0
+#elem-type:USER-PROPERTY
+#elem-author:Heero Yui<yui.heero@gmail.com>
+
+#brief:Name of the user
+string name
+
+#brief:Groups of the user
+vector:string groups
+
+#brief:list of function athorised
+vector:string functionList
\ No newline at end of file
diff --git a/tools/service-user/lutin_zeus-service-user.py b/tools/service-user/lutin_zeus-service-user.py
index fbdab15..59601f3 100644
--- a/tools/service-user/lutin_zeus-service-user.py
+++ b/tools/service-user/lutin_zeus-service-user.py
@@ -35,7 +35,7 @@ def configure(target, my_module):
 	zeus_macro = macro.load_macro('zeus')
 	zeus_macro.parse_service_idl(my_module, 'appl/zeus-service-user.srv.zeus.idl')
 	# use object for a first step ...
-	zeus_macro.parse_object_idl(my_module, 'appl/zeus-service-clientProperty.struct.zeus.idl')
+	zeus_macro.parse_object_idl(my_module, 'appl/zeus-clientProperty.obj.zeus.idl')
 	
 	#module_zeus = target.get_module('zeus')
 	#module_zeus.parse_service_idl(my_module, 'appl/zeus-service-user.zeus.idl')
diff --git a/zeus/BaseProxy.cpp b/zeus/BaseProxy.cpp
index 44816ef..259c35a 100644
--- a/zeus/BaseProxy.cpp
+++ b/zeus/BaseProxy.cpp
@@ -7,21 +7,21 @@
 #include <zeus/BaseProxy.hpp>
 #include <zeus/debug.hpp>
 
-const zeus::BaseProxy& zeus::BaseProxy::operator= (const zeus::ServiceRemote& _srv) {
-	m_srv = _srv;
+const zeus::BaseProxy& zeus::BaseProxy::operator= (const zeus::ServiceRemote& _obj) {
+	m_obj = _obj;
 	return *this;
 }
 zeus::BaseProxy::BaseProxy():
-  sys(m_srv),
-  srv(m_srv) {
+  sys(m_obj),
+  srv(m_obj) {
 	
 }
-zeus::BaseProxy::BaseProxy(const zeus::ServiceRemote& _srv):
-  m_srv(_srv),
-  sys(m_srv),
-  srv(m_srv) {
+zeus::BaseProxy::BaseProxy(const zeus::ServiceRemote& _obj):
+  m_obj(_obj),
+  sys(m_obj),
+  srv(m_obj) {
 	
 }
 bool zeus::BaseProxy::exist() const {
-	return m_srv.exist();
+	return m_obj.exist();
 }
diff --git a/zeus/BaseProxy.hpp b/zeus/BaseProxy.hpp
index 02b2bd0..e00944a 100644
--- a/zeus/BaseProxy.hpp
+++ b/zeus/BaseProxy.hpp
@@ -15,7 +15,7 @@ namespace zeus {
 	 */
 	class BaseProxy {
 		protected:
-			zeus::ServiceRemote m_srv; //!< Service instance handle
+			zeus::ServiceRemote m_obj; //!< Service instance handle
 		public:
 			zeus::SystemProxy sys;
 			zeus::ServiceProxy srv;
diff --git a/zeus/BufferAnswer.hpp b/zeus/BufferAnswer.hpp
index 9e96e83..69f2661 100644
--- a/zeus/BufferAnswer.hpp
+++ b/zeus/BufferAnswer.hpp
@@ -10,7 +10,7 @@
 #include <zeus/BufferParameter.hpp>
 
 namespace zeus {
-
+	class WebServer;
 	class BufferAnswer :
 	  public BufferParameter {
 		friend class zeus::Buffer;
@@ -43,8 +43,8 @@ namespace zeus {
 			 * @param[in] _value Value to add
 			 */
 			template<class ZEUS_TYPE_DATA>
-			void addAnswer(const ZEUS_TYPE_DATA& _value) {
-				addParameter(_value);
+			void addAnswer(const ememory::SharedPtr<zeus::WebServer>& _iface, const ZEUS_TYPE_DATA& _value) {
+				addParameter(_iface, _value);
 			}
 			/**
 			 * @brief get the answer value
diff --git a/zeus/BufferParameter.hpp b/zeus/BufferParameter.hpp
index 2d94b7e..274a57a 100644
--- a/zeus/BufferParameter.hpp
+++ b/zeus/BufferParameter.hpp
@@ -7,9 +7,10 @@
 #include <etk/types.hpp>
 #include <enet/WebSocket.hpp>
 #include <zeus/ParamType.hpp>
+#include <ememory/memory.hpp>
 
 namespace zeus {
-
+	class WebServer;
 	class BufferParameter:
 	  public Buffer {
 		protected:
@@ -68,11 +69,11 @@ namespace zeus {
 			 * @param[in] _value Value to add in parameter
 			 */
 			template<class ZEUS_TYPE_DATA>
-			void addParameter(uint16_t _paramId, const ZEUS_TYPE_DATA& _value);
+			void addParameter(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const ZEUS_TYPE_DATA& _value);
 		public:
 			template<class ZEUS_TYPE_DATA>
-			void addParameter(const ZEUS_TYPE_DATA& _value) {
-				addParameter(m_parameter.size(), _value);
+			void addParameter(const ememory::SharedPtr<zeus::WebServer>& _iface, const ZEUS_TYPE_DATA& _value) {
+				addParameter(_iface, m_parameter.size(), _value);
 			}
 			void parameterAppendBufferData(ememory::SharedPtr<zeus::BufferData> _obj);
 	};
diff --git a/zeus/BufferParameter_addParameter.cpp b/zeus/BufferParameter_addParameter.cpp
index 21dc877..87bdd02 100644
--- a/zeus/BufferParameter_addParameter.cpp
+++ b/zeus/BufferParameter_addParameter.cpp
@@ -49,7 +49,7 @@ void zeus::BufferParameter::addParameterEmptyVector() {
 }
 namespace zeus {
 	template<>
-	void BufferParameter::addParameter<std::string>(uint16_t _paramId, const std::string& _value) {
+	void BufferParameter::addParameter<std::string>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::string& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::string>());
 		int32_t currentOffset = data.size();
@@ -58,7 +58,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<std::vector<std::string>>(uint16_t _paramId, const std::vector<std::string>& _value) {
+	void BufferParameter::addParameter<std::vector<std::string>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<std::string>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<std::string>>());
 		// count all datas:
@@ -81,7 +81,7 @@ namespace zeus {
 	}
 	
 	template<>
-	void BufferParameter::addParameter<std::vector<bool>>(uint16_t _paramId, const std::vector<bool>& _value) {
+	void BufferParameter::addParameter<std::vector<bool>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<bool>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<bool>>());
 		// add size:
@@ -100,7 +100,7 @@ namespace zeus {
 	}
 	
 	template<>
-	void BufferParameter::addParameter<std::vector<int8_t>>(uint16_t _paramId, const std::vector<int8_t>& _value) {
+	void BufferParameter::addParameter<std::vector<int8_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<int8_t>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<int8_t>>());
 		// add size:
@@ -110,7 +110,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<std::vector<int16_t>>(uint16_t _paramId, const std::vector<int16_t>& _value) {
+	void BufferParameter::addParameter<std::vector<int16_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<int16_t>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<int16_t>>());
 		// add size:
@@ -120,7 +120,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<std::vector<int32_t>>(uint16_t _paramId, const std::vector<int32_t>& _value) {
+	void BufferParameter::addParameter<std::vector<int32_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<int32_t>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<int32_t>>());
 		// add size:
@@ -130,7 +130,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<std::vector<int64_t>>(uint16_t _paramId, const std::vector<int64_t>& _value) {
+	void BufferParameter::addParameter<std::vector<int64_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<int64_t>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<int64_t>>());
 		// add size:
@@ -140,7 +140,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<std::vector<uint8_t>>(uint16_t _paramId, const std::vector<uint8_t>& _value) {
+	void BufferParameter::addParameter<std::vector<uint8_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<uint8_t>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<uint8_t>>());
 		// add size:
@@ -150,7 +150,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<std::vector<uint16_t>>(uint16_t _paramId, const std::vector<uint16_t>& _value) {
+	void BufferParameter::addParameter<std::vector<uint16_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<uint16_t>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<uint16_t>>());
 		// add size:
@@ -160,7 +160,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<std::vector<uint32_t>>(uint16_t _paramId, const std::vector<uint32_t>& _value) {
+	void BufferParameter::addParameter<std::vector<uint32_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<uint32_t>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<uint32_t>>());
 		// add size:
@@ -170,7 +170,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<std::vector<uint64_t>>(uint16_t _paramId, const std::vector<uint64_t>& _value) {
+	void BufferParameter::addParameter<std::vector<uint64_t>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<uint64_t>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<uint64_t>>());
 		// add size:
@@ -181,7 +181,7 @@ namespace zeus {
 	}
 	
 	template<>
-	void BufferParameter::addParameter<std::vector<float>>(uint16_t _paramId, const std::vector<float>& _value) {
+	void BufferParameter::addParameter<std::vector<float>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<float>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<float>>());
 		// add size:
@@ -192,7 +192,7 @@ namespace zeus {
 	}
 	
 	template<>
-	void BufferParameter::addParameter<std::vector<double>>(uint16_t _paramId, const std::vector<double>& _value) {
+	void BufferParameter::addParameter<std::vector<double>>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const std::vector<double>& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<std::vector<double>>());
 		// add size:
@@ -203,21 +203,21 @@ namespace zeus {
 	}
 	
 	template<>
-	void BufferParameter::addParameter<int8_t>(uint16_t _paramId, const int8_t& _value) {
+	void BufferParameter::addParameter<int8_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const int8_t& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<int8_t>());
 		data.push_back(uint8_t(_value));
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<uint8_t>(uint16_t _paramId, const uint8_t& _value) {
+	void BufferParameter::addParameter<uint8_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const uint8_t& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<uint8_t>());
 		data.push_back(_value);
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<int16_t>(uint16_t _paramId, const int16_t& _value) {
+	void BufferParameter::addParameter<int16_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const int16_t& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<int16_t>());
 		int32_t currentOffset = data.size();
@@ -226,7 +226,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<uint16_t>(uint16_t _paramId, const uint16_t& _value) {
+	void BufferParameter::addParameter<uint16_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const uint16_t& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<uint16_t>());
 		int32_t currentOffset = data.size();
@@ -235,7 +235,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<int32_t>(uint16_t _paramId, const int32_t& _value) {
+	void BufferParameter::addParameter<int32_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const int32_t& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<int32_t>());
 		int32_t currentOffset = data.size();
@@ -244,7 +244,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<uint32_t>(uint16_t _paramId, const uint32_t& _value) {
+	void BufferParameter::addParameter<uint32_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const uint32_t& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<uint32_t>());
 		int32_t currentOffset = data.size();
@@ -253,7 +253,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<int64_t>(uint16_t _paramId, const int64_t& _value) {
+	void BufferParameter::addParameter<int64_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const int64_t& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<int64_t>());
 		int32_t currentOffset = data.size();
@@ -262,7 +262,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<uint64_t>(uint16_t _paramId, const uint64_t& _value) {
+	void BufferParameter::addParameter<uint64_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const uint64_t& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<uint64_t>());
 		int32_t currentOffset = data.size();
@@ -273,12 +273,12 @@ namespace zeus {
 	#if    defined(__TARGET_OS__MacOs) \
 	    || defined(__TARGET_OS__IOs)
 	template<>
-	void BufferParameter::addParameter<size_t>(uint16_t _paramId, const size_t& _value) {
+	void BufferParameter::addParameter<size_t>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const size_t& _value) {
 		addParameter(_paramId, uint64_t(_value));
 	}
 	#endif
 	template<>
-	void BufferParameter::addParameter<float>(uint16_t _paramId, const float& _value) {
+	void BufferParameter::addParameter<float>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const float& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<float>());
 		int32_t currentOffset = data.size();
@@ -287,7 +287,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<double>(uint16_t _paramId, const double& _value) {
+	void BufferParameter::addParameter<double>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const double& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<double>());
 		int32_t currentOffset = data.size();
@@ -296,7 +296,7 @@ namespace zeus {
 		m_parameter.push_back(std::make_pair(2,data));
 	}
 	template<>
-	void BufferParameter::addParameter<bool>(uint16_t _paramId, const bool& _value) {
+	void BufferParameter::addParameter<bool>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const bool& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<bool>());
 		if (_value == true) {
@@ -351,7 +351,7 @@ namespace zeus {
 			}
 	};
 	template<>
-	void BufferParameter::addParameter<zeus::File>(uint16_t _paramId, const zeus::File& _value) {
+	void BufferParameter::addParameter<zeus::File>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const zeus::File& _value) {
 		std::vector<uint8_t> data;
 		addType(data, createType<zeus::File>());
 		// set mine type in string:
@@ -427,7 +427,7 @@ namespace zeus {
 	};
 	
 	template<>
-	void BufferParameter::addParameter<zeus::FileServer>(uint16_t _paramId, const zeus::FileServer& _value) {
+	void BufferParameter::addParameter<zeus::FileServer>(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _paramId, const zeus::FileServer& _value) {
 		etk::FSNode node(_value.getFileName());
 		node.fileOpenRead();
 		std::string extention = std::string(_value.getFileName().begin()+_value.getFileName().size() -3, _value.getFileName().end());
@@ -440,7 +440,7 @@ namespace zeus {
 			node.fileRead(&fileData[0], 1, size);
 		}
 		zeus::File tmpFile(zeus::getMineType(extention), fileData, size);
-		addParameter(_paramId, tmpFile);
+		addParameter(_iface, _paramId, tmpFile);
 		node.fileClose();
 		if (size >= ZEUS_MINIMUM_SIZE_MULTIPLE) {
 			m_multipleSend.push_back(zeus::SendFile(_value.getFileName(), _paramId, size));
diff --git a/zeus/Object.cpp b/zeus/Object.cpp
index 0dcfc58..84fbff6 100644
--- a/zeus/Object.cpp
+++ b/zeus/Object.cpp
@@ -13,9 +13,9 @@
 
 
 zeus::Object::Object(zeus::Client* _client, uint16_t _objectId) :
+  zeus::RemoteProcessCall(_client->getWebInterface(), _client->m_localAddress, _objectId),
   m_clientId(_client->m_localAddress),
   m_objectId(_objectId) {
-	m_interfaceClient = _client->getWebInterface();
 	/*
 	zeus::AbstractFunction* func = advertise("getExtention", &zeus::Object::getExtention);
 	if (func != nullptr) {
@@ -25,6 +25,14 @@ zeus::Object::Object(zeus::Client* _client, uint16_t _objectId) :
 	*/
 }
 
+zeus::Object::Object(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _objectId) :
+  zeus::RemoteProcessCall(_iface, _iface->getAdress(), _objectId),
+  m_clientId(_iface->getAdress()),
+  m_objectId(_objectId) {
+	
+}
+
+
 zeus::Object::~Object() {
 	
 }
@@ -100,7 +108,7 @@ void zeus::Object::callBinary(ememory::SharedPtr<zeus::Buffer> _obj) {
 			} else if (callFunction == "_delete") {
 				clientDisconnect(sourceId);
 			}
-			m_interfaceClient->answerValue(callObj->getTransactionId(), uint32_t(m_id)<<16, source, true);
+			m_interfaceWeb->answerValue(callObj->getTransactionId(), uint32_t(m_id)<<16, source, true);
 			return;
 		} else */if (isFunctionAuthorized(sourceId, callFunction) == true) {
 			ZEUS_INFO("plop 6 ...");
@@ -108,7 +116,7 @@ void zeus::Object::callBinary(ememory::SharedPtr<zeus::Buffer> _obj) {
 			return;
 		} else {
 			ZEUS_INFO("plop 7 ...");
-			m_interfaceClient->answerError(callObj->getTransactionId(), (uint32_t(m_clientId)<<16) + m_objectId, source, "NOT-AUTHORIZED-FUNCTION", "");
+			m_interfaceWeb->answerError(callObj->getTransactionId(), (uint32_t(m_clientId)<<16) + m_objectId, source, "NOT-AUTHORIZED-FUNCTION", "");
 			return;
 		}
 	}
diff --git a/zeus/Object.hpp b/zeus/Object.hpp
index 8287108..9fa88da 100644
--- a/zeus/Object.hpp
+++ b/zeus/Object.hpp
@@ -27,9 +27,8 @@ namespace zeus {
 		protected:
 			std::mutex m_mutex;
 		protected:
-			ememory::SharedPtr<zeus::WebServer> m_interfaceClient;
-			uint16_t m_clientId;
-			uint16_t m_objectId;
+			uint16_t m_clientId; // TODO : Remove it
+			uint16_t m_objectId; // TODO : Remove it
 			std::vector<zeus::FutureBase> m_callMultiData;
 		public:
 			uint16_t getObjectId() { return m_objectId; }
@@ -39,6 +38,7 @@ namespace zeus {
 			 * @return 
 			 */
 			Object(zeus::Client* _client, uint16_t _objectId);
+			Object(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _objectId);
 			/**
 			 * @brief 
 			 * @param[in] 
@@ -104,10 +104,17 @@ namespace zeus {
 		private:
 			ememory::SharedPtr<ZEUS_TYPE_OBJECT> m_interface; // direct handle on the data;
 		public:
+			/*
 			ObjectType(zeus::Client* _client, uint16_t _objectId, uint16_t _clientId) :
 			  Object(_client, _objectId) {
 				m_interface = ememory::makeShared<ZEUS_TYPE_OBJECT>(_clientId);
 			}
+			*/
+			ObjectType(zeus::Client* _client, uint16_t _objectId, const ememory::SharedPtr<ZEUS_TYPE_OBJECT>& _element) :
+			  Object(_client, _objectId),
+			  m_interface(_element) {
+				// nothing else to do ...
+			}
 		public:
 			/**
 			 * @brief 
@@ -173,7 +180,8 @@ namespace zeus {
 					}
 					switch (it2->getType()) {
 						case zeus::AbstractFunction::type::object: {
-							it2->execute(m_interfaceClient, _obj, (void*)m_interface);
+							ZEUS_TYPE_OBJECT* elem = m_interface.get();
+							it2->execute(m_interfaceClient, _obj, (void*)elem);
 							return;
 						}
 						case zeus::AbstractFunction::type::local: {
diff --git a/zeus/RemoteProcessCall.cpp b/zeus/RemoteProcessCall.cpp
index 15f4b96..59cbcc2 100644
--- a/zeus/RemoteProcessCall.cpp
+++ b/zeus/RemoteProcessCall.cpp
@@ -5,8 +5,9 @@
  */
 #include <zeus/RemoteProcessCall.hpp>
 
-zeus::RemoteProcessCall::RemoteProcessCall() :
-  m_type("UNKNOW"){
+zeus::RemoteProcessCall::RemoteProcessCall(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _id, uint16_t _objectId) :
+  zeus::WebObj(_iface, _id, _objectId),
+  m_type("UNKNOW") {
 	zeus::AbstractFunction* func = advertise("getDescription", &zeus::RemoteProcessCall::getDescription);
 	if (func != nullptr) {
 		func->setDescription("Get description");
diff --git a/zeus/RemoteProcessCall.hpp b/zeus/RemoteProcessCall.hpp
index ff8eb9e..048c8dc 100644
--- a/zeus/RemoteProcessCall.hpp
+++ b/zeus/RemoteProcessCall.hpp
@@ -9,17 +9,18 @@
 #include <zeus/AbstractFunctionTypeDirect.hpp>
 #include <zeus/AbstractFunctionTypeClass.hpp>
 #include <zeus/debug.hpp>
+#include <zeus/WebObj.hpp>
 
 namespace zeus {
 	/**
 	 * @brief Local declaration of call local data
 	 */
-	class RemoteProcessCall {
+	class RemoteProcessCall : public zeus::WebObj {
 		public:
 			/**
 			 * @brief Basic constructor
 			 */
-			RemoteProcessCall();
+			RemoteProcessCall(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _id, uint16_t _objectId);
 		protected:
 			std::vector<zeus::AbstractFunction*> m_listFunction; //!< List of all functions callable
 		protected:
diff --git a/zeus/Service.hpp b/zeus/Service.hpp
index 910e450..ea8342a 100644
--- a/zeus/Service.hpp
+++ b/zeus/Service.hpp
@@ -23,14 +23,14 @@ namespace zeus {
 	 * @param[in] 
 	 * @return 
 	 */
-	class ClientProperty {
+	class ClientPropertyddd {
 		public:
 			/**
 			 * @brief 
 			 * @param[in] 
 			 * @return 
 			 */
-			ClientProperty(const std::string& _clientName="", const std::vector<std::string>& _groups = std::vector<std::string>()) :
+			ClientPropertyddd(const std::string& _clientName="", const std::vector<std::string>& _groups = std::vector<std::string>()) :
 			  m_name(_clientName),
 			  m_groups(_groups) {
 				
@@ -103,7 +103,7 @@ namespace zeus {
 			using factory = std::function<ememory::SharedPtr<ZEUS_TYPE_SERVICE>(uint16_t)>;
 		private:
 			// no need of shared_ptr or unique_ptr (if service die all is lost and is client die, the gateway notify us...)
-			ememory::SharedPtr<ClientProperty> m_property;
+			ememory::SharedPtr<ClientPropertyddd> m_property;
 			ememory::SharedPtr<ZEUS_TYPE_SERVICE> m_interface;
 		public:
 			ServiceType(zeus::Client* _client, uint16_t _objectId, uint16_t _clientId, factory _factory) :
@@ -177,7 +177,7 @@ namespace zeus {
 				ZEUS_DEBUG("connect: " << _sourceId << " to '" << _userName << "'");
 				ZEUS_DEBUG("    client name='" << _clientName << "'");
 				ZEUS_DEBUG("    groups=" << etk::to_string(_groups));
-				ememory::SharedPtr<ClientProperty> tmpProperty = ememory::makeShared<ClientProperty>(_clientName, _groups);
+				ememory::SharedPtr<ClientPropertyddd> tmpProperty = ememory::makeShared<ClientPropertyddd>(_clientName, _groups);
 				ememory::SharedPtr<ZEUS_TYPE_SERVICE> tmpSrv;
 				if (m_factory != nullptr) {
 					tmpSrv = m_factory(tmpProperty, m_nameUser);
diff --git a/zeus/ServiceRemote.cpp b/zeus/ServiceRemote.cpp
index 871cbda..62676dd 100644
--- a/zeus/ServiceRemote.cpp
+++ b/zeus/ServiceRemote.cpp
@@ -10,17 +10,15 @@
 
 
 zeus::ServiceRemoteBase::ServiceRemoteBase(ememory::SharedPtr<zeus::WebServer> _clientLink, const std::string& _name, uint16_t _localId, uint16_t _localObjectId):
-  m_interfaceClient(_clientLink),
+  zeus::WebObj(_clientLink, _localId, _localObjectId),
   m_name(_name),
-  m_localId(_localId),
-  m_localObjectId(_localObjectId),
   m_serviceId(0),
   m_isLinked(false) {
-	if (m_interfaceClient == nullptr) {
+	if (m_interfaceWeb == nullptr) {
 		return;
 	}
 	// little hack : Call the service manager with the service ID=0 ...
-	zeus::Future<uint32_t> ret = m_interfaceClient->call((uint32_t(m_localId)<<16)+m_localObjectId, ZEUS_GATEWAY_ADDRESS, "link", _name);
+	zeus::Future<uint32_t> ret = m_interfaceWeb->call(getFullId(), ZEUS_GATEWAY_ADDRESS, "link", _name);
 	ret.wait();
 	if (ret.hasError() == true) {
 		ZEUS_WARNING("Can not link with the service named: '" << _name << "' ==> link error");
@@ -35,7 +33,7 @@ zeus::ServiceRemoteBase::~ServiceRemoteBase() {
 		uint32_t tmpLocalService = m_serviceId;
 		// little hack : Call the service manager with the service ID=0 ...
 		m_serviceId = 0;
-		zeus::Future<bool> ret = m_interfaceClient->call((uint32_t(m_localId)<<16)+m_localObjectId, m_serviceId, "unlink", tmpLocalService);
+		zeus::Future<bool> ret = m_interfaceWeb->call(getFullId(), m_serviceId, "unlink", tmpLocalService);
 		ret.wait();
 		if (ret.hasError() == true) {
 			ZEUS_WARNING("Can not unlink with the service id: '" << tmpLocalService << "' ==> link error");
diff --git a/zeus/ServiceRemote.hpp b/zeus/ServiceRemote.hpp
index bfe486c..2888788 100644
--- a/zeus/ServiceRemote.hpp
+++ b/zeus/ServiceRemote.hpp
@@ -11,6 +11,7 @@
 #include <zeus/ServiceRemote.hpp>
 #include <zeus/Future.hpp>
 #include <zeus/WebServer.hpp>
+#include <zeus/WebObj.hpp>
 
 namespace zeus {
 	class Client;
@@ -20,13 +21,10 @@ namespace zeus {
 	 * @param[in] 
 	 * @return 
 	 */
-	class ServiceRemoteBase {
+	class ServiceRemoteBase : public zeus::WebObj {
 		friend class ServiceRemote;
 		private:
-			ememory::SharedPtr<zeus::WebServer> m_interfaceClient;
 			std::string m_name;
-			uint16_t m_localId;
-			uint16_t m_localObjectId;
 			uint32_t m_serviceId;
 			bool m_isLinked;
 		public:
@@ -35,7 +33,10 @@ namespace zeus {
 			 * @param[in] 
 			 * @return 
 			 */
-			ServiceRemoteBase() = default;
+			ServiceRemoteBase():
+			  zeus::WebObj(nullptr, 0, 0) {
+				
+			}
 			/**
 			 * @brief 
 			 * @param[in] 
@@ -97,17 +98,17 @@ namespace zeus {
 			template<class... _ARGS>
 			zeus::FutureBase call(const std::string& _functionName, _ARGS&&... _args) {
 				if (    m_interface == nullptr
-				     || m_interface->m_interfaceClient == nullptr) {
+				     || m_interface->m_interfaceWeb == nullptr) {
 					ememory::SharedPtr<zeus::BufferAnswer> ret = zeus::BufferAnswer::create();
 					if (ret != nullptr) {
 						ret->addError("NULLPTR", "call " + _functionName + " with no interface open");
 					}
 					return zeus::FutureBase(0, ret);
 				}
-				return m_interface->m_interfaceClient->call((uint32_t(m_interface->m_localId)<<16)+m_interface->m_localObjectId,
-				                                            m_interface->m_serviceId,
-				                                            _functionName,
-				                                            _args...);
+				return m_interface->m_interfaceWeb->call(m_interface->getFullId(),
+				                                         m_interface->m_serviceId,
+				                                         _functionName,
+				                                         _args...);
 			}
 	};
 	
diff --git a/zeus/WebObj.hpp b/zeus/WebObj.hpp
new file mode 100644
index 0000000..c4bf78d
--- /dev/null
+++ b/zeus/WebObj.hpp
@@ -0,0 +1,32 @@
+/** @file
+ * @author Edouard DUPIN
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+//#include <zeus/WebServer.hpp>
+#include <etk/types.hpp>
+#include <ememory/memory.hpp>
+
+namespace zeus {
+	class WebServer;
+	class WebObj : public ememory::EnableSharedFromThis<zeus::WebObj> {
+		protected:
+			ememory::SharedPtr<zeus::WebServer> m_interfaceWeb;
+			uint16_t m_id;
+			uint16_t m_objectId;
+		public:
+			WebObj(const ememory::SharedPtr<zeus::WebServer>& _iface, uint16_t _id, uint16_t _objectId) :
+			  m_interfaceWeb(_iface),
+			  m_id(_id),
+			  m_objectId(_objectId) {
+				
+			}
+			uint32_t getFullId() {
+				return (uint32_t(m_id) << 16 ) + m_objectId;
+			}
+		
+	};
+}
+
diff --git a/zeus/WebServer.cpp b/zeus/WebServer.cpp
index 52c3233..914ed8b 100644
--- a/zeus/WebServer.cpp
+++ b/zeus/WebServer.cpp
@@ -23,7 +23,7 @@ ememory::SharedPtr<zeus::BufferCall> zeus::createBaseCall(uint64_t _transactionI
 	return obj;
 }
 
-void zeus::createParam(int32_t _paramId, ememory::SharedPtr<zeus::BufferCall> _obj) {
+void zeus::createParam(const ememory::SharedPtr<zeus::WebServer>& _iface, int32_t _paramId, ememory::SharedPtr<zeus::BufferCall> _obj) {
 	// Finish recursive parse ...
 }
 
@@ -384,6 +384,7 @@ void zeus::WebServer::callForwardMultiple(uint16_t _srcObjectId,
 }
 */
 
+/*
 void zeus::WebServer::sendCtrl(uint32_t _source, uint32_t _destination, const std::string& _ctrlValue) {
 	auto ctrl = zeus::BufferCtrl::create();
 	if (ctrl == nullptr) {
@@ -395,6 +396,7 @@ void zeus::WebServer::sendCtrl(uint32_t _source, uint32_t _destination, const st
 	ctrl->setCtrl(_ctrlValue);
 	writeBinary(ctrl);
 }
+*/
 
 void zeus::WebServer::answerError(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination, const std::string& _errorValue, const std::string& _errorHelp) {
 	auto answer = zeus::BufferAnswer::create();
diff --git a/zeus/WebServer.hpp b/zeus/WebServer.hpp
index 0739a57..366e10c 100644
--- a/zeus/WebServer.hpp
+++ b/zeus/WebServer.hpp
@@ -11,6 +11,7 @@
 #include <ememory/memory.hpp>
 #include <zeus/AbstractFunction.hpp>
 #include <zeus/FutureBase.hpp>
+#include <zeus/WebObj.hpp>
 
 //#define ZEUS_NO_ID_CLIENT (0xFFFFFFFF)
 #define ZEUS_NO_ID_CLIENT (0x00000000)
@@ -22,6 +23,7 @@
 
 
 namespace zeus {
+	class WebServer;
 	/**
 	 * @brief 
 	 * @param[in] 
@@ -33,7 +35,8 @@ namespace zeus {
 	 * @param[in] 
 	 * @return 
 	 */
-	void createParam(int32_t _paramId,
+	void createParam(const ememory::SharedPtr<zeus::WebServer>& _iface,
+	                 int32_t _paramId,
 	                 ememory::SharedPtr<zeus::BufferCall> _obj);
 	
 	/**
@@ -42,13 +45,14 @@ namespace zeus {
 	 * @return 
 	 */
 	template<class ZEUS_TYPE, class... _ARGS>
-	void createParam(int32_t _paramId,
+	void createParam(const ememory::SharedPtr<zeus::WebServer>& _iface,
+	                 int32_t _paramId,
 	                 ememory::SharedPtr<zeus::BufferCall> _obj,
 	                 const ZEUS_TYPE& _param,
 	                 _ARGS&&... _args) {
-		_obj->addParameter<ZEUS_TYPE>(_param);
+		_obj->addParameter<ZEUS_TYPE>(_iface, _param);
 		_paramId++;
-		createParam(_paramId, _obj, std::forward<_ARGS>(_args)...);
+		createParam(_iface, _paramId, _obj, std::forward<_ARGS>(_args)...);
 	}
 	/**
 	 * @brief 
@@ -57,11 +61,12 @@ namespace zeus {
 	 */
 	// convert const char in std::string ...
 	template<class... _ARGS>
-	void createParam(int32_t _paramId,
+	void createParam(const ememory::SharedPtr<zeus::WebServer>& _iface,
+	                 int32_t _paramId,
 	                 ememory::SharedPtr<zeus::BufferCall> _obj,
 	                 const char* _param,
 	                 _ARGS&&... _args) {
-		createParam(_paramId, _obj, std::string(_param), std::forward<_ARGS>(_args)...);
+		createParam(_iface, _paramId, _obj, std::string(_param), std::forward<_ARGS>(_args)...);
 	}
 	/**
 	 * @brief 
@@ -69,19 +74,21 @@ namespace zeus {
 	 * @return 
 	 */
 	template<class... _ARGS>
-	ememory::SharedPtr<zeus::BufferCall> createCall(uint64_t _transactionId, const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName, _ARGS&&... _args) {
+	ememory::SharedPtr<zeus::BufferCall> createCall(const ememory::SharedPtr<zeus::WebServer>& _iface, uint64_t _transactionId, const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName, _ARGS&&... _args) {
 		ememory::SharedPtr<zeus::BufferCall> callElem = createBaseCall(_transactionId, _source, _destination, _functionName);
 		if (callElem == nullptr) {
 			return nullptr;
 		}
-		createParam(0, callElem, std::forward<_ARGS>(_args)...);
+		createParam(_iface, 0, callElem, std::forward<_ARGS>(_args)...);
 		return callElem;
 	}
 	
 	/**
 	 * @brief 
 	 */
-	class WebServer {
+	class WebServer : public ememory::EnableSharedFromThis<zeus::WebServer> {
+		public:
+			std::vector<ememory::SharedPtr<zeus::WebObj>> m_actifObject; //!< List of all active object created and that remove is in progress ...
 		private:
 			enet::WebSocket m_connection;
 			uint32_t m_interfaceId;
@@ -260,7 +267,7 @@ namespace zeus {
 			template<class... _ARGS>
 			zeus::FutureBase call(const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName, _ARGS&&... _args) {
 				uint16_t id = getId();
-				ememory::SharedPtr<zeus::BufferCall> callElem = zeus::createCall(id, _source, _destination, _functionName, std::forward<_ARGS>(_args)...);
+				ememory::SharedPtr<zeus::BufferCall> callElem = zeus::createCall(sharedFromThis(), id, _source, _destination, _functionName, std::forward<_ARGS>(_args)...);
 				return callBinary(id, callElem);
 			}
 		public:
@@ -302,7 +309,7 @@ namespace zeus {
 				answer->setTransactionId(_clientTransactionId);
 				answer->setSource(_source);
 				answer->setDestination(_destination);
-				answer->addAnswer(_value);
+				answer->addAnswer(sharedFromThis(), _value);
 				writeBinary(answer);
 			}
 			/**
@@ -326,7 +333,7 @@ namespace zeus {
 			 * @param[in] _ctrlValue Control to send
 			 * @return 
 			 */
-			void sendCtrl(uint32_t _source, uint32_t _destination, const std::string& _ctrlValue);
+			//void sendCtrl(uint32_t _source, uint32_t _destination, const std::string& _ctrlValue);
 	};
 }