diff --git a/Cargo.lock b/Cargo.lock
index 5e2bcf8..a5c3d56 100755
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9252,6 +9252,7 @@ dependencies = [
  "parity-scale-codec",
  "polkadot-sdk",
  "scale-info",
+ "substrate-fixed",
  "test-utils",
 ]
 
@@ -16292,6 +16293,17 @@ name = "substrate-build-script-utils"
 version = "11.0.0"
 source = "git+https://github.com/paritytech/polkadot-sdk.git?branch=stable2409#981d6c0fa87a00b72bb3b6211d1e71deed21f0cc"
 
+[[package]]
+name = "substrate-fixed"
+version = "0.5.9"
+source = "git+https://github.com/encointer/substrate-fixed#ddaa922892d1565f02c9c5702f0aacd17da53ce2"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "substrate-typenum",
+]
+
 [[package]]
 name = "substrate-frame-rpc-support"
 version = "40.0.0"
@@ -16369,6 +16381,16 @@ dependencies = [
  "trie-db",
 ]
 
+[[package]]
+name = "substrate-typenum"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f0091e93c2c75b233ae39424c52cb8a662c0811fb68add149e20e5d7e8a788"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+]
+
 [[package]]
 name = "substrate-wasm-builder"
 version = "24.0.1"
diff --git a/Cargo.toml b/Cargo.toml
index 0d2c227..89c368f 100755
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,6 +43,8 @@ pallet-evm-precompile-modexp = { git = "https://github.com/paritytech/frontier.g
 pallet-evm-precompile-sha3fips = { git = "https://github.com/paritytech/frontier.git", rev = "b9b1c620c8b418bdeeadc79725f9cfa4703c0333", default-features = false }
 pallet-evm-precompile-simple = { git = "https://github.com/paritytech/frontier.git", rev = "b9b1c620c8b418bdeeadc79725f9cfa4703c0333", default-features = false }
 
+substrate-fixed = { git = "https://github.com/encointer/substrate-fixed", default-features = false }
+
 # CLI-specific dependencies
 clap = { version = "4.5.22", features = ["derive"] }
 serde_json = { version = "1.0", default-features = false }
diff --git a/pallets/torus0/Cargo.toml b/pallets/torus0/Cargo.toml
index 6e0ab91..95c8f2b 100644
--- a/pallets/torus0/Cargo.toml
+++ b/pallets/torus0/Cargo.toml
@@ -8,13 +8,14 @@ edition.workspace = true
 
 [features]
 default = ["std"]
-std = ["codec/std", "polkadot-sdk/std", "scale-info/std"]
+std = ["codec/std", "polkadot-sdk/std", "scale-info/std", "substrate-fixed/std"]
 runtime-benchmarks = ["polkadot-sdk/runtime-benchmarks"]
 try-runtime = ["polkadot-sdk/try-runtime"]
 
 [dependencies]
 codec = { workspace = true, features = ["derive"] }
 scale-info = { workspace = true, features = ["derive"] }
+substrate-fixed = { workspace = true }
 polkadot-sdk = { workspace = true, features = ["experimental", "runtime"] }
 
 [dev-dependencies]
diff --git a/pallets/torus0/src/agent.rs b/pallets/torus0/src/agent.rs
index 3bc54f5..1c4f92c 100644
--- a/pallets/torus0/src/agent.rs
+++ b/pallets/torus0/src/agent.rs
@@ -1,8 +1,9 @@
 use crate::AccountIdOf;
 use codec::{Decode, Encode, MaxEncodedLen};
+use polkadot_sdk::frame_election_provider_support::Get;
+use polkadot_sdk::sp_runtime::DispatchError;
 use polkadot_sdk::{
-    frame_support::{dispatch::DispatchResult, CloneNoBound},
-    polkadot_sdk_frame::prelude::OriginFor,
+    frame_support::{dispatch::DispatchResult, ensure, CloneNoBound},
     sp_runtime::{BoundedVec, Percent},
 };
 use scale_info::prelude::vec::Vec;
@@ -13,31 +14,199 @@ use scale_info::TypeInfo;
 pub struct Agent<T: crate::Config> {
     pub key: AccountIdOf<T>,
     pub name: BoundedVec<u8, T::MaxAgentNameLengthConstraint>,
-    pub address: BoundedVec<u8, T::MaxAgentAddressLengthConstraint>,
+    pub url: BoundedVec<u8, T::MaxAgentUrlLengthConstraint>,
+    pub metadata: BoundedVec<u8, T::MaxAgentMetadataLengthConstraint>,
     pub weight_factor: Percent,
 }
 
 pub fn register<T: crate::Config>(
-    _origin: OriginFor<T>,
-    _name: Vec<u8>,
-    _address: Vec<u8>,
-    _agent_key: AccountIdOf<T>,
-    _metadata: Option<Vec<u8>>,
+    agent_key: AccountIdOf<T>,
+    name: Vec<u8>,
+    url: Vec<u8>,
+    metadata: Vec<u8>,
 ) -> DispatchResult {
-    todo!()
+    ensure!(
+        !exists::<T>(&agent_key),
+        crate::Error::<T>::AgentAlreadyRegistered
+    );
+
+    ensure!(
+        crate::RegistrationsThisBlock::<T>::get() < crate::MaxRegistrationsPerBlock::<T>::get(),
+        crate::Error::<T>::TooManyAgentRegistrationsThisBlock
+    );
+
+    let burn_config = crate::BurnConfig::<T>::get();
+    ensure!(
+        crate::RegistrationsThisInterval::<T>::get() < burn_config.max_registrations_per_interval,
+        crate::Error::<T>::TooManyAgentRegistrationsThisBlock
+    );
+
+    validate_agent_name::<T>(&name[..])?;
+    validate_agent_url::<T>(&url[..])?;
+    validate_agent_metadata::<T>(&metadata[..])?;
+
+    // TODO: check if agent is on whitelist
+
+    crate::Agents::<T>::insert(
+        agent_key.clone(),
+        Agent {
+            key: agent_key.clone(),
+            name: BoundedVec::truncate_from(name),
+            url: BoundedVec::truncate_from(url),
+            metadata: BoundedVec::truncate_from(metadata),
+            weight_factor: Percent::from_percent(100),
+        },
+    );
+
+    crate::Pallet::<T>::deposit_event(crate::Event::<T>::AgentRegistered(agent_key));
+
+    Ok(())
 }
 
-pub fn deregister<T: crate::Config>(_origin: OriginFor<T>) -> DispatchResult {
-    todo!()
+pub fn unregister<T: crate::Config>(agent_key: AccountIdOf<T>) -> DispatchResult {
+    ensure!(
+        exists::<T>(&agent_key),
+        crate::Error::<T>::AgentDoesNotExist
+    );
+
+    crate::Agents::<T>::remove(&agent_key);
+
+    crate::Pallet::<T>::deposit_event(crate::Event::<T>::AgentUnregistered(agent_key));
+
+    Ok(())
 }
 
 pub fn update<T: crate::Config>(
-    _origin: OriginFor<T>,
-    _name: Vec<u8>,
-    _address: Vec<u8>,
-    _metadata: Option<Vec<u8>>,
-    _staking_fee: Option<Percent>,
-    _weight_control_fee: Option<Percent>,
+    agent_key: AccountIdOf<T>,
+    name: Vec<u8>,
+    url: Vec<u8>,
+    metadata: Option<Vec<u8>>,
+    staking_fee: Option<Percent>,
+    weight_control_fee: Option<Percent>,
 ) -> DispatchResult {
-    todo!()
+    ensure!(
+        exists::<T>(&agent_key),
+        crate::Error::<T>::AgentDoesNotExist
+    );
+
+    crate::Agents::<T>::try_mutate(&agent_key, |agent| {
+        let Some(agent) = agent else {
+            return Err(crate::Error::<T>::AgentDoesNotExist.into());
+        };
+
+        validate_agent_name::<T>(&name[..])?;
+        agent.name = BoundedVec::truncate_from(name);
+
+        validate_agent_url::<T>(&url[..])?;
+        agent.url = BoundedVec::truncate_from(url);
+
+        if let Some(metadata) = metadata {
+            validate_agent_metadata::<T>(&metadata[..])?;
+            agent.metadata = BoundedVec::truncate_from(metadata);
+        }
+
+        Ok::<(), DispatchError>(())
+    })?;
+
+    if staking_fee.is_none() && weight_control_fee.is_none() {
+        return Ok(());
+    }
+
+    crate::Fee::<T>::try_mutate(&agent_key, |fee| {
+        let constraints = crate::FeeConstraints::<T>::get();
+
+        if let Some(staking_fee) = staking_fee {
+            ensure!(
+                staking_fee >= constraints.min_staking_fee,
+                crate::Error::<T>::InvalidStakingFee
+            );
+
+            fee.staking_fee = staking_fee;
+        }
+
+        if let Some(weight_control_fee) = weight_control_fee {
+            ensure!(
+                weight_control_fee >= constraints.min_weight_control_fee,
+                crate::Error::<T>::InvalidWeightControlFee
+            );
+
+            fee.weight_control_fee = weight_control_fee;
+        }
+
+        Ok::<(), DispatchError>(())
+    })?;
+
+    Ok(())
+}
+
+pub fn exists<T: crate::Config>(key: &AccountIdOf<T>) -> bool {
+    crate::Agents::<T>::contains_key(key)
+}
+
+fn validate_agent_name<T: crate::Config>(bytes: &[u8]) -> DispatchResult {
+    let len: u32 = bytes
+        .len()
+        .try_into()
+        .map_err(|_| crate::Error::<T>::AgentNameTooLong)?;
+
+    ensure!(
+        len >= crate::MinNameLength::<T>::get() as u32,
+        crate::Error::<T>::AgentNameTooShort
+    );
+
+    ensure!(
+        len <= (crate::MaxNameLength::<T>::get() as u32)
+            .min(T::MaxAgentNameLengthConstraint::get()),
+        crate::Error::<T>::AgentNameTooShort
+    );
+
+    ensure!(
+        core::str::from_utf8(bytes).is_ok(),
+        crate::Error::<T>::InvalidAgentName
+    );
+
+    Ok(())
+}
+
+fn validate_agent_url<T: crate::Config>(bytes: &[u8]) -> DispatchResult {
+    let len: u32 = bytes
+        .len()
+        .try_into()
+        .map_err(|_| crate::Error::<T>::AgentUrlTooLong)?;
+
+    ensure!(len > 0, crate::Error::<T>::AgentNameTooShort);
+
+    ensure!(
+        len <= (crate::MaxNameLength::<T>::get() as u32)
+            .min(T::MaxAgentNameLengthConstraint::get()),
+        crate::Error::<T>::AgentUrlTooShort
+    );
+
+    ensure!(
+        core::str::from_utf8(bytes).is_ok(),
+        crate::Error::<T>::InvalidAgentUrl
+    );
+
+    Ok(())
+}
+
+fn validate_agent_metadata<T: crate::Config>(bytes: &[u8]) -> DispatchResult {
+    let len: u32 = bytes
+        .len()
+        .try_into()
+        .map_err(|_| crate::Error::<T>::AgentMetadataTooLong)?;
+
+    ensure!(len > 0, crate::Error::<T>::AgentMetadataTooShort);
+
+    ensure!(
+        len <= T::MaxAgentMetadataLengthConstraint::get(),
+        crate::Error::<T>::AgentMetadataTooLong
+    );
+
+    ensure!(
+        core::str::from_utf8(bytes).is_ok(),
+        crate::Error::<T>::InvalidAgentMetadata
+    );
+
+    Ok(())
 }
diff --git a/pallets/torus0/src/balance.rs b/pallets/torus0/src/balance.rs
index 9bd0693..0065384 100644
--- a/pallets/torus0/src/balance.rs
+++ b/pallets/torus0/src/balance.rs
@@ -1,13 +1,21 @@
-use polkadot_sdk::{
-    frame_support::dispatch::DispatchResult, polkadot_sdk_frame::prelude::OriginFor,
-};
-
 use crate::{AccountIdOf, BalanceOf};
+use polkadot_sdk::frame_support::traits::{Currency, ExistenceRequirement};
+use polkadot_sdk::frame_support::{dispatch::DispatchResult, ensure};
 
-pub fn transfer_balance_multiple<T: crate::Config>(
-    _origin: OriginFor<T>,
-    _destination: AccountIdOf<T>,
-    _amount: BalanceOf<T>,
+pub fn transfer_balance<T: crate::Config>(
+    key: AccountIdOf<T>,
+    destination: AccountIdOf<T>,
+    amount: BalanceOf<T>,
 ) -> DispatchResult {
-    todo!()
+    ensure!(amount > 0, crate::Error::<T>::InvalidAmount);
+
+    <T as crate::Config>::Currency::transfer(
+        &key,
+        &destination,
+        amount,
+        ExistenceRequirement::KeepAlive,
+    )
+    .map_err(|_| crate::Error::<T>::NotEnoughBalanceToTransfer)?;
+
+    Ok(())
 }
diff --git a/pallets/torus0/src/burn.rs b/pallets/torus0/src/burn.rs
new file mode 100644
index 0000000..7272fae
--- /dev/null
+++ b/pallets/torus0/src/burn.rs
@@ -0,0 +1,94 @@
+use crate::{BalanceOf, BlockAmount};
+use codec::{Decode, Encode, MaxEncodedLen};
+use polkadot_sdk::frame_election_provider_support::Get;
+use polkadot_sdk::frame_support::DebugNoBound;
+use scale_info::prelude::marker::PhantomData;
+use scale_info::TypeInfo;
+use substrate_fixed::types::I110F18;
+
+#[derive(Clone, TypeInfo, Decode, Encode, PartialEq, Eq, DebugNoBound, MaxEncodedLen)]
+#[scale_info(skip_type_params(T))]
+pub struct BurnConfiguration<T: crate::Config> {
+    pub min_burn: BalanceOf<T>,
+    pub max_burn: BalanceOf<T>,
+    pub adjustment_alpha: u64,
+    pub target_registrations_interval: BlockAmount,
+    pub target_registrations_per_interval: u16,
+    pub max_registrations_per_interval: u16,
+    pub _pd: PhantomData<T>,
+}
+
+impl<T> Default for BurnConfiguration<T>
+where
+    T: crate::Config,
+{
+    fn default() -> Self {
+        Self {
+            min_burn: T::DefaultMinBurn::get(),
+            max_burn: T::DefaultMaxBurn::get(),
+            adjustment_alpha: T::DefaultAdjustmentAlpha::get(),
+            target_registrations_interval: T::DefaultTargetRegistrationsInterval::get(),
+            target_registrations_per_interval: T::DefaultTargetRegistrationsPerInterval::get(),
+            max_registrations_per_interval: T::DefaultMaxRegistrationsPerInterval::get(),
+            _pd: Default::default(),
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub fn adjust_burn<T: crate::Config>(current_block: u64) {
+    let BurnConfiguration {
+        min_burn,
+        max_burn,
+        adjustment_alpha,
+        target_registrations_interval,
+        target_registrations_per_interval,
+        ..
+    } = crate::BurnConfig::<T>::get();
+
+    let current_burn = crate::Burn::<T>::get();
+    let registrations_this_interval = crate::RegistrationsThisInterval::<T>::get();
+
+    let reached_interval = current_block
+        .checked_rem(target_registrations_interval)
+        .is_some_and(|r| r == 0);
+
+    if !reached_interval {
+        return;
+    }
+
+    let updated_burn: I110F18 = I110F18::from_num(current_burn)
+        .checked_mul(I110F18::from_num(
+            registrations_this_interval.saturating_add(target_registrations_per_interval),
+        ))
+        .unwrap_or_default()
+        .checked_div(I110F18::from_num(
+            target_registrations_per_interval.saturating_add(target_registrations_per_interval),
+        ))
+        .unwrap_or_default();
+
+    let alpha: I110F18 = I110F18::from_num(adjustment_alpha)
+        .checked_div(I110F18::from_num(u64::MAX))
+        .unwrap_or_else(|| I110F18::from_num(0));
+
+    let next_value: I110F18 = alpha
+        .checked_mul(I110F18::from_num(current_burn))
+        .unwrap_or_else(|| I110F18::from_num(0))
+        .saturating_add(
+            I110F18::from_num(1.0)
+                .saturating_sub(alpha)
+                .checked_mul(updated_burn)
+                .unwrap_or_else(|| I110F18::from_num(0)),
+        );
+
+    let new_burn = if next_value >= I110F18::from_num(max_burn) {
+        max_burn
+    } else if next_value <= I110F18::from_num(min_burn) {
+        min_burn
+    } else {
+        next_value.to_num::<BalanceOf<T>>()
+    };
+
+    crate::Burn::<T>::set(new_burn);
+    crate::RegistrationsThisInterval::<T>::set(0);
+}
diff --git a/pallets/torus0/src/fee.rs b/pallets/torus0/src/fee.rs
index 634633c..7faa800 100644
--- a/pallets/torus0/src/fee.rs
+++ b/pallets/torus0/src/fee.rs
@@ -8,7 +8,7 @@ use scale_info::TypeInfo;
 #[derive(DebugNoBound, Decode, Encode, MaxEncodedLen, PartialEq, Eq, TypeInfo)]
 #[scale_info(skip_type_params(T))]
 pub struct ValidatorFeeConstraints<T: crate::Config> {
-    pub min_stake_delegation_fee: Percent,
+    pub min_staking_fee: Percent,
     pub min_weight_control_fee: Percent,
     pub _pd: PhantomData<T>,
 }
@@ -16,7 +16,7 @@ pub struct ValidatorFeeConstraints<T: crate::Config> {
 impl<T: crate::Config> Default for ValidatorFeeConstraints<T> {
     fn default() -> Self {
         Self {
-            min_stake_delegation_fee: Percent::from_percent(T::DefaultMinStakingFee::get()),
+            min_staking_fee: Percent::from_percent(T::DefaultMinStakingFee::get()),
             min_weight_control_fee: Percent::from_percent(T::DefaultMinWeightControlFee::get()),
             _pd: PhantomData,
         }
@@ -26,7 +26,7 @@ impl<T: crate::Config> Default for ValidatorFeeConstraints<T> {
 #[derive(DebugNoBound, Decode, Encode, MaxEncodedLen, PartialEq, Eq, TypeInfo)]
 #[scale_info(skip_type_params(T))]
 pub struct ValidatorFee<T: crate::Config> {
-    pub stake_delegation_fee: Percent,
+    pub staking_fee: Percent,
     pub weight_control_fee: Percent,
     pub _pd: PhantomData<T>,
 }
@@ -34,7 +34,7 @@ pub struct ValidatorFee<T: crate::Config> {
 impl<T: crate::Config> Default for ValidatorFee<T> {
     fn default() -> Self {
         Self {
-            stake_delegation_fee: Percent::from_percent(T::DefaultMinStakingFee::get()),
+            staking_fee: Percent::from_percent(T::DefaultMinStakingFee::get()),
             weight_control_fee: Percent::from_percent(T::DefaultMinWeightControlFee::get()),
             _pd: PhantomData,
         }
diff --git a/pallets/torus0/src/lib.rs b/pallets/torus0/src/lib.rs
index 1e491c2..04a0df4 100644
--- a/pallets/torus0/src/lib.rs
+++ b/pallets/torus0/src/lib.rs
@@ -2,15 +2,18 @@
 
 mod agent;
 mod balance;
+mod burn;
 mod ext;
 mod fee;
 mod stake;
 
 use crate::agent::Agent;
+use crate::burn::BurnConfiguration;
 use crate::fee::ValidatorFee;
 use crate::fee::ValidatorFeeConstraints;
 pub(crate) use ext::*;
 use frame::arithmetic::Percent;
+use frame::prelude::ensure_signed;
 pub use pallet::*;
 use polkadot_sdk::frame_support::{
     dispatch::DispatchResult,
@@ -66,7 +69,7 @@ pub mod pallet {
         StorageValue<_, u16, ValueQuery, T::DefaultMaxAllowedWeights>;
 
     #[pallet::storage]
-    pub type Tempo<T: Config> = StorageValue<_, u16, ValueQuery, T::DefaultTempo>;
+    pub type RewardInterval<T: Config> = StorageValue<_, u16, ValueQuery, T::DefaultRewardInterval>;
 
     #[pallet::storage]
     pub type Agents<T: Config> = StorageMap<_, Identity, AccountIdOf<T>, Agent<T>>;
@@ -91,7 +94,7 @@ pub mod pallet {
     pub type MinWeightStake<T> = StorageValue<_, BalanceOf<T>, ValueQuery>;
 
     #[pallet::storage]
-    pub type RegistrationsPerBlock<T> = StorageValue<_, u16, ValueQuery>;
+    pub type RegistrationsThisBlock<T> = StorageValue<_, u16, ValueQuery>;
 
     #[pallet::storage]
     pub type MaxRegistrationsPerBlock<T: Config> =
@@ -118,12 +121,35 @@ pub mod pallet {
     #[pallet::storage]
     pub type Fee<T: Config> = StorageMap<_, Identity, T::AccountId, ValidatorFee<T>, ValueQuery>;
 
-    #[pallet::config]
+    #[pallet::storage]
+    pub type BurnConfig<T: Config> = StorageValue<_, BurnConfiguration<T>, ValueQuery>;
+
+    #[pallet_section]
+    pub mod hooks {
+        #[pallet::hooks]
+        impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+            fn on_initialize(block_number: BlockNumberFor<T>) -> Weight {
+                let current_block: u64 = block_number
+                    .try_into()
+                    .ok()
+                    .expect("blockchain won't pass 2 ^ 64 blocks");
+
+                burn::adjust_burn::<T>(current_block);
+
+                RegistrationsThisBlock::<T>::set(0);
+
+                Weight::default()
+            }
+        }
+    }
+
+    #[pallet::config(with_default)]
     pub trait Config: polkadot_sdk::frame_system::Config {
         #[pallet::constant]
         type DefaultMaxAllowedValidators: Get<u16>;
 
         #[pallet::constant]
+        #[pallet::no_default_bounds]
         type DefaultMinValidatorStake: Get<BalanceOf<Self>>;
 
         #[pallet::constant]
@@ -139,7 +165,7 @@ pub mod pallet {
         type DefaultMaxAllowedWeights: Get<u16>;
 
         #[pallet::constant]
-        type DefaultTempo: Get<u16>;
+        type DefaultRewardInterval: Get<u16>;
 
         #[pallet::constant]
         type DefaultMinNameLength: Get<u16>;
@@ -154,6 +180,7 @@ pub mod pallet {
         type DefaultMaxRegistrationsPerBlock: Get<u16>;
 
         #[pallet::constant]
+        #[pallet::no_default_bounds]
         type DefaultMinimumAllowedStake: Get<BalanceOf<Self>>;
 
         #[pallet::constant]
@@ -162,6 +189,28 @@ pub mod pallet {
         #[pallet::constant]
         type DefaultMinWeightControlFee: Get<u8>;
 
+        #[pallet::constant]
+        #[pallet::no_default_bounds]
+        type DefaultMinBurn: Get<BalanceOf<Self>>;
+
+        #[pallet::constant]
+        #[pallet::no_default_bounds]
+        type DefaultMaxBurn: Get<BalanceOf<Self>>;
+
+        #[pallet::constant]
+        type DefaultAdjustmentAlpha: Get<u64>;
+
+        #[pallet::constant]
+        type DefaultTargetRegistrationsInterval: Get<u64>;
+
+        #[pallet::constant]
+        #[pallet::no_default_bounds]
+        type DefaultTargetRegistrationsPerInterval: Get<u16>;
+
+        #[pallet::constant]
+        #[pallet::no_default_bounds]
+        type DefaultMaxRegistrationsPerInterval: Get<u16>;
+
         /// The storage MaxNameLength should be constrained to be no more than the value of this.
         /// This is needed on agent::Agent to set the `name` field BoundedVec max length.
         #[pallet::constant]
@@ -169,7 +218,14 @@ pub mod pallet {
 
         /// This is needed on agent::Agent to set the `address` field BoundedVec max length.
         #[pallet::constant]
-        type MaxAgentAddressLengthConstraint: Get<u32>;
+        type MaxAgentUrlLengthConstraint: Get<u32>;
+
+        #[pallet::constant]
+        type MaxAgentMetadataLengthConstraint: Get<u32>;
+
+        #[pallet::no_default_bounds]
+        type RuntimeEvent: From<Event<Self>>
+            + IsType<<Self as polkadot_sdk::frame_system::Config>::RuntimeEvent>;
 
         type Currency: Currency<Self::AccountId, Balance = u128> + Send + Sync;
     }
@@ -186,7 +242,8 @@ pub mod pallet {
             agent_key: AccountIdOf<T>,
             amount: BalanceOf<T>,
         ) -> DispatchResult {
-            stake::add_stake::<T>(origin, agent_key, amount)
+            let key = ensure_signed(origin)?;
+            stake::add_stake::<T>(key, agent_key, amount)
         }
 
         #[pallet::call_index(1)]
@@ -196,7 +253,8 @@ pub mod pallet {
             agent_key: AccountIdOf<T>,
             amount: BalanceOf<T>,
         ) -> DispatchResult {
-            stake::remove_stake::<T>(origin, agent_key, amount)
+            let key = ensure_signed(origin)?;
+            stake::remove_stake::<T>(key, agent_key, amount)
         }
 
         #[pallet::call_index(2)]
@@ -207,7 +265,8 @@ pub mod pallet {
             new_agent_key: AccountIdOf<T>,
             amount: BalanceOf<T>,
         ) -> DispatchResult {
-            stake::transfer_stake::<T>(origin, agent_key, new_agent_key, amount)
+            let key = ensure_signed(origin)?;
+            stake::transfer_stake::<T>(key, agent_key, new_agent_key, amount)
         }
 
         #[pallet::call_index(3)]
@@ -217,25 +276,28 @@ pub mod pallet {
             destination: AccountIdOf<T>,
             amount: BalanceOf<T>,
         ) -> DispatchResult {
-            balance::transfer_balance_multiple::<T>(origin, destination, amount)
+            let key = ensure_signed(origin)?;
+            balance::transfer_balance::<T>(key, destination, amount)
         }
 
         #[pallet::call_index(4)]
         #[pallet::weight(0)]
         pub fn register_agent(
             origin: OriginFor<T>,
-            name: Vec<u8>,
-            address: Vec<u8>,
             agent_key: T::AccountId,
-            metadata: Option<Vec<u8>>,
+            name: Vec<u8>,
+            url: Vec<u8>,
+            metadata: Vec<u8>,
         ) -> DispatchResult {
-            agent::register::<T>(origin, name, address, agent_key, metadata)
+            ensure_signed(origin)?;
+            agent::register::<T>(agent_key, name, url, metadata)
         }
 
         #[pallet::call_index(5)]
         #[pallet::weight(0)]
-        pub fn deregister_agent(origin: OriginFor<T>) -> DispatchResult {
-            agent::deregister::<T>(origin)
+        pub fn unregister_agent(origin: OriginFor<T>) -> DispatchResult {
+            let agent_key = ensure_signed(origin)?;
+            agent::unregister::<T>(agent_key)
         }
 
         #[pallet::call_index(6)]
@@ -248,8 +310,9 @@ pub mod pallet {
             staking_fee: Option<Percent>,
             weight_control_fee: Option<Percent>,
         ) -> DispatchResult {
+            let agent_key = ensure_signed(origin)?;
             agent::update::<T>(
-                origin,
+                agent_key,
                 name,
                 address,
                 metadata,
@@ -259,18 +322,35 @@ pub mod pallet {
         }
     }
 
+    #[pallet::event]
+    #[pallet::generate_deposit(pub fn deposit_event)]
+    pub enum Event<T: Config> {
+        /// Event created when stake has been transferred from the coldkey account onto the key
+        /// staking account
+        StakeAdded(AccountIdOf<T>, AccountIdOf<T>, BalanceOf<T>),
+        /// Event created when stake has been removed from the key staking account onto the coldkey
+        /// account
+        StakeRemoved(AccountIdOf<T>, AccountIdOf<T>, BalanceOf<T>),
+        /// Event created when a new agent account has been registered to the chain
+        AgentRegistered(AccountIdOf<T>),
+        /// Event created when a agent account has been deregistered from the chain
+        AgentUnregistered(AccountIdOf<T>),
+        /// Event created when the agent's updated information is added to the network
+        AgentUpdated(AccountIdOf<T>),
+    }
+
     #[pallet::error]
     pub enum Error<T> {
-        /// The specified module does not exist.
+        /// The specified agent does not exist.
         AgentDoesNotExist,
         /// Insufficient stake to withdraw the requested amount.
         NotEnoughStakeToWithdraw,
         /// Insufficient balance in the cold key account to stake the requested amount.
         NotEnoughBalanceToStake,
         /// The number of agent registrations in this block exceeds the allowed limit.
-        TooManyAgentRegistrationsPerBlock,
+        TooManyAgentRegistrationsThisBlock,
         /// The number of agent registrations in this interval exceeds the allowed limit.
-        TooManyAgentRegistrationsPerInterval,
+        TooManyAgentRegistrationsThisInterval,
         /// The agent is already registered in the active set.
         AgentAlreadyRegistered,
         /// Failed to convert between u128 and T::Balance.
@@ -279,8 +359,6 @@ pub mod pallet {
         BalanceNotAdded,
         /// Failed to remove stake from the account.
         StakeNotRemoved,
-        /// The key is already registered.
-        KeyAlreadyRegistered,
         /// Invalid shares distribution.
         InvalidShares,
         /// Insufficient balance to register.
@@ -295,30 +373,34 @@ pub mod pallet {
         NotEnoughStakeToRegister,
         /// The entity is still registered and cannot be modified.
         StillRegistered,
-        /// Attempted to set max allowed modules to a value less than the current number of
-        /// registered modules.
-        MaxAllowedModules,
+        /// Attempted to set max allowed agents to a value less than the current number of
+        /// registered agents.
+        MaxAllowedAgents,
         /// Insufficient balance to transfer.
         NotEnoughBalanceToTransfer,
-        /// The module metadata is invalid.
+        /// The agent metadata is invalid.
         InvalidAgentMetadata,
-        /// The module metadata is too long.
+        /// The agent metadata is too long.
         AgentMetadataTooLong,
+        /// The agent metadata is too long.
+        AgentMetadataTooShort,
         /// The minimum burn value is invalid, likely too small.
         InvalidMinBurn,
         /// The maximum burn value is invalid.
         InvalidMaxBurn,
-        /// The module name is too long.
+        /// The agent name is too long.
         AgentNameTooLong,
-        /// The module name is too short.
+        /// The agent name is too short.
         AgentNameTooShort,
-        /// The module name is invalid. It must be a UTF-8 encoded string.
+        /// The agent name is invalid. It must be a UTF-8 encoded string.
         InvalidAgentName,
-        /// The module address is too long.
-        AgentAddressTooLong,
-        /// The module address is invalid.
-        InvalidAgentAddress,
-        /// A module with this name already exists in the subnet.
+        /// The agent url is too long.
+        AgentUrlTooLong,
+        /// The agent url is too short.
+        AgentUrlTooShort,
+        /// The agent ur; is invalid.
+        InvalidAgentUrl,
+        /// A agent with this name already exists in the subnet.
         AgentNameAlreadyExists,
         /// An arithmetic error occurred during calculation.
         ArithmeticError,
@@ -330,5 +412,11 @@ pub mod pallet {
         StakeTooSmall,
         /// Key is not present in Whitelist, it needs to be whitelisted by a Curator
         AgentKeyNotWhitelisted,
+        /// The amount given is 0
+        InvalidAmount,
+        /// The staking fee given is lower than the minimum fee
+        InvalidStakingFee,
+        /// The weight control fee given is lower than the minimum fee
+        InvalidWeightControlFee,
     }
 }
diff --git a/pallets/torus0/src/stake.rs b/pallets/torus0/src/stake.rs
index fb38064..1dc9c87 100644
--- a/pallets/torus0/src/stake.rs
+++ b/pallets/torus0/src/stake.rs
@@ -1,30 +1,88 @@
-use polkadot_sdk::{
-    frame_support::dispatch::DispatchResult, polkadot_sdk_frame::prelude::OriginFor,
-};
-
+use crate::agent;
 use crate::{AccountIdOf, BalanceOf};
+use polkadot_sdk::frame_support::traits::{Currency, ExistenceRequirement, WithdrawReasons};
+use polkadot_sdk::frame_support::{dispatch::DispatchResult, ensure};
 
 pub fn add_stake<T: crate::Config>(
-    _origin: OriginFor<T>,
-    _agent_key: AccountIdOf<T>,
-    _amount: BalanceOf<T>,
+    key: AccountIdOf<T>,
+    agent_key: AccountIdOf<T>,
+    amount: BalanceOf<T>,
 ) -> DispatchResult {
-    todo!()
+    ensure!(
+        amount >= crate::MinimumAllowedStake::<T>::get(),
+        crate::Error::<T>::StakeTooSmall
+    );
+
+    ensure!(
+        agent::exists::<T>(&agent_key),
+        crate::Error::<T>::AgentDoesNotExist
+    );
+
+    let _ = <T as crate::Config>::Currency::withdraw(
+        &key,
+        amount,
+        WithdrawReasons::TRANSFER,
+        ExistenceRequirement::KeepAlive,
+    )
+    .map_err(|_| crate::Error::<T>::NotEnoughBalanceToStake)?;
+
+    crate::StakingTo::<T>::mutate(&key, &agent_key, |stake| {
+        *stake = Some(stake.unwrap_or(0).saturating_add(amount))
+    });
+
+    crate::StakedBy::<T>::mutate(&agent_key, &key, |stake| {
+        *stake = Some(stake.unwrap_or(0).saturating_add(amount))
+    });
+
+    crate::TotalStake::<T>::mutate(|total_stake| *total_stake = total_stake.saturating_add(amount));
+
+    crate::Pallet::<T>::deposit_event(crate::Event::<T>::StakeAdded(key, agent_key, amount));
+
+    Ok(())
 }
 
 pub fn remove_stake<T: crate::Config>(
-    _origin: OriginFor<T>,
-    _agent_key: AccountIdOf<T>,
-    _amount: BalanceOf<T>,
+    key: AccountIdOf<T>,
+    agent_key: AccountIdOf<T>,
+    amount: BalanceOf<T>,
 ) -> DispatchResult {
-    todo!()
+    ensure!(
+        amount >= crate::MinimumAllowedStake::<T>::get(),
+        crate::Error::<T>::StakeTooSmall
+    );
+
+    ensure!(
+        agent::exists::<T>(&agent_key),
+        crate::Error::<T>::AgentDoesNotExist
+    );
+
+    ensure!(
+        crate::StakingTo::<T>::get(&key, &agent_key).unwrap_or(0) >= amount,
+        crate::Error::<T>::NotEnoughStakeToWithdraw
+    );
+
+    crate::StakingTo::<T>::mutate(&key, &agent_key, |stake| {
+        *stake = Some(stake.unwrap_or(0).saturating_sub(amount))
+    });
+
+    crate::StakedBy::<T>::mutate(&agent_key, &key, |stake| {
+        *stake = Some(stake.unwrap_or(0).saturating_sub(amount))
+    });
+
+    crate::TotalStake::<T>::mutate(|total_stake| *total_stake = total_stake.saturating_sub(amount));
+
+    let _ = <T as crate::Config>::Currency::deposit_creating(&key, amount);
+
+    Ok(())
 }
 
 pub fn transfer_stake<T: crate::Config>(
-    _origin: OriginFor<T>,
-    _agent_key: AccountIdOf<T>,
-    _new_agent_key: AccountIdOf<T>,
-    _amount: BalanceOf<T>,
+    key: AccountIdOf<T>,
+    agent_key: AccountIdOf<T>,
+    new_agent_key: AccountIdOf<T>,
+    amount: BalanceOf<T>,
 ) -> DispatchResult {
-    todo!()
+    remove_stake::<T>(key.clone(), agent_key, amount)?;
+    add_stake::<T>(key, new_agent_key, amount)?;
+    Ok(())
 }
diff --git a/runtime/src/configs.rs b/runtime/src/configs.rs
index 59e3265..c771583 100644
--- a/runtime/src/configs.rs
+++ b/runtime/src/configs.rs
@@ -288,8 +288,6 @@ impl pallet_grandpa::Config for Runtime {
 // --- Torus ---
 
 impl pallet_torus0::Config for Runtime {
-    type Currency = Balances;
-
     type DefaultMinValidatorStake = ConstU128<50_000_000_000_000>;
 
     type DefaultImmunityPeriod = ConstU16<0>;
@@ -300,7 +298,7 @@ impl pallet_torus0::Config for Runtime {
 
     type DefaultMaxAllowedWeights = ConstU16<420>;
 
-    type DefaultTempo = ConstU16<100>;
+    type DefaultRewardInterval = ConstU16<100>;
 
     type DefaultMinNameLength = ConstU16<2>;
 
@@ -318,12 +316,30 @@ impl pallet_torus0::Config for Runtime {
 
     type DefaultMinWeightControlFee = ConstU8<4>;
 
+    type DefaultMinBurn = ConstU128<10_000_000_000>;
+
+    type DefaultMaxBurn = ConstU128<150_000_000_000>;
+
+    type DefaultAdjustmentAlpha = ConstU64<{ u64::MAX / 2 }>;
+
+    type DefaultTargetRegistrationsInterval = ConstU64<142>;
+
+    type DefaultTargetRegistrationsPerInterval = ConstU16<3>;
+
+    type DefaultMaxRegistrationsPerInterval = ConstU16<32>;
+
     #[doc = " The storage MaxNameLength should be constrained to be no more than the value of this."]
     #[doc = " This is needed on agent::Agent to set the `name` field BoundedVec max length."]
     type MaxAgentNameLengthConstraint = ConstU32<256>;
 
     #[doc = " This is needed on agent::Agent to set the `address` field BoundedVec max length."]
-    type MaxAgentAddressLengthConstraint = ConstU32<256>;
+    type MaxAgentUrlLengthConstraint = ConstU32<256>;
+
+    type MaxAgentMetadataLengthConstraint = ConstU32<256>;
+
+    type RuntimeEvent = RuntimeEvent;
+
+    type Currency = Balances;
 }
 
 parameter_types! {
diff --git a/test-utils/src/lib.rs b/test-utils/src/lib.rs
index adad249..548df37 100644
--- a/test-utils/src/lib.rs
+++ b/test-utils/src/lib.rs
@@ -67,7 +67,7 @@ impl pallet_torus0::Config for Test {
 
     type DefaultMaxAllowedWeights = ConstU16<420>;
 
-    type DefaultTempo = ConstU16<100>;
+    type DefaultRewardInterval = ConstU16<100>;
 
     type DefaultMinNameLength = ConstU16<2>;
 
@@ -85,12 +85,28 @@ impl pallet_torus0::Config for Test {
 
     type DefaultMinWeightControlFee = ConstU8<4>;
 
+    type DefaultMinBurn = ConstU128<10_000_000_000>;
+
+    type DefaultMaxBurn = ConstU128<150_000_000_000>;
+
+    type DefaultAdjustmentAlpha = ConstU64<{ u64::MAX / 2 }>;
+
+    type DefaultTargetRegistrationsInterval = ConstU64<142>;
+
+    type DefaultTargetRegistrationsPerInterval = ConstU16<3>;
+
+    type DefaultMaxRegistrationsPerInterval = ConstU16<32>;
+
     #[doc = " The storage MaxNameLength should be constrained to be no more than the value of this."]
     #[doc = " This is needed on agent::Agent to set the `name` field BoundedVec max length."]
     type MaxAgentNameLengthConstraint = ConstU32<256>;
 
     #[doc = " This is needed on agent::Agent to set the `address` field BoundedVec max length."]
-    type MaxAgentAddressLengthConstraint = ConstU32<256>;
+    type MaxAgentUrlLengthConstraint = ConstU32<256>;
+
+    type MaxAgentMetadataLengthConstraint = ConstU32<256>;
+
+    type RuntimeEvent = RuntimeEvent;
 
     type Currency = Balances;
 }