How Law Changes with AI Agentic Flows

A petition that used to take me an entire afternoon can now be done in minutes.

I'm not talking about copying and pasting a generic prompt into ChatGPT and accepting the first answer. That remains dangerous, especially in the legal field.

I'm talking about something else.

Imagine a common situation: the client sends some PDFs, a Word contract, loose screenshots, a previous decision, an email exchange, and a confusing audio explanation. The legal problem is there, but it's not yet organized.

Before, the grunt work almost always started the same way: opening document by document, separating facts, identifying relevant dates, checking clauses, building a timeline, locating possible requests, searching for foundations, adapting an old template, reviewing the piece, cutting excess, checking documents again, and hoping not to have left a contradiction hidden in some corner. HOURS of organizational work.

Depending on the case, this consumed 4, 5, or 6 hours before the piece even began to be written.

Today, with a well-designed flow, the first structured draft can appear in minutes.

The point is not that AI “makes the petition”.

The point is that the lawyer stops using AI as a text box and starts using AI as a work system.

This is, for me, the central difference between using a prompt and building an agentic flow.

Prompt is an isolated instruction.

Agentic flow is an organized sequence of tasks, context, files, criteria, templates, reviews, and decisions.

In a prompt, you ask: “make a petition about this”.

In a flow, you teach the agent how to work.

You show where the documents are. You tell it which files to read first. You define how to extract facts. You explain the timeline format. You provide your petition templates. You specify your way of organizing foundations. You define what it should check before writing. You determine what it must never invent. You demand a list of doubts. You ask for a risk matrix. Only then do you order the drafting.

The practical difference is ENORMOUS.

A good legal flow with AI can follow a logic more or less like this:

1. Read the case documents.
2. Extract relevant facts.
3. Separate documents by evidentiary function.
4. Build a timeline.
5. Identify controversial points.
6. Relate facts to possible requests.
7. Compare the case with previous templates.
8. Create a piece plan.
9. Draft by sections.
10. Review coherence, omissions, and risks.
11. Generate a final version in Word.
12. Produce a checklist for human review.

This does not replace legal reasoning.

In fact, it requires more legal reasoning, because the lawyer needs to know how to design the process.

AI doesn't know, on its own, what your strategy is, which thesis you prefer, what risk is worth taking, which argument is fragile, which fact needs proof, which document should not be used, which request could generate costs, or what language is appropriate for that court.

But it can brutally reduce the mechanical work that lies between the input of documents and the first useful version of the piece.

This is where LLMs come in.

LLM stands for large language model. In practice, it is the type of model that can read, interpret, summarize, compare, classify, rewrite, structure, and generate text from context.

But an LLM, alone, is still just the engine.

What changes the work is the engine within an operation.

The same model can be used poorly or excellently.

If you throw loose documents and ask for a complete petition, it might mix up facts, exaggerate foundations, lose nuances, and deliver a beautiful but unsafe piece.

If you organize the flow, separate stages, provide templates, ask for justifications, demand traceability, and include human review, the result changes in nature.

The lawyer stops receiving “an AI text” and starts receiving a work package: extracted facts, chronology, argumentative structure, draft, list of doubts, points of attention, and a verification checklist.

That's what interests me.

Tools like Codex and Claude are interesting precisely because they allow moving beyond the isolated prompt.

In both, the logic is to work within an environment with files, instructions, terminal, scripts, templates, and project structure.

This opens up a very concrete possibility for the legal profession: treating each case as an organized work folder.

Simple example of a folder per case for lawyers:

/case-client-x

/documents

/templates

/drafts

/timelines

/checklists

/outputs

/case-instructions.md

Inside /documents, go PDFs, contracts, decisions, powers of attorney, exported emails, reports, spreadsheets, and whatever else is relevant.

Inside /templates, go your previous petitions, approved structures, reference pieces, and internal firm standards.

In the instructions file, you explain how the agent should work on that type of demand.

Something like:

*“Read the main documents first.” “Extract facts with date, source, and document of origin.” “Do not create a legal foundation without indicating that it needs verification.” “Use my petition template as a structure, but adapt it to the case.” “Before drafting, present a plan.” “After the draft, generate a review checklist.” “Highlight points that depend on lawyer confirmation.”*

This seems simple, but it changes everything.

Both Codex and Claude can be especially useful when the work involves files. They can operate in folders, read content, organize documents, run scripts, convert information, create structured outputs, and work with materials that don't fit well in a common conversation.

If there are PDFs, for example, the flow can include text extraction, identification of relevant pages, summary per document, list of attachments, and linking between fact and evidence.

If there are Word files, the flow can use .docx templates, compare versions, generate a new draft, preserve structures, footers, and headers, without messing up your letterhead, as well as review titles and prepare a final file for human editing.

This is very different from asking “make a defense”.

A better flow would be:

*“1. Read the PDFs in the documents folder; 2. Build a table with fact, date, document, and page; 3. Identify legally relevant facts; 4. Compare with the defense template in the templates folder; 5. Create a defense plan; 6. List doubts before drafting; 7. Once the plan is approved, generate a draft in Word; 8. Perform a second review looking for contradictions, unfounded requests, and facts without evidence.”*

At this point, the petition in minutes stops being an empty promise.

It becomes a consequence of organization.

The lawyer still reviews.

The lawyer still decides.

The lawyer still answers.

But they don't need to spend the same energy opening file by file and manually redoing steps that can be transformed into a process.

Claude, in this specific context, is usually very strong for reading, synthesis, long writing, language review, reasoning structuring, and working with extensive context. In legal flows, this can be useful for transforming confusing materials into organized reasoning.

With Claude Code, the logic approaches agentic execution in projects and files, with instructions, skills, commands, specialized agents, and chained tasks.

With Claude Cowork, this logic goes to knowledge work on the desktop: local files, applications, folders, repetitive tasks, office materials, and deliverables that are not necessarily code.

For a lawyer, this is very relevant.

Because a large part of legal work is not just “writing”.

It's coordinating information.

It's transforming dispersed documents into a thesis.

It's transforming a thesis into a piece.

It's transforming a piece into a reviewed version.

It's transforming a review into a checklist.

It's transforming learning into a reusable template.

Claude Cowork can be thought of as an execution assistant for knowledge tasks: organizing a folder, reviewing documents, comparing versions, preparing a report, structuring a draft, helping with Word, Excel, PowerPoint, and other work environments, always with user supervision and permission.

The gain lies in delegating tasks with a beginning, middle, and end.

Not: “help me with this case”.

But:

“Open this case folder, read the main documents, generate a timeline in a table, identify evidence gaps, and prepare a first draft report for review.”

Or:

“Compare this draft with the firm's standard template, indicate relevant differences, highlight missing clauses, and generate a revised version in more objective language.”

Or:

“Read these documents, separate what is fact, what is allegation, what is evidence, and what still needs to be confirmed.”

This change in command is small on the surface, but deep in operation.

The quality of the agent depends on the quality of the work you teach.

This is where skills come in.

A skill is, in simple terms, a package of instructions, references, and sometimes scripts or templates, that teaches the agent to perform a specific type of work.

In the legal field, this can become something very powerful.

You can have a skill for:

• drafting a consumer initial petition;
• reviewing a service provision contract;
• building a procedural timeline;
• analyzing evidentiary documents;
• preparing an executive report for a client;
• reviewing a piece with a focus on coherence and risk;
• transforming a judicial decision into a strategic summary;
• creating a filing checklist;
• adapting a firm template to a specific case.

The skill doesn't need to contain just a “pretty prompt”.

It can contain method.

It can say:

*“Before drafting, always make a plan.”

“Separate facts from arguments.”

“Never invent a case number, jurisprudence, or document.”

“When there is no evidence, mark it as pending.”

“Use clear and technical language.”

“Preserve the structure of the firm's template.”

“Generate a final checklist.”

“Indicate points that need human validation.”*

Over time, the firm stops depending on improvisation.

It starts building a library of intelligent procedures.

This applies to Codex.

Applies to Claude.

Applies to API solutions.

Applies to subscription plans, when the tool already delivers a ready interface.

It is also important to understand that “model” is not all the same.

A mistake common is choosing AI as if there were only one option: the most famous, most expensive, or most talked about model.

In practice, the legal flow can use different models for different tasks.

• A fast model can classify documents, extract simple data, or organize names, dates, and values.
• A model with better reasoning can analyze theses, identify risks, build a piece plan, and review contradictions.
• A model with larger context can read many documents at once.
• A model more strong in writing can transform the plan into a clear draft.
• An agent with access to files can generate the Word document, compare versions, and organize the folder.

The operational secret lies in not treating everything as a single AI call.

The flow can be divided:

1. First, extraction.
2. Then, organization.
3. Then, analysis.
4. Then, plan.
5. Then, drafting.
6. Then, review.
7. Then, formatting.
8. Then, checklist.

Each stage has a function.

And each stage can have its own criteria.

This reduces hallucination.

Reduces rework.

Increases traceability.

And makes human review much more objective.

A practical example of a flow for an initial petition could be:

1. Input of documents.

The lawyer creates a case folder and puts the contract, conversations, receipts, notifications, previous decisions, power of attorney, personal documents, and client observations.

2. Reading and inventory.

The agent lists all documents, identifies type, date, parties involved, and possible relevance.

3. Timeline.

The agent creates a chronology with date, fact, source document, and observation about evidence.

4. Legal problems.

The agent separates possible foundations but marks what needs validation.

5. Doubts to the lawyer.

Before drafting, the agent asks what is missing: value, request, evidence, jurisdiction, statute of limitations, settlement attempt, procedural risk.

6. Piece plan.

The agent builds a structure: facts, foundations, requests, evidence, injunction, value of the case, attached documents.

7. Adaptation to the template.

The agent uses a firm template, preserves style, structure, and language, but adapts it to the case.

8. Draft.

The agent drafts the first version.

9. Technical review.

The agent reviews if all requests have a foundation, if all important facts have a document, if there are contradictions, and if any passage is too generic.

10. Output in Word.

The agent generates an editable version, with title, topics, and structure ready for the lawyer's final review.

11. Checklist.

The agent delivers a verification list before filing.

In this scenario, the first draft can come out in minutes.

But it is not born from nothing.

It is born from a system.

And this system depends on three things: good inputs, good instructions, and good review.

Without this, AI only accelerates disorganization.

A firm that wants to use AI with maturity needs to create some internal assets.

They are:

This is where the conversation returns to governance.

AI in the legal profession cannot be treated as a productivity toy.

It affects confidentiality, strategy, professional responsibility, personal data, sensitive documents, procedural risk, and client trust.

Therefore, the lawyer needs to understand the minimum of the technology.

Not to become an engineer. But to know what they are delegating.

An agent can be excellent at organizing information, but it does not assume professional responsibility.

An LLM can draft very well, but it doesn't know if that thesis is the best for that client.

A flow can accelerate the piece, but it doesn't replace legal strategy.

Maturity lies in knowing where AI enters and where it stops.

For me, the legal profession begins to change for real when the lawyer understands that they can build a small AI operation around their own work.

It doesn't need to start big.

It can start with a folder, three templates, a well-written instruction, and a simple flow:

“Read, organize, ask, plan, draft, review.”

After that, it improves.

Create skill.

Create checklist.

Create output standard.

Create template bank.

Create flow for Word.

Create flow for PDF.

Create integration via API.

Create governance.

Over time, the lawyer stops being someone who just talks to an AI.

They start operating agents.

And this is a profound change.

Because those who learn to operate agents can transform legal knowledge into a reusable process.

They can take a template that already exists and have the agent apply it to the specific case.

They can transform messy documents into structure.

They can transform hours of screening into minutes of review.

They can move from “help me with this petition” to “execute this drafting flow, using my templates, my criteria, and my checklists”.

That's the point.

When the lawyer teaches the agent to work within their method, AI stops being just a drafting tool and starts functioning as an operational layer of the firm.

The petition in minutes is just the visible part.

Behind it lies repertoire, well-built templates, organized files, clear instructions, appropriate choice of LLM, human review, and governance.

This is the point that many people still underestimate.

The real transformation is not in producing more text. It is in transforming legal knowledge into a reusable process.

A firm that learns this begins to gain consistency.

Screening improves.

Review becomes more objective.

Templates stop being forgotten in old folders.

Accumulated knowledge starts to circulate within clearer flows.

And the lawyer gains something that has always been scarce in legal practice: qualified time to think better.

In the end, AI does not make legal work less technical.

It requires more method.

And those who know how to build this method will work with an advantage that is hard to ignore.