Get started

How to migrate to Libertadia

To reduce friction when migrating from Custom GPTs to Libertadia, the main obstacle is not technical but a matter of mental model. Users tend to think of a "GPT" as a monolithic container (a long prompt with a few uploaded PDFs and feedback until it produces usable answers). In Libertadia, the architecture is modular and decoupled (agents, models, brains, functions and workflows). This shift in paradigm is essential to understand the power of Libertadia and its exponential improvement over a model like that of, for example, OpenAI or Perplexity, which automates its development, takes control away from the user by making them comfortable and keeps them from gaining autonomy.

#The change of mindset – From a monolithic GPT to a modular environment

• Goal: Defuse the initial frustration of "copy-pasting my GPT doesn't work the same" and teach how to use Free chat with context as a starting point.
• Friction it addresses: The user expects Libertadia to work exactly like ChatGPT and doesn't understand why their old prompt doesn't perform the same without structuring the environment.
• Content outline:
  1. The "all-in-one GPT" myth: Explain why traditional Custom GPTs break down when complex instructions, messy files and unrelated tasks are mixed.
  2. Free chat is not an empty chat: How to make the most of the base chat by injecting dynamic context (files, one-off instructions and models suited to the task).
  3. The golden rule: When you simply need a well-directed conversation with context and when it's worth creating a dedicated agent.
  4. Practical step: A quick 3-step exercise to get immediate results in Free chat without configuring anything complex.

Why copy-pasting your old Custom GPT into a new platform usually gives poor results (and how to fix it)

When we decide to move to a more advanced AI work environment like Libertadia, the first temptation is usually to replicate exactly what we already had: take the block of text from a Custom GPT, paste it into a configuration field and wait for the magic to happen.

The result is usually disappointing: generic answers, lost nuance, or functions that don't respond as before.

The problem is not the power of the model, but the mental model. To get the most out of Libertadia, the first step is not learning to configure complex systems, but unlearning the logic of the "all-in-one GPT".

1. The monolithic Custom GPT trap

On traditional platforms, a Custom GPT is usually a "black box" mixing three things that should be kept apart:

1. The role and tone (how it should speak).
2. The static knowledge (three or four PDFs uploaded in bulk).
3. The operational tasks (ten different instructions waiting to run at once).

This monolithic architecture creates a perception of control where there is none, risks in the medium term, and requires constant supervision with a tendency towards alienation:

• Context saturation: If you ask the same assistant to draft a contract, summarise a report and analyse data, the model splits its attention and output quality drops.
• Lack of control: You can't change the reasoning engine according to the complexity of the task without altering the whole structure.
• A limited, passive user role: You only get to train the skill and can't control each factor separately, creating a dependency on the external company's orchestrators and skills. This erodes professional competence in the medium term.

In Libertadia the architecture is decoupled: models, agents, structured knowledge (Brains) and flows (Workflows) are independent pieces that you combine as needed.

That's why the professional will start by defining:

1. The role and tone (how it should speak).
2. The static knowledge (building knowledge bases in brains).
3. The operational tasks (the agent's specific functions, supported by skills and specialisations).

This modular architecture gives very high control over the kind of answers the agent will give, reduces the risk of alienation and is more robust in the medium and long term:

• Less exposed to context drift: When you activate a function, its fixed instructions guide every answer, so the conversation strays less from its goal.
• Maximum control: Although it initially means a steeper learning curve than general chats, the user can adjust key elements to fine-tune and improve the quality and stability of the answers.
• A proactive, free user role: Once the professional has design skills, they can fluently and quickly build automations for increasingly complex sub-processes. This brings greater autonomy and lets them focus on creativity, judgement and decision-making.

2. Free chat vs an AI Agent's Function

The key to migrating previous work from other platforms to a multimodal stack like Libertadia is understanding what Free chat is (consultative and reactive) and what an AI Agent's function is (executive and proactive).

Free chat is consultative and reactive. It responds to my direct requests and needs me to guide and supervise it through the process. My prompt is crucial every time I write it, and the accumulated context will cause the answers to drift, with a tendency towards alienation and possible AI paranoia. That's why, given the same request, the model with accumulated context may vary its answers a lot. It needs close supervision, although it manages to give the user a sense of stability and deep knowledge, which is an illusion, since the models' internal memory is limited.

Its main strength is giving me a fast, high-quality baseline answer to new challenges, designs and proposals. It brings a lot of breadth of knowledge and, combined with human judgement, boosts the creative process and the search for information and design. It corrects, translates, proposes and produces with high efficiency, depending on the user and their prompts.

Its main risk is precisely the excess of breadth and accumulated context, which makes it harder to stabilise the answer and build autonomy. High risk of AI paranoia due to model saturation and prioritising pleasing the user.

An AI Agent's Function is mainly executive. It triggers previously designed protocols connected to specific knowledge bases (brains) or utilities (integrations). Since every possible nuance of its response protocol has been designed in advance, it doesn't need me to guide it through the process, although I can still supervise everything. My prompt in the function matters less, because the function's instructions guide every answer, minimising the tendency towards alienation and possible AI paranoia. As a result, the answers are more stable and aligned with the function's goal. It gives the professional the ability to delegate daily sub-tasks to specific functions and, in turn, to automations. It needs occasional maintenance supervision and an investment of work in its development. [Blog link on this].

Its main strength is giving me a stable, high-quality answer for repetitive and constant challenges. It greatly limits creative action and narrows the knowledge base. It gives a lot of control over the kind of answers, letting the professional trust their quality, even offering its use to other users and keeping the response style solid for longer.

Its main risk is that it doesn't evolve with new knowledge as much as Free chat, it is less creative and, for generating value propositions and supporting new ventures, it is more limited than Free chat with context. It requires design development and calibration work.

3. Free chat is not a blank slate

Before rushing into creating agents, you should master the most flexible and underrated tool on the platform: Free chat with context.

Many users make the mistake of thinking that to do something professional they must create an agent. That's not always the case. Libertadia's Free chat is not a simple search engine; it's an execution canvas where you can:

• Choose the right model for the task: Assign a deep-reasoning model for critical analysis or a faster one for writing and summarising.
• Inject dynamic context in real time: Load specific documents only when the task requires it. If you don't want the assistant to carry over context from other conversations, turn off Memory (in a company workspace, the company's instructions always stay active).
• Iterate without rigidity: Try instructions, adjust approaches and check whether a process really needs automating or is better solved in a direct interaction.

4. Decision matrix: Chat with context or your own Agent?

Before creating an agent, ask yourself these questions:

5. Practical exercise: The "C-R-O" protocol in Free chat

To see the difference without configuring any agent, open a conversation in Free chat and apply this structure in a single message:

[CONTEXT]
I'm evaluating the attached service proposal for a client in the [Sector] sector.
I'm attaching the document with the details of the offer.

[ROLE]
Act as a critical operations consultant. Don't try to validate my ideas;
identify operational risks, ambiguities in the scope and hidden costs.

[OBJECTIVE AND FORMAT]
Deliver a structured analysis in:
1. Blind spots in the scope (maximum 3).
2. Main financial or operational risk.
3. Three key questions I should ask the supplier before signing.

Result: You'll get a usable answer without having spent a single minute configuring an agent. You've controlled the context, the role and the format at the exact moment. If it's a one-off task, this is the right approach; but if it's a recurring function you perform often, it would NOT be the right format, since it may show too much variability and a higher risk of AI paranoia.

#Catalog agents vs. your own assistant – When to delegate and when to build

• Goal: Show the value of Libertadia's preconfigured agents and understand the concept of a purpose-built agent.
• Friction it addresses: Wanting to build everything from scratch before understanding which standards and functions the platform already covers.
• Content outline:
  1. What a catalog agent is: Ready-to-use specialists (read-only), designed with optimised instructions and already-tested capabilities.
  2. The difference between talking and executing: How a catalog agent solves specific tasks thanks to the combination of model + fine-tuned instructions.
  3. Quick audit: Before migrating or creating an agent, check whether the catalog already has one that covers 80% of the use case.
  4. Practical step: A real use case comparing how a problem is solved in a generic chat vs. delegating it to a catalog agent.

One of the most common mistakes when migrating to Libertadia is "builder fever": the belief that to work professionally you have to create your own agent with thousands of functions for every need from minute one.

Many users spend hours writing instructions for tasks such as financial analysis, persuasive writing, code auditing or technical summaries, without realising that the Libertadios catalog already has agents designed, tested and calibrated for those purposes.

The real value in a modular environment is not in building more, but in knowing which piece to activate at each moment.

1. What a catalog agent really is

Libertadios are Libertadia's catalog agents: preconfigured specialists with different functions. Company workspaces also have Company agents, published by your admins. They are not just "public prompts", but optimised configurations that combine three key variables:

1. Hardened system instructions: Designed to minimise hallucinations, hold the role under pressure and enforce consistent output structures.
2. Optimal model selection: Each catalog agent has as its default the model that best suits its task (speed vs. deep reasoning ability vs. extended context).
3. Proven capabilities: Ready to be used directly through conversation, with no prior technical calibration needed from the user.

2. Anatomy of the decision: Catalog or your own Agent (Agents & skills)?

To avoid creating unnecessary systems, use this decision rule:

Does the task require private internal data, a unique institutional tone or proprietary business rules?

├── NO  ──▶ Use a CATALOG AGENT (immediate time savings).
└── YES ──▶ Build in AGENTS & SKILLS (full customisation).

When to rely on the catalog:

• Industry-standard tasks: Copy editing, SWOT analysis, boilerplate code generation, standard contract review, technical translation, decision-making frameworks, specific photography functions.
• Critical second opinions: Use an analytical catalog agent to audit a document or business plan from a neutral perspective.
• Rapid prototyping: Test how a specialised agent approaches a problem before deciding whether it's worth creating a custom version for your company.

When to build your own agent:

• Specific brand identity and tone: The assistant must speak in your organisation's exact corporate voice.
• Repetitive proprietary processes: Internal work methodologies, your own clinical/educational evaluation guidelines, exclusive delivery templates.
• Connection to private ecosystems: When you need the agent to work with structured knowledge bases (Brains), with your apps (Integrations) or with models configured to your needs.

3. Practical comparison: The same problem, two approaches

Imagine you need to audit the reply to a complaint filed against a supplier.

Option A: Trying to solve it in a generic, unstructured chat

• You open the chat, paste the text and ask: "Check whether this is OK".
• Result: The model gives a compliant summary, tells you the reply is solid and points out a couple of obvious things. You waste time re-asking it to be critical.

Option B: Delegating to a catalog specialist agent

• You select a catalog agent focused on auditing and critical analysis: Lucía Abogada.
• You choose a function from the lightning menu on the agent bar: Responder a una reclamación (reply to a complaint).
• You attach the reply with a direct instruction: "Identify operational ambiguities and asymmetric penalties".
• Result: The agent, configured with strict evaluation guidelines, delivers a systematic breakdown by risk level, identifying ambiguous clauses and recommending exact proposals.

Time spent: 1 minute. Hours of configuration needed: zero.

4. Practical exercise: The 80/20 audit

Before you sit down to write your next agent, do this 3-step exercise:

1. List your 5 most repetitive tasks of the week. (E.g.: writing meeting minutes, structuring content outlines, auditing budgets, summarising scientific articles).
2. Explore the Libertadios (and, in a company, the Company agents). Identify whether there are agents whose role covers 80% of the result you need.
3. Test one of them on a real task. Measure the time and the quality of the answer against what you used to get from your traditional Custom GPT.

Conclusion and next step

• Use the work already done: The catalog is not a limitation; it's a library of productivity accelerators.
• Strategic focus: Spend your time building only the agents that represent a competitive advantage or a proprietary process for your business.
• Modularity: A mature workflow combines catalog agents for standard tasks and your own agents for the core of your activity.

👉 In the next post: Build your own Agent in Libertadia. We'll see how to structure clean instructions, choose the right model and demystify the use of complex functions to overcome the limitations of your old Custom GPT.

#Build your own Agent – Overcoming the limitations of your old Custom GPT

• Goal: Guide the creation of your own agents, demystifying the need to configure complex functions from day one.
• Friction it addresses: The belief that an agent without skills is useless, or the opposite extreme: trying to cram in complex logic without understanding the anatomy of your own agent.
• Content outline:
  1. Anatomy of an Agent in Libertadia:
     • Clear instructions (role, constraints, output format).
     • Default model selection (not every problem needs the same engine).
     • Optional functions and skills (when they're needed and when a conversational agent is enough).
  2. The mistake when migrating prompts: Use the assistant to generate the base of an AI Agent and its functions.
  3. Evolution through testing: Check the quality of the answers and generate usage examples to fine-tune it.
  4. Practical step: A step-by-step template to migrate a Custom GPT to an optimised agent of your own in Libertadia.

How to design AI Agents in Libertadia that really reason, respect formats and scale with you.

The step from user to creator in Libertadia happens in the Agents & skills section. However, this is where many users get frustrated: they try to copy the 3,000-word prompt they had in ChatGPT, paste it into the instructions field and find that the agent doesn't answer with the expected precision.

The reason is simple: a good agent in Libertadia is not a long, messy text, but a well-calibrated architecture.

Next, we'll see how to structure your own agent from scratch, how to choose its engine and why you don't need to configure complex functions to have a high-performing assistant.

1. The anatomy of an Agent in Libertadia

Unlike catalog agents (which are read-only), the agents you create in Agents & skills are 100% editable and configurable. Their structure is made of three essential blocks:

YOUR OWN AGENT
1. SYSTEM INSTRUCTIONS (Role, constraints and output format)
2. DEFAULT MODEL (Text model)
3. OPTIONAL CAPABILITIES (Functions, Skills, Brains and Integrations)

Block 1: The System Instructions (The "Core")

This is the set of permanent guidelines that define the agent's identity, operational constraints and delivery structure. It shouldn't contain encyclopaedic knowledge (that's what Brains are for), but rules of reasoning and behaviour. Variables (in Advanced) and functions are configured separately.

Block 2: Choosing the Default Model

A traditional Custom GPT ties you to its platform's general model. In Libertadia, you decide which text model powers your agent, and each function can produce text, image, audio or video according to its Output type:

• Is it an agent for critical analysis or product design? Give it a model with strong logical reasoning.
• Is it an agent for quick writing or text summaries? Give it a balanced, low-latency model.
• Are there functions with no operational cost? Give it a free model for tasks that need little compute.

Block 3: Functions, Skills, Brains and Integrations (optional)

Let's demystify this: An agent does NOT need functions, skills or brains to work. A conversational agent guided by good instructions and the right model can solve 90% of professional use cases (auditing, consulting, writing, analysis). Each piece is added only when needed: functions for specific, repeatable protocols, skills for Markdown guides the agent loads when the task fits, brains to look things up in structured knowledge bases, and integrations to perform external actions, such as sending an email or creating an event.

2. The mistake when migrating prompts: From "text soup" to a modular structure

When you migrate an old Custom GPT, you need to put its content through a cleanup and refinement process.

Notice the difference between an inherited prompt and a structured instruction for Libertadia:

The monolithic approach (what usually fails):

"You're an expert in marketing and business. Help me with my LinkedIn posts and also with my emails. Use a friendly but professional tone. Don't use too many emojis. I'm attaching my company's whole history and my prices here so you remember them..."

Libertadia's modular approach: split the instructions into 4 clear, unambiguous blocks.

[ROLE AND PURPOSE]
You are a B2B positioning strategist specialised in executive summaries.
Your goal is to turn technical notes into clear posts for decision-makers.

[OPERATING PRINCIPLES]
- Prioritise conceptual clarity over generic persuasive language.
- Always identify a single central idea per deliverable.
- No corporate clichés or aggressive sales structures.

[STANDARD OUTPUT FORMAT]
Deliver each proposal structured as:
1. Main thesis (1 punchy sentence).
2. Logical argument (3 key points).
3. A debate or friction question for the audience.

[LIMITATIONS]
If the input information is not enough to support a thesis,
ask up to 2 clarifying questions before writing.

3. Roadmap: Build your agent in 4 steps

Follow this procedure in Agents & skills to create your first optimised assistant. The first few times we recommend clicking Create agent with the assistant and asking it: "I want you to generate an agent with this role and these specific functions". The assistant fills in the form and you review it before clicking Create.

1. Define the scope → Give your agent a single area of work.
2. Write the rules → Use the [Role, Principles, Format, Limits] scheme.
3. Assign the model → Choose the engine that best fits the demands of the task.
4. Test and calibrate → Give it 3 stress tests before adding it to your daily routine.

4. Practical exercise: Migrate your first GPT to Libertadia

Take the Custom GPT you use most right now and apply this 5-minute process:

1. Separate the role from the data: Pull out of the prompt everything that is "reference data, price lists or documents" (we'll use them with Brains in The advanced layer).
2. Keep only the reasoning guidelines: Apply the 4-block scheme (Role, Principles, Format, Limits). Move specific tasks to Functions.
3. Create the agent in Agents & skills: Paste your new instructions and select the default model.
4. Test it on a real task: See how the clarity and consistency of the answers far exceed what you got from your old GPT.

👉 In the next post: The advanced layer: Brains and Workflows. We'll learn to connect your agents to structured knowledge bases and to create automated workflows so you can stop chatting and start scaling.

#The advanced layer – Multiply your agents' power with Brains and Workflows

• Goal: Teach how to structure company knowledge (Brains) and automate recurring tasks (Workflows) to build scalable systems.
• Friction it addresses: Treating the knowledge base as a "file dump" and expecting the AI to reason through multi-stage processes in a single prompt.
• Content outline:
  1. From "uploading PDFs" to "Building Brains": How to organise structured knowledge bases that agents and functions can query with surgical precision.
  2. Connecting Brains with Functions and Agents: Why separating knowledge (Brain) from logic (Agent) gives full control over privacy and precision.
  3. Workflows: Stop chatting and start automating: When a task stops being a conversation and becomes a sequential or conditional workflow.
  4. Practical step: Example of a complete system: Agent + connected Brain + output Workflow (the definitive leap from basic user to system builder).

So far we've covered using Free chat, making the most of the catalog and designing your own agents in Agents & skills. If you've followed the process, you already have well-instructed, calibrated assistants.

However, the real competitive leap in Libertadia isn't just having agents that reason well in isolation, but connecting them to your business's proprietary knowledge and automating repetitive work sequences.

This is where two fundamental pillars come in: Brains and Workflows (in the menu, Automations).

1. From "uploading files in bulk" to "Building Brains"

On traditional platforms, the knowledge base is usually a dump of PDFs uploaded straight into the prompt. This causes three serious problems:

• Precision leaks: The agent looks for information in outdated or redundant documents and mixes up concepts.
• Rigidity: If you change a document, you have to reconfigure the whole assistant.
• No reuse: You can't share the same database between different agents without duplicating files.

What is a Brain in Libertadia?

A brain is a structured, dynamic knowledge base, decoupled from the agent, built from your files, texts, documents and web links.

Advantages of the decoupled model:

1. Centralised updates: You change or add a document in the Brain once and, as soon as the source is Ready (and, in RAG mode, indexed with Save and index), every connected agent or function accesses the current version.
2. Queries with surgical precision: Agents retrieve only the relevant passages at the moment the query runs, keeping the context window clean. Depending on the brain's mode, they do it with semantic search (RAG) or by searching the sources with tools (Tool retrieval).
3. Information governance: You choose which brain each agent queries by connecting it to the functions that need it. An agent without that brain connected doesn't query it, and the brain stays private unless you choose to make it public in your company.

2. Connecting Brains with Agents and Functions

For an agent to query a Brain, you don't need to paste text into its instructions. Libertadia's architecture lets you:

• Link knowledge in a modular way: You connect a Brain to one of the agent's text functions (Advanced → Brain) so the assistant searches the document base directly only when the task requires it. The function needs a model that supports tools. In Free chat you can also use it from Tools → Brain search.
• Keep instructions clean: The agent's instructions focus on how to reason and deliver (role, tone, format), while the Brain takes care of what it knows (technical documents, regulations, protocols).

3. Workflows: From conversation to automation

Chatting with AI is interactive and useful for exploring ideas, but it's inefficient for standardised processes that repeat every week.

A Workflow is a structured sequence of steps that runs on a schedule or after an external event, where the output of one task automatically feeds the next, without you having to step in manually at each stage.

Anatomy of a professional Workflow:

[INPUT]
Raw notes or a transcript of a client meeting, received by the trigger
(for example, an external event such as a new email).
   │
   ▼
[STEP 1: EXTRACTION AGENT]
Identifies agreements, deadlines and unresolved objections.
   │
   ▼
[STEP 2: AGENT WITH A CONNECTED BRAIN]
An Agent node, whose function has the services brain connected,
cross-checks the client's requirements against the current service catalogue.
   │
   ▼
[STEP 3: WRITING AGENT]
Generates the formal draft of the technical proposal and the executive minutes.
   │
   ▼
[FINAL OUTPUT]
A structured document ready for human review and sending.

By turning this process into a Workflow:

• You cut execution time from 45 minutes to a few seconds.
• You eliminate human error in passing data between stages.
• You guarantee that every deliverable keeps exactly the same quality standard.

4. Practical exercise: Design your first modular system

To put Libertadia's full architecture into practice, design a micro-system following these 4 steps:

1. Create a pilot Brain: Upload 2 or 3 core documents of your business (for example, your work methodology or your list of services and FAQs).
2. Set up your Agent: In Agents & skills, create an assistant whose instructions define how to analyse or explain that information to a third party.
3. Connect and validate: Connect the Brain to one of the agent's text functions and run 3 complex queries to check that it pulls data from the Brain accurately and cites its sources without inventing details.
4. Sketch your first Workflow: Identify a weekly repetitive task that takes more than two manual steps and design the flow in Automations to automate it.

#Series wrap-up: The new standard for working with AI

Over these 4 posts we've gone through the complete transformation:

The goal is no longer to "talk to an AI", but to build a modular, precise and scalable work ecosystem.