diff --git a/sessions_manager.cpp b/sessions_manager.cpp
new file mode 100644
index 0000000..ff17727
--- /dev/null
+++ b/sessions_manager.cpp
@@ -0,0 +1,166 @@
+#include "sessions_manager.hpp"
+
+#include <algorithm>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+
+#include "session.hpp"
+
+namespace session
+{
+
+Manager::Manager()
+{
+    /*
+     * Session ID is 0000_0000h for messages that are sent outside the session.
+     * The session setup commands are sent on this session, so when the session
+     * manager comes up, is creates the Session ID  0000_0000h. It is active
+     * through the lifetime of the Session Manager.
+     */
+    sessionsMap.emplace(0, std::make_shared<Session>());
+    // Seeding the pseudo-random generator
+    std::srand(std::time(0));
+}
+
+std::weak_ptr<Session> Manager::startSession(SessionID remoteConsoleSessID,
+        Privilege priv, cipher::rakp_auth::Algorithms authAlgo)
+{
+    std::shared_ptr<Session> session = nullptr;
+    SessionID sessionID = 0;
+    cleanStaleEntries();
+    auto activeSessions = sessionsMap.size() - MAX_SESSIONLESS_COUNT;
+
+    if (activeSessions < MAX_SESSION_COUNT)
+    {
+        do
+        {
+            session = std::make_shared<Session>(remoteConsoleSessID, priv);
+
+            /*
+             * Every IPMI Session has two ID's attached to it Remote Console
+             * Session ID and BMC Session ID. The remote console ID is passed
+             * along with the Open Session request command. The BMC session ID
+             * is the key for the session map and is generated using std::rand.
+             * There is a rare chance for collision of BMC session ID, so the
+             * following check validates that. In the case of collision the
+             * created session is reseted and a new session is created for
+             * validating collision.
+             */
+            auto iterator = sessionsMap.find(session->getBMCSessionID());
+            if (iterator != sessionsMap.end())
+            {
+               //Detected BMC Session ID collisions
+                session.reset();
+                continue;
+            }
+            else
+            {
+                break;
+            }
+        }
+        while (1);
+
+        // Set the Authentication Algorithm to RAKP_HMAC_SHA1
+        switch (authAlgo)
+        {
+            case cipher::rakp_auth::Algorithms::RAKP_HMAC_SHA1:
+            {
+                session->setAuthAlgo(
+                        std::make_unique<cipher::rakp_auth::AlgoSHA1>());
+                break;
+            }
+            default:
+            {
+                throw std::runtime_error("Invalid Authentication Algorithm");
+            }
+        }
+        sessionID = session->getBMCSessionID();
+        sessionsMap.emplace(sessionID, std::move(session));
+    }
+    else
+    {
+        std::cerr << "E> No free sessions left: Active: " << activeSessions <<
+                  " Allowed: " <<
+                  MAX_SESSION_COUNT << "\n";
+
+        for (const auto& iterator : sessionsMap)
+        {
+            std::cerr << "E> Active Session: 0x" << std::hex
+                      << std::setfill('0') << std::setw(8)
+                      << (iterator.second)->getBMCSessionID() << "\n";
+        }
+        throw std::runtime_error("No free sessions left");
+    }
+
+    return getSession(sessionID);
+}
+
+void Manager::stopSession(SessionID bmcSessionID)
+{
+    // If the session is valid and not session zero
+    if(bmcSessionID != SESSION_ZERO)
+    {
+        auto iter = sessionsMap.find(bmcSessionID);
+        if (iter != sessionsMap.end())
+        {
+            iter->second->state = State::TEAR_DOWN_IN_PROGRESS;
+        }
+    }
+}
+
+std::weak_ptr<Session> Manager::getSession(SessionID sessionID,
+                                           RetrieveOption option)
+{
+    switch (option)
+    {
+        case RetrieveOption::BMC_SESSION_ID:
+        {
+            auto iter = sessionsMap.find(sessionID);
+            if (iter != sessionsMap.end())
+            {
+                return iter->second;
+            }
+        }
+        case RetrieveOption::RC_SESSION_ID:
+        {
+            auto iter = std::find_if(sessionsMap.begin(),
+                                     sessionsMap.end(),
+                                     [sessionID](const std::pair<const uint32_t,
+                                                 std::shared_ptr<Session>>& in)
+                                                 -> bool
+            {
+                return sessionID == in.second->getRCSessionID();
+            });
+
+            if (iter != sessionsMap.end())
+            {
+                return iter->second;
+            }
+        }
+        default:
+            throw std::runtime_error("Invalid retrieval option");
+    }
+
+    throw std::runtime_error("Session ID not found");
+}
+
+void Manager::cleanStaleEntries()
+{
+    for(auto iter = sessionsMap.begin(); iter != sessionsMap.end();)
+    {
+        auto session = iter->second;
+        if ((session->getBMCSessionID() != SESSION_ZERO) &&
+            !(session->isSessionActive()))
+        {
+            iter = sessionsMap.erase(iter);
+        }
+        else
+        {
+            ++iter;
+        }
+    }
+}
+
+} // namespace session
diff --git a/sessions_manager.hpp b/sessions_manager.hpp
new file mode 100644
index 0000000..71bb7e4
--- /dev/null
+++ b/sessions_manager.hpp
@@ -0,0 +1,96 @@
+#pragma once
+
+#include <map>
+#include <memory>
+#include <mutex>
+
+#include "session.hpp"
+
+namespace session
+{
+
+enum class RetrieveOption
+{
+    BMC_SESSION_ID,
+    RC_SESSION_ID,
+};
+
+constexpr size_t SESSION_ZERO = 0;
+constexpr size_t MAX_SESSIONLESS_COUNT = 1;
+constexpr size_t MAX_SESSION_COUNT = 5;
+
+/*
+ * @class Manager
+ *
+ * Manager class acts a manager for the IPMI sessions and provides interfaces
+ * to start a session, stop a session and get reference to the session objects.
+ *
+ */
+
+class Manager
+{
+    public:
+
+        // BMC Session ID is the key for the map
+        using SessionMap = std::map<SessionID, std::shared_ptr<Session>>;
+
+        Manager();
+        ~Manager() = default;
+        Manager(const Manager&) = delete;
+        Manager& operator=(const Manager&) = delete;
+        Manager(Manager&&) = default;
+        Manager& operator=(Manager&&) = default;
+
+        /*
+         * @brief Start an IPMI session
+         *
+         * @param[in] remoteConsoleSessID - Remote Console Session ID mentioned
+         *            in the Open SessionRequest Command
+         * @param[in] priv - Privilege level requested
+         * @param[in] authAlgo - Authentication Algorithm
+         *
+         * @return session handle on success and nullptr on failure
+         *
+         */
+        std::weak_ptr<Session> startSession(SessionID remoteConsoleSessID,
+                Privilege priv, cipher::rakp_auth::Algorithms authAlgo);
+
+        /*
+         * @brief Stop IPMI Session
+         *
+         * @param[in] bmcSessionID - BMC Session ID
+         *
+         */
+        void stopSession(SessionID bmcSessionID);
+
+        /*
+         * @brief Get Session Handle
+         *
+         * @param[in] sessionID - Session ID
+         * @param[in] option - Select between BMC Session ID and Remote Console
+         *            Session ID, Default option is BMC Session ID
+         *
+         * @return session handle on success and nullptr on failure
+         *
+         */
+        std::weak_ptr<Session> getSession(
+               SessionID sessionID,
+               RetrieveOption option = RetrieveOption::BMC_SESSION_ID);
+
+    private:
+
+        /*
+         * @brief Session Manager keeps the session objects as a sorted
+         *        associative container with Session ID as the unique key
+         */
+        SessionMap sessionsMap;
+
+        /*
+         * @brief Clean Session Stale Entries
+         *
+         *  Removes the inactive sessions entries from the Session Map
+         */
+        void cleanStaleEntries();
+};
+
+} // namespace session