diff --git a/src/atlas_frontend/src/canisters/atlasSpace/api.ts b/src/atlas_frontend/src/canisters/atlasSpace/api.ts
index b1859cf..37be8eb 100644
--- a/src/atlas_frontend/src/canisters/atlasSpace/api.ts
+++ b/src/atlas_frontend/src/canisters/atlasSpace/api.ts
@@ -1,6 +1,7 @@
 import type { ActorSubclass } from "@dfinity/agent";
 import type {
   _SERVICE,
+  AnswerFormat,
   ClosedTask,
   State,
   Submission,
@@ -22,6 +23,7 @@ interface CreateSubtaskArg {
   title: string;
   description: string;
   allow_resubmit: boolean;
+  answer_format: AnswerFormat
 }
 
 interface GetAtlasSpaceArgs {
@@ -93,6 +95,7 @@ export const createNewTask = async ({
       task_title: arg.title,
       task_description: arg.description,
       allow_resubmit: arg.allow_resubmit,
+      answer_format: arg.answer_format
     },
   }));
 
diff --git a/src/atlas_frontend/src/components/Submissions/index.tsx b/src/atlas_frontend/src/components/Submissions/index.tsx
index 6bfe213..44bcf45 100644
--- a/src/atlas_frontend/src/components/Submissions/index.tsx
+++ b/src/atlas_frontend/src/components/Submissions/index.tsx
@@ -133,7 +133,7 @@ const Submissions = () => {
               </h2>
             </div>
             <div className="overflow-x-auto">
-              <table className="table-auto mt-6 w-full overflow-x-auto  text-white text-center rtl:text-right border-separate border-spacing-x-2 font-montserrat">
+              <table className="table-fixed mt-6 w-full text-white text-center rtl:text-right border-separate border-spacing-x-2 font-montserrat">
                 <thead>
                   <tr>
                     <th
@@ -380,6 +380,16 @@ const GenericTaskSummation = ({
             {submission.submissionData.submission.Text.content}
           </div>
         )}
+        {"List" in submission.submissionData.submission && (
+          <ul className="list-disc list-inside border-2 border-[#9173FF]/20 p-3 rounded-xl w-full mb-4 bg-[#9173FF]/20 text-white space-y-1">
+            {submission.submissionData.submission.List.items.map((item: string, idx: number) => (
+              <li key={idx} className="break-words whitespace-pre-wrap">
+                {item}
+              </li>
+            ))}
+          </ul>
+        )}
+        
         {submissionState === "Rejected" &&
           submission.submissionData.rejection_reason[0] &&
           submission.submissionData.rejection_reason[0].trim().length > 0 && (
diff --git a/src/atlas_frontend/src/components/Task/tasks/GenericTask.tsx b/src/atlas_frontend/src/components/Task/tasks/GenericTask.tsx
index b150eda..d8c6077 100644
--- a/src/atlas_frontend/src/components/Task/tasks/GenericTask.tsx
+++ b/src/atlas_frontend/src/components/Task/tasks/GenericTask.tsx
@@ -1,11 +1,11 @@
-import React from "react";
+import React, { useMemo } from "react";
 import { useState } from "react";
 import type {
   _SERVICE,
   TaskType,
 } from "../../../../../declarations/atlas_space/atlas_space.did";
 import Button from "../../Shared/Button";
-import { useForm, type SubmitHandler } from "react-hook-form";
+import { useFieldArray, useForm, type SubmitHandler } from "react-hook-form";
 import { yupResolver } from "@hookform/resolvers/yup";
 import * as yup from "yup";
 import {
@@ -32,21 +32,13 @@ interface GenericTaskProps {
   disabled?: boolean;
 }
 
-interface GenericTaskFormInput {
+interface TextFormData {
   taskSubmission: string;
 }
 
-const maxDescriptionLength = 500;
-
-const schema = yup.object({
-  taskSubmission: yup
-    .string()
-    .max(maxDescriptionLength)
-    .trim()
-    .min(2)
-    .required()
-    .label("Task submission"),
-});
+interface ListFormData {
+  items: { value: string }[];
+}
 
 const GenericTask = ({
   genericTask,
@@ -58,22 +50,49 @@ const GenericTask = ({
   disabled = false,
 }: GenericTaskProps) => {
   const dispatch = useDispatch();
-  const { user } = useAuth();
+  const { user, connect } = useAuth();
   const [openSubmission, setSubmission] = useState(false);
-  const { register, handleSubmit} = useForm({
-    resolver: yupResolver(schema),
+  const authAtlasSpace = useAuthAtlasSpaceActor(spacePrincipal);
+  const answerFormatKey = "TitleAndDescription" in genericTask.task_content
+    ? (Object.keys(genericTask.task_content.TitleAndDescription.answer_format)[0] as
+        | "Small"
+        | "Paragraph"
+        | "Long"
+        | "List")
+    : null;
+
+  const maxTextLength = useMemo(() => {
+    switch (answerFormatKey) {
+      case "Small":
+        return 254;
+      case "Paragraph":
+        return 600;
+      case "Long":
+        return 2500;
+      default:
+        return 254;
+    }
+  }, [answerFormatKey]);
+
+  const textSchema = yup.object({
+    taskSubmission: yup
+      .string()
+      .trim()
+      .min(2)
+      .max(maxTextLength)
+      .required("Field is required"),
+  });
+
+  const textForm = useForm<TextFormData>({
+    resolver: yupResolver(textSchema),
     defaultValues: {
-      taskSubmission: "",
+      taskSubmission: ""
     },
   });
-  const { connect } = useAuth();
-  const authAtlasSpace = useAuthAtlasSpaceActor(spacePrincipal);
 
-  const handleSubmitResponse: SubmitHandler<GenericTaskFormInput> = async ({
-    taskSubmission,
-  }) => {
+  const onSubmitText: SubmitHandler<TextFormData> = async ({ taskSubmission }) => {
     if (!authAtlasSpace || !unAuthAtlasSpace) return;
-    
+
     await runWithLoading(async () => {
       const call = submitSubtaskSubmission({
         authAtlasSpace,
@@ -88,7 +107,61 @@ const GenericTask = ({
       });
 
       setSubmission(false);
-      getSpaceTasks({
+      await getSpaceTasks({
+        spaceId: spacePrincipal.toString(),
+        unAuthAtlasSpace,
+        dispatch,
+      });
+    }, dispatch, () => setSubmission(false));
+  };
+
+  const listSchema = yup.object({
+  items: yup
+    .array()
+    .of(
+      yup.object({
+        value: yup
+          .string()
+          .trim()
+          .max(254, "Item too long")
+          .required("Item cannot be empty"),
+      })
+    )
+    .max(25, "Max 25 items allowed")
+    .required(),
+});
+
+const listForm = useForm<ListFormData>({
+  resolver: yupResolver(listSchema),
+  defaultValues: {
+    items: [{ value: "" }]
+  },
+});
+
+  const { fields, append, remove } = useFieldArray({
+    control: listForm.control,
+    name: "items",
+  });
+
+  const onSubmitList = async () => {
+    if (!authAtlasSpace || !unAuthAtlasSpace) return;
+
+    const items = listForm.getValues().items.map(item => item.value.trim());
+    await runWithLoading(async () => {
+      const call = submitSubtaskSubmission({
+        authAtlasSpace,
+        taskId: BigInt(taskId),
+        subtaskId: BigInt(subtaskId),
+        submission: { List: { items } },
+      });
+      await toast.promise(call, {
+        loading: "Submitting list...",
+        success: "Submitted response.",
+        error: getErrorWithInfoToast("Failed to submit response."),
+      });
+
+      setSubmission(false);
+      await getSpaceTasks({
         spaceId: spacePrincipal.toString(),
         unAuthAtlasSpace,
         dispatch,
@@ -112,10 +185,8 @@ const GenericTask = ({
   );
 
   const rawState = Object.keys(submissionData?.state || {})[0] ?? null;
-
   const validStates = ["Rejected", "WaitingForReview", "Accepted"] as const;
   type SubmissionState = typeof validStates[number];
-
   const submissionState = validStates.includes(rawState as SubmissionState)
     ? (rawState as SubmissionState)
     : null;
@@ -161,19 +232,54 @@ const GenericTask = ({
           )}
 
         {canSubmit && openSubmission && !disabled && (
-          <form onSubmit={handleSubmit(handleSubmitResponse)}>
-            <div>
-              <p className="text-xs md:text-base text-white font-semibold mb-1">Submit response:</p>
-              <textarea
-                {...register("taskSubmission")}
-                className="border-2 border-[#9173FF]/20 p-2 h-32 md:h-20 md:p-4 rounded-xl w-full mb-2 bg-[#9173FF]/20 text-white"
-              ></textarea>
-            </div>
-            <div className="flex justify-end">
-              <Button className="text-[14px] px-2 py-1 rounded-xl">Submit</Button>
-            </div>
-          </form>
-        )}
+          <>
+            {answerFormatKey !== "List" ? (
+              <form onSubmit={textForm.handleSubmit(onSubmitText)}>
+                <textarea
+                  {...textForm.register("taskSubmission")}
+                  maxLength={maxTextLength}
+                  className="border-2 border-[#9173FF]/20 p-2 h-32 md:h-20 md:p-4 rounded-xl w-full mb-2 bg-[#9173FF]/20 text-white"
+                />
+                {textForm.formState.errors.taskSubmission && (
+                  <p className="text-red-400 text-sm">
+                    {textForm.formState.errors.taskSubmission.message}
+                  </p>
+                )}
+                <div className="flex justify-end">
+                  <Button className="text-[14px] px-2 py-1 rounded-xl">Submit</Button>
+                </div>
+              </form>
+            ) : (
+              <form onSubmit={listForm.handleSubmit(onSubmitList)}>
+                {fields.map((field, idx) => (
+                  <div key={field.id} className="flex gap-2 mb-2 items-center">
+                    <input
+                      {...listForm.register(`items.${idx}.value` as const)}
+                      maxLength={254}
+                      className="border-2 border-[#9173FF]/20 p-1 md:p-2 rounded-xl w-full bg-[#9173FF]/20 text-white placeholder-gray-300"
+                      defaultValue={field.value}
+                    />
+                    <button type="button" onClick={() => remove(idx)} className="text-red-500 text-xl px-2 py-1 rounded-lg">
+                      −
+                    </button>
+                  </div>
+                ))}
+                {
+                  <Button onClick={() => append({ value: "" })} className="md:px-2.5 md:py-1 px-2 py-0.5">
+                    + 
+                  </Button>
+                }
+                {listForm.formState.errors.items && (
+                  <p className="text-red-400 text-sm">{(listForm.formState.errors.items)?.message}</p>
+                )}
+                <div className="flex justify-end">
+                  <Button className="text-[14px] px-2 py-1 rounded-xl">Submit</Button>
+                </div>
+              </form>
+            )}
+          </>
+         )}
+         
         {canSubmit  && !openSubmission && !disabled && (
           <div className="flex py-2">
             <Button onClick={() => setSubmission(true)} className="text-[14px] px-2 py-1 rounded-xl">
diff --git a/src/atlas_frontend/src/modals/CreateNewTaskModal.tsx b/src/atlas_frontend/src/modals/CreateNewTaskModal.tsx
index f51f8d0..5a13aee 100644
--- a/src/atlas_frontend/src/modals/CreateNewTaskModal.tsx
+++ b/src/atlas_frontend/src/modals/CreateNewTaskModal.tsx
@@ -31,6 +31,15 @@ import {
 import { deserialize, type RootState } from "../store/store";
 import { getErrorWithInfoToast } from "../utils/errors";
 import { toLocalISOString } from "../utils/date";
+import type { AnswerFormat } from "../../../declarations/atlas_space/atlas_space.did";
+
+const getAnswerFormatKey = (format: AnswerFormat): string => Object.keys(format)[0];
+const answerFormatDescriptions: Record<string, string> = {
+  Small: "Up to 254 characters",
+  Paragraph: "Up to 600 characters",
+  Long: "Up to 2500 characters",
+  List: "Multiple items, each up to 254 characters",
+};
 
 type TaskType = "generic";
 const allowedTaskTypes = ["generic"] as const;
@@ -46,11 +55,22 @@ interface CreateNewTaskFormInput {
     title: string;
     description: string;
     allowresubmit: boolean;
+    answerFormat: keyof typeof answerFormatDescriptions;
   }[];
 }
+
 const maxSubtitleLength = 50;
 const maxTitleLength = 50;
 const maxDescriptionLength = 500;
+const answerFormats: AnswerFormat[] = [
+  { Small: null },
+  { Paragraph: null },
+  { Long: null },
+  { List: null },
+];
+const answerFormatKeys = Object.keys(answerFormatDescriptions) as Array<
+  keyof typeof answerFormatDescriptions
+>;
 
 const taskSchema = yup.object({
   taskType: yup.mixed<TaskType>().oneOf(allowedTaskTypes).required(),
@@ -68,6 +88,11 @@ const taskSchema = yup.object({
     .required()
     .label("Task description"),
   allowresubmit: yup.boolean().required(),
+  answerFormat: yup
+    .string()
+    .oneOf(answerFormatKeys as string[])
+    .required()
+    .label("Answer format"),
 });
 
 interface CreateNewTaskModalArgs {
@@ -150,6 +175,7 @@ const CreateNewTaskModal = ({ callback }: CreateNewTaskModalArgs) => {
           title: "",
           description: "",
           allowresubmit: false,
+          answerFormat: "Small",
         },
       ],
       startTime: toLocalISOString(renderedAt).slice(0, 16),
@@ -220,6 +246,21 @@ const CreateNewTaskModal = ({ callback }: CreateNewTaskModalArgs) => {
       return;
     }
 
+    const toAnswerFormat = (key: string): AnswerFormat => {
+      switch (key) {
+        case "Small":
+          return { Small: null };
+        case "Paragraph":
+          return { Paragraph: null };
+        case "Long":
+          return { Long: null };
+        case "List":
+          return { List: null };
+        default:
+          throw new Error(`Unknown AnswerFormat key: ${key}`);
+      }
+    };
+
     const taskContent = tasks
       ?.map((task) => {
         if (task.taskType === "generic") {
@@ -228,6 +269,7 @@ const CreateNewTaskModal = ({ callback }: CreateNewTaskModalArgs) => {
             title: task.title,
             description: task.description,
             allow_resubmit: task.allowresubmit,
+            answer_format: toAnswerFormat(task.answerFormat),
           };
         }
       })
@@ -306,6 +348,7 @@ const CreateNewTaskModal = ({ callback }: CreateNewTaskModalArgs) => {
                   title: "",
                   description: "",
                   allowresubmit: false,
+                  answerFormat: "Small", 
                 })
               }
               className="flex gap-2"
@@ -397,7 +440,22 @@ const CreateNewTaskModal = ({ callback }: CreateNewTaskModalArgs) => {
                     >
                       <option value="generic">Generic text task</option>
                     </select>
-
+                    <div className="mt-4">
+                      <label className="text-gray-600 font-semibold">Answer format:</label>
+                      <select
+                        {...register(`tasks.${index}.answerFormat`)}
+                        className="border-2 p-2 rounded-xl w-full mt-1"
+                      >
+                        {answerFormats.map((format) => {
+                          const key = getAnswerFormatKey(format);
+                          return (
+                            <option key={key} value={key}>
+                              {key} – {answerFormatDescriptions[key]}
+                            </option>
+                          );
+                        })}
+                      </select>
+                    </div>
                     {taskType === "generic" && (
                       <GenericTask
                         register={register}
@@ -414,6 +472,7 @@ const CreateNewTaskModal = ({ callback }: CreateNewTaskModalArgs) => {
                         {...register(`tasks.${index}.allowresubmit`)}
                         className="form-checkbox h-5 w-5 text-[#9173FF] rounded"
                       />
+
                       <label
                         htmlFor={`allowresubmit-${index}`}
                         className="text-gray-600 font-semibold"
diff --git a/src/atlas_space/atlas_space.did b/src/atlas_space/atlas_space.did
index 099110b..5a440bd 100644
--- a/src/atlas_space/atlas_space.did
+++ b/src/atlas_space/atlas_space.did
@@ -1,3 +1,4 @@
+type AnswerFormat = variant { Small; List; Long; Paragraph };
 type CkUsdcLedger = record { fee : opt nat; "principal" : principal };
 type CkUsdcLedger_1 = record { fee : opt nat; "principal" : principal };
 type ClosedTask = record {
@@ -103,7 +104,11 @@ type State = record {
   tasks_count : nat64;
   space_description : text;
 };
-type Submission = variant { Empty; Text : record { content : text } };
+type Submission = variant {
+  Empty;
+  List : record { items : vec text };
+  Text : record { content : text };
+};
 type SubmissionData = record {
   state : SubmissionState;
   rejection_reason : opt text;
@@ -123,6 +128,7 @@ type Task = record {
 };
 type TaskContent = variant {
   TitleAndDescription : record {
+    answer_format : AnswerFormat;
     task_description : text;
     task_title : text;
     allow_resubmit : bool;
diff --git a/src/atlas_space/src/migration.rs b/src/atlas_space/src/migration.rs
index ea8a83a..37d54b3 100644
--- a/src/atlas_space/src/migration.rs
+++ b/src/atlas_space/src/migration.rs
@@ -1 +1,284 @@
-pub async fn migrate() {}
+use crate::memory::{VMem, CLOSED_TASKS_MAP_MEMORY_ID, MEMORY_MANAGER, OPEN_TASKS_MAP_MEMORY_ID};
+use crate::tasks::{
+    closed_task::ClosedTask,
+    submission::{Submission, SubmissionData, SubmissionState},
+    task::Task,
+    task_types::{AnswerFormat, TaskContent, TaskId, TaskType, TimerKeyData},
+    token_reward::TokenReward,
+};
+use candid::{CandidType, Principal};
+use ic_stable_structures::{storable::Bound, StableBTreeMap, Storable};
+use minicbor::{Decode, Encode};
+use serde::Deserialize;
+use std::{borrow::Cow, cell::RefCell, collections::BTreeMap};
+
+#[derive(Eq, PartialEq, Debug, Decode, Encode, Clone, CandidType, Deserialize)]
+pub enum OldSubmission {
+    #[n(0)]
+    Text {
+        #[n(0)]
+        content: String,
+    },
+    #[n(1)]
+    Empty,
+}
+
+#[derive(Eq, PartialEq, Debug, Decode, Encode, Clone, CandidType, Deserialize)]
+pub enum OldTaskContent {
+    #[n(0)]
+    TitleAndDescription {
+        #[n(0)]
+        task_title: String,
+        #[n(1)]
+        task_description: String,
+        #[n(2)]
+        allow_resubmit: bool,
+    },
+}
+
+#[derive(Eq, PartialEq, Debug, Decode, Encode, Clone, CandidType)]
+pub struct OldSubmissionData {
+    #[n(0)]
+    pub(crate) submission: OldSubmission,
+
+    #[n(1)]
+    pub(crate) state: SubmissionState,
+
+    #[n(2)]
+    pub(crate) rejection_reason: Option<String>,
+}
+
+#[derive(Eq, PartialEq, Debug, Decode, Encode, Clone, CandidType)]
+pub enum OldTaskType {
+    #[n(0)]
+    GenericTask {
+        #[n(0)]
+        task_content: OldTaskContent,
+        #[cbor(n(1), with = "shared::cbor::principal::b_tree_map")]
+        submission: BTreeMap<Principal, OldSubmissionData>,
+    },
+}
+
+#[derive(Eq, PartialEq, Debug, Decode, Encode, Clone, CandidType)]
+pub struct OldTask {
+    #[cbor(n(0), with = "shared::cbor::principal")]
+    pub(crate) creator: Principal,
+    #[n(1)]
+    pub(crate) token_reward: TokenReward,
+    #[n(2)]
+    pub(crate) tasks: Vec<OldTaskType>,
+    #[n(3)]
+    pub(crate) number_of_uses: u64,
+    #[n(4)]
+    pub(crate) task_title: String,
+    #[cbor(n(5), with = "shared::cbor::principal::vec")]
+    pub(crate) rewarded: Vec<Principal>,
+    #[n(6)]
+    pub(crate) start_time: u64,
+    #[n(7)]
+    pub(crate) end_time: u64,
+    #[n(8)]
+    pub(crate) timer_id: Option<TimerKeyData>,
+}
+
+impl Storable for OldTask {
+    fn to_bytes(&self) -> Cow<[u8]> {
+        let mut buf = vec![];
+        minicbor::encode(self, &mut buf).expect("OldTask encoding should always succeed");
+        Cow::Owned(buf)
+    }
+
+    fn from_bytes(bytes: Cow<[u8]>) -> Self {
+        minicbor::decode(bytes.as_ref()).unwrap_or_else(|e| {
+            panic!("failed to decode OldTask bytes {}: {e}", hex::encode(bytes))
+        })
+    }
+
+    const BOUND: Bound = Bound::Unbounded;
+}
+
+#[derive(Eq, PartialEq, Debug, Decode, Encode, Clone)]
+pub struct OldClosedTask {
+    #[cbor(n(0), with = "shared::cbor::principal")]
+    pub(crate) creator: Principal,
+    #[n(1)]
+    pub(crate) token_reward: crate::tasks::token_reward::TokenReward,
+    #[n(2)]
+    pub(crate) tasks: Vec<OldTaskType>,
+    #[n(3)]
+    pub(crate) number_of_uses: u64,
+    #[n(4)]
+    pub(crate) task_title: String,
+    #[cbor(n(5), with = "shared::cbor::principal::vec")]
+    pub(crate) rewarded: Vec<Principal>,
+    #[n(6)]
+    pub(crate) start_time: u64,
+    #[n(7)]
+    pub(crate) end_time: u64,
+    #[n(8)]
+    pub(crate) refunded: bool,
+}
+
+impl Storable for OldClosedTask {
+    fn to_bytes(&self) -> Cow<[u8]> {
+        let mut buf = vec![];
+        minicbor::encode(self, &mut buf).expect("OldClosedTask encoding failed");
+        Cow::Owned(buf)
+    }
+
+    fn from_bytes(bytes: Cow<[u8]>) -> Self {
+        minicbor::decode(bytes.as_ref()).unwrap_or_else(|e| {
+            panic!(
+                "Failed to decode OldClosedTask bytes {}: {e}",
+                hex::encode(bytes)
+            )
+        })
+    }
+
+    const BOUND: Bound = Bound::Unbounded;
+}
+
+impl From<OldSubmission> for Submission {
+    fn from(old: OldSubmission) -> Self {
+        match old {
+            OldSubmission::Text { content } => Submission::Text { content },
+            OldSubmission::Empty => Submission::Empty,
+        }
+    }
+}
+
+impl From<OldTaskContent> for TaskContent {
+    fn from(old: OldTaskContent) -> Self {
+        match old {
+            OldTaskContent::TitleAndDescription {
+                task_title,
+                task_description,
+                allow_resubmit,
+            } => TaskContent::TitleAndDescription {
+                task_title,
+                task_description,
+                allow_resubmit,
+                answer_format: AnswerFormat::Paragraph,
+            },
+        }
+    }
+}
+
+impl From<OldSubmissionData> for SubmissionData {
+    fn from(old: OldSubmissionData) -> Self {
+        SubmissionData {
+            submission: old.submission.into(),
+            state: old.state,
+            rejection_reason: old.rejection_reason,
+        }
+    }
+}
+
+impl From<OldTaskType> for TaskType {
+    fn from(old: OldTaskType) -> Self {
+        match old {
+            OldTaskType::GenericTask {
+                task_content,
+                submission,
+            } => TaskType::GenericTask {
+                task_content: task_content.into(),
+                submission: submission
+                    .into_iter()
+                    .map(|(principal, old_data)| (principal, old_data.into()))
+                    .collect(),
+            },
+        }
+    }
+}
+
+impl From<OldTask> for Task {
+    fn from(old: OldTask) -> Self {
+        Task {
+            creator: old.creator,
+            token_reward: old.token_reward,
+            tasks: old.tasks.into_iter().map(Into::into).collect(),
+            number_of_uses: old.number_of_uses,
+            task_title: old.task_title,
+            rewarded: old.rewarded,
+            start_time: old.start_time,
+            end_time: old.end_time,
+            timer_id: old.timer_id,
+        }
+    }
+}
+
+impl From<OldClosedTask> for ClosedTask {
+    fn from(old: OldClosedTask) -> Self {
+        ClosedTask {
+            creator: old.creator,
+            token_reward: old.token_reward,
+            tasks: old.tasks.into_iter().map(Into::into).collect(),
+            number_of_uses: old.number_of_uses,
+            task_title: old.task_title,
+            rewarded: old.rewarded,
+            start_time: old.start_time,
+            end_time: old.end_time,
+            refunded: old.refunded,
+        }
+    }
+}
+
+thread_local! {
+    static OLD_OPEN_TASKS: RefCell<StableBTreeMap<TaskId, OldTask, VMem>> = RefCell::new(
+        StableBTreeMap::init(MEMORY_MANAGER.with(|m| m.borrow().get(OPEN_TASKS_MAP_MEMORY_ID)))
+    );
+
+    static OLD_CLOSED_TASKS: RefCell<StableBTreeMap<TaskId, OldClosedTask, VMem>> = RefCell::new(
+        StableBTreeMap::init(MEMORY_MANAGER.with(|m| m.borrow().get(CLOSED_TASKS_MAP_MEMORY_ID)))
+    );
+}
+
+pub async fn migrate() {
+    // OpenTasks
+    let old_open: BTreeMap<TaskId, OldTask> =
+        OLD_OPEN_TASKS.with_borrow(|map| map.iter().collect());
+
+    let new_open: BTreeMap<TaskId, Task> = old_open
+        .into_iter()
+        .map(|(id, old)| (id, old.into()))
+        .collect();
+
+    OLD_OPEN_TASKS.with_borrow_mut(|map| {
+        *map =
+            StableBTreeMap::new(MEMORY_MANAGER.with(|m| m.borrow().get(OPEN_TASKS_MAP_MEMORY_ID)))
+    });
+
+    let mut new_open_map = StableBTreeMap::<TaskId, Task, VMem>::new(
+        MEMORY_MANAGER.with(|m| m.borrow().get(OPEN_TASKS_MAP_MEMORY_ID)),
+    );
+
+    for (id, task) in new_open {
+        new_open_map.insert(id, task);
+    }
+
+    let _ = new_open_map.len();
+
+    // ClosedTasks
+    let old_closed: BTreeMap<TaskId, OldClosedTask> =
+        OLD_CLOSED_TASKS.with_borrow(|map| map.iter().collect());
+
+    let new_closed: BTreeMap<TaskId, ClosedTask> = old_closed
+        .into_iter()
+        .map(|(id, old)| (id, old.into()))
+        .collect();
+
+    OLD_CLOSED_TASKS.with_borrow_mut(|map| {
+        *map =
+            StableBTreeMap::new(MEMORY_MANAGER.with(|m| m.borrow().get(CLOSED_TASKS_MAP_MEMORY_ID)))
+    });
+
+    let mut new_closed_map = StableBTreeMap::<TaskId, ClosedTask, VMem>::new(
+        MEMORY_MANAGER.with(|m| m.borrow().get(CLOSED_TASKS_MAP_MEMORY_ID)),
+    );
+
+    for (id, task) in new_closed {
+        new_closed_map.insert(id, task);
+    }
+
+    let _ = new_closed_map.len();
+}
diff --git a/src/atlas_space/src/tasks/submission.rs b/src/atlas_space/src/tasks/submission.rs
index 768180a..9a1a67b 100644
--- a/src/atlas_space/src/tasks/submission.rs
+++ b/src/atlas_space/src/tasks/submission.rs
@@ -24,12 +24,11 @@ pub enum Submission {
     },
     #[n(1)]
     Empty,
-}
-
-impl Submission {
-    pub fn is_text(&self) -> bool {
-        matches!(self, Submission::Text { .. })
-    }
+    #[n(2)]
+    List {
+        #[n(0)]
+        items: Vec<String>,
+    },
 }
 
 #[derive(Eq, PartialEq, Debug, Decode, Encode, Clone, CandidType)]
diff --git a/src/atlas_space/src/tasks/task_types.rs b/src/atlas_space/src/tasks/task_types.rs
index 2f78762..2c3518a 100644
--- a/src/atlas_space/src/tasks/task_types.rs
+++ b/src/atlas_space/src/tasks/task_types.rs
@@ -30,6 +30,18 @@ impl TryFrom<TimerKeyData> for TimerId {
     }
 }
 
+#[derive(Eq, PartialEq, Debug, Decode, Encode, Clone, CandidType, Deserialize)]
+pub enum AnswerFormat {
+    #[n(0)]
+    Small, // 254 chars
+    #[n(1)]
+    Paragraph, // 600 chars
+    #[n(2)]
+    Long, // 2500 chars
+    #[n(3)]
+    List, // Vec<String>, each max 254 chars
+}
+
 #[derive(Eq, PartialEq, Debug, Decode, Encode, Clone, CandidType, Deserialize)]
 pub enum TaskContent {
     #[n(0)]
@@ -40,6 +52,8 @@ pub enum TaskContent {
         task_description: String,
         #[n(2)]
         allow_resubmit: bool,
+        #[n(3)]
+        answer_format: AnswerFormat,
     },
 }
 
@@ -50,6 +64,7 @@ impl TaskContent {
                 task_title,
                 task_description,
                 allow_resubmit: _,
+                answer_format: _,
             } => {
                 if task_title.trim().len() > 50 {
                     return Err(Error::InvalidTaskContent(
@@ -80,11 +95,13 @@ impl From<&TaskContent> for TaskType {
                 task_title,
                 task_description,
                 allow_resubmit,
+                answer_format,
             } => Self::GenericTask {
                 task_content: TaskContent::TitleAndDescription {
                     task_title: task_title.clone(),
                     task_description: task_description.clone(),
                     allow_resubmit: *allow_resubmit,
+                    answer_format: answer_format.clone(),
                 },
                 submission: Default::default(),
             },
@@ -108,7 +125,7 @@ impl TaskType {
         let allow_resubmit = self.get_allow_resubmit();
         match self {
             TaskType::GenericTask {
-                task_content: _,
+                task_content,
                 submission: submissions_map,
             } => {
                 if let Some(existing_submission) = submissions_map.get(&user) {
@@ -120,8 +137,71 @@ impl TaskType {
                         return Err(Error::UserAlreadySubmitted);
                     }
                 }
-                if !submission.is_text() {
-                    return Err(Error::IncorrectSubmission("Text".to_string()));
+                match (task_content, &submission) {
+                    (
+                        TaskContent::TitleAndDescription { answer_format, .. },
+                        Submission::Text { content },
+                    ) => {
+                        let len = content.trim().len();
+                        match answer_format {
+                            AnswerFormat::Small if len > 254 => {
+                                return Err(Error::IncorrectSubmission(
+                                    "Answer too long (max 254 chars)".into(),
+                                ))
+                            }
+                            AnswerFormat::Paragraph if len > 600 => {
+                                return Err(Error::IncorrectSubmission(
+                                    "Answer too long (max 600 chars)".into(),
+                                ))
+                            }
+                            AnswerFormat::Long if len > 2500 => {
+                                return Err(Error::IncorrectSubmission(
+                                    "Answer too long (max 2500 chars)".into(),
+                                ))
+                            }
+                            AnswerFormat::List => {
+                                return Err(Error::IncorrectSubmission(
+                                    "Expected list submission".into(),
+                                ))
+                            }
+                            _ => {}
+                        }
+                    }
+                    (
+                        TaskContent::TitleAndDescription { answer_format, .. },
+                        Submission::List { items },
+                    ) => {
+                        if *answer_format != AnswerFormat::List {
+                            return Err(Error::IncorrectSubmission(
+                                "Expected text submission".into(),
+                            ));
+                        }
+                        if items.is_empty() {
+                            return Err(Error::IncorrectSubmission("List cannot be empty".into()));
+                        }
+                        if items.len() > 25 {
+                            return Err(Error::IncorrectSubmission(
+                                "List too long (max 25 items)".into(),
+                            ));
+                        }
+                        for item in items {
+                            if item.trim().is_empty() {
+                                return Err(Error::IncorrectSubmission(
+                                    "List item cannot be empty".into(),
+                                ));
+                            }
+                            if item.len() > 254 {
+                                return Err(Error::IncorrectSubmission(
+                                    "List item too long (max 254 chars)".into(),
+                                ));
+                            }
+                        }
+                    }
+                    _ => {
+                        return Err(Error::IncorrectSubmission(
+                            "Unsupported submission type".into(),
+                        ))
+                    }
                 }
                 submissions_map.insert(
                     user,
diff --git a/src/declarations/atlas_space/atlas_space.did b/src/declarations/atlas_space/atlas_space.did
index 099110b..5a440bd 100644
--- a/src/declarations/atlas_space/atlas_space.did
+++ b/src/declarations/atlas_space/atlas_space.did
@@ -1,3 +1,4 @@
+type AnswerFormat = variant { Small; List; Long; Paragraph };
 type CkUsdcLedger = record { fee : opt nat; "principal" : principal };
 type CkUsdcLedger_1 = record { fee : opt nat; "principal" : principal };
 type ClosedTask = record {
@@ -103,7 +104,11 @@ type State = record {
   tasks_count : nat64;
   space_description : text;
 };
-type Submission = variant { Empty; Text : record { content : text } };
+type Submission = variant {
+  Empty;
+  List : record { items : vec text };
+  Text : record { content : text };
+};
 type SubmissionData = record {
   state : SubmissionState;
   rejection_reason : opt text;
@@ -123,6 +128,7 @@ type Task = record {
 };
 type TaskContent = variant {
   TitleAndDescription : record {
+    answer_format : AnswerFormat;
     task_description : text;
     task_title : text;
     allow_resubmit : bool;
diff --git a/src/declarations/atlas_space/atlas_space.did.d.ts b/src/declarations/atlas_space/atlas_space.did.d.ts
index 280a4b1..60bab99 100644
--- a/src/declarations/atlas_space/atlas_space.did.d.ts
+++ b/src/declarations/atlas_space/atlas_space.did.d.ts
@@ -2,6 +2,10 @@ import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
 import type { IDL } from '@dfinity/candid';
 
+export type AnswerFormat = { 'Small' : null } |
+  { 'List' : null } |
+  { 'Long' : null } |
+  { 'Paragraph' : null };
 export interface CkUsdcLedger { 'fee' : [] | [bigint], 'principal' : Principal }
 export interface CkUsdcLedger_1 {
   'fee' : [] | [bigint],
@@ -112,6 +116,7 @@ export interface State {
   'space_description' : string,
 }
 export type Submission = { 'Empty' : null } |
+  { 'List' : { 'items' : Array<string> } } |
   { 'Text' : { 'content' : string } };
 export interface SubmissionData {
   'state' : SubmissionState,
@@ -134,6 +139,7 @@ export interface Task {
 }
 export type TaskContent = {
     'TitleAndDescription' : {
+      'answer_format' : AnswerFormat,
       'task_description' : string,
       'task_title' : string,
       'allow_resubmit' : boolean,
diff --git a/src/declarations/atlas_space/atlas_space.did.js b/src/declarations/atlas_space/atlas_space.did.js
index 6df5283..dbeef3a 100644
--- a/src/declarations/atlas_space/atlas_space.did.js
+++ b/src/declarations/atlas_space/atlas_space.did.js
@@ -58,8 +58,15 @@ export const idlFactory = ({ IDL }) => {
   const TokenReward = IDL.Variant({
     'CkUsdc' : IDL.Record({ 'amount' : IDL.Nat }),
   });
+  const AnswerFormat = IDL.Variant({
+    'Small' : IDL.Null,
+    'List' : IDL.Null,
+    'Long' : IDL.Null,
+    'Paragraph' : IDL.Null,
+  });
   const TaskContent = IDL.Variant({
     'TitleAndDescription' : IDL.Record({
+      'answer_format' : AnswerFormat,
       'task_description' : IDL.Text,
       'task_title' : IDL.Text,
       'allow_resubmit' : IDL.Bool,
@@ -89,6 +96,7 @@ export const idlFactory = ({ IDL }) => {
   });
   const Submission = IDL.Variant({
     'Empty' : IDL.Null,
+    'List' : IDL.Record({ 'items' : IDL.Vec(IDL.Text) }),
     'Text' : IDL.Record({ 'content' : IDL.Text }),
   });
   const SubmissionData = IDL.Record({