标签：#legal

A inteligência artificial no setor jurídico ultrapassou a fase dos chatbots genéricos de pergunta e resposta. Quando lidamos com o Direito, o custo de uma "alucinação" de IA não é apenas um incômodo — pode significar a perda de um prazo fatal, uma tese fundamentada em jurisprudência inexistente ou a violação de sigilo. Para resolver esse problema, a engenharia de software aplicada a LegalTechs está migrando para os Agentic AI Workflows (Workflows de IA Agêntica). Em vez de depender de um único prompt gigantesco para resolver um problema complexo, orquestramos múltiplos agentes especializados. Neste artigo, vamos detalhar como arquitetar uma esteira de triagem, busca vetorial e sumarização de processos, utilizando ferramentas maduras e garantindo que o advogado permaneça como o orquestrador final no Quality Gate . 1. Dividir para Conquistar: A Arquitetura Multi-Agente A premissa da orquestração de agentes é a especialização. Cada agente no sistema possui um escopo restrito, ferramentas específicas ( tool use ) e um objetivo claro. Em um cenário de entrada de um novo processo longo (ex: um PDF de 500 páginas), o workflow se divide em três estágios: Agente 1: Classificação de Intenção e Roteamento O primeiro agente atua como o recepcionista. Ele não lê o documento para extrair teses; ele apenas analisa as primeiras páginas para responder: O que é isso? É uma Inicial Trabalhista? Uma intimação de prazo? Uma contestação? A partir dessa classificação, o workflow roteia o documento para a fila correta de processamento. Agente 2: RAG (Retrieval-Augmented Generation) e Busca Vetorial O segundo agente é o pesquisador. Ele quebra o documento em fragmentos ( chunks ) e cruza as alegações da parte contrária com o acervo interno do escritório. No ecossistema Elixir, por exemplo, podemos utilizar o PostgreSQL com pgvector e Ecto para armazenar os embeddings de casos passados e jurisprudências vencedoras do próprio escritório. O agente busca semelhanças e recupera o contexto estrit

Judge hasn't ruled on X Corp’s preliminary injunction, but Operation Bluebird plows ahead

If you use GitHub Copilot, Claude, Cursor or any other AI coding assistant to write production code, the legal ownership of what you ship is less settled than your licence agreement implies. The US Copyright Office ruled in January 2025 that purely AI-generated material is not copyrightable, and that prompts alone do not provide sufficient human control to earn protection. Code you wrote with heavy AI assistance sits in an uncertain middle ground: it may be copyrightable, it may not, and no court has drawn the line for software. The answer-first version: you probably do not own copyright in the portions of your code that an AI wrote without substantial human direction, and you may not be able to prove where the boundary lies. This does not mean someone else owns it — it may be uncopyrightable altogether, like a phone book. But your employment contract, your client agreement and your open-source licence all assume you hold full copyright in your deliverables. That assumption is now an open question. The rule, plainly stated Purely AI-generated output is not copyrightable in the United States. This is not a prediction or a legal opinion; it is the stated position of the US Copyright Office, set out in its January 2025 report Copyright and Artificial Intelligence, Part 2: Copyrightability . The report received over 10,000 public comments and represents the Office’s most comprehensive statement on the subject. Its conclusions are clear: “material generated wholly by AI is not copyrightable”, and existing law is adequate to handle the question without new legislation. The nuance sits in the middle ground — which is exactly where most AI-assisted coding lives. What the Copyright Office said The report draws several lines. First, it confirms the long-standing requirement that copyright requires a human author. An AI system cannot be an author, regardless of how sophisticated its output. Second, it addresses prompts: “based on the functioning of current generally available

Building any intake pipeline, you'll hit the same problem eventually. Files arrive from multiple sources. Some you've already processed: re-uploads of the same document, copies from two different intake paths, items your worker errored on last run and re-queued. Call the anchoring API blindly and you end up with multiple proof records for identical bytes. The ProofLedger v1 API returns a duplicate_of field in its 201 response when it detects a hash it's already seen. But that's only half the solution. A network round-trip costs time and quota even when it comes back as a duplicate. Hash-based local deduplication is the other half. Here's how to build a worker that handles both layers. Hash Locally First The core pattern: compute the SHA-256 digest before making any API call. If you've seen this digest before, skip it. If you haven't, submit it. Two things you need: a persistent record of digests you've already anchored, and chunked hashing so large files don't blow memory. import hashlib import json from pathlib import Path SEEN_DB = Path ( " anchored_hashes.json " ) def load_seen (): if SEEN_DB . exists (): with open ( SEEN_DB ) as f : return json . load ( f ) return {} def save_seen ( db ): with open ( SEEN_DB , " w " ) as f : json . dump ( db , f , indent = 2 ) def hash_file ( path : str ) -> str : h = hashlib . sha256 () with open ( path , " rb " ) as f : for chunk in iter ( lambda : f . read ( 65536 ), b "" ): h . update ( chunk ) return h . hexdigest () 65536-byte chunks keep memory flat regardless of file size. The load_seen / save_seen pair gives you a persistent record that survives worker restarts. Submitting and Reading duplicate_of When duplicate_of appears in the API response, its value is the proof ID of the earliest anchor for that hash. That's the canonical ID. The new proof ID from this call is irrelevant. import requests API_URL = " https://proofledger.io/api/v1/proof " API_KEY = " sk_YOUR_KEY_HERE " def anchor_file ( file_path : str , seen : dict

New behavior capturing a writer's "broad qualities" could have legal implications.

The government says destroying his own data during an airport interrogation was illegal.

Most tutorials on AI agents assume the agent should get more autonomous over time — more tools, more scope, less human intervention. That's the wrong architecture for regulated professional-services work, and if you're building for accounting or legal clients, it's worth understanding why before you write a line of code. The constraint that shapes everything In accounting and legal workflows, there's a hard line between preparing work and exercising professional judgment. A first-pass extraction of numbers from a bank statement is preparation. Deciding how to characterize a transaction for tax purposes is judgment. An agent that drafts a client letter from a template is preparation. An agent that decides what legal advice goes in that letter is not — and building one that does is a liability, not a product. This isn't a hypothetical concern. The 2026 legal industry data shows the gap plainly: 69% of individual lawyers now use generative AI at work, according to the 8am 2026 Legal Industry Report, but firm-wide adoption of legal-specific AI sits at only 34%, and 54% of firms report no training or governance plan for responsible AI use at all. The technology is ahead of the guardrails, and that's exactly the gap this architecture is meant to close. So the architecture I use treats "human approval" as a first-class step in the pipeline, not an afterthought bolted on for compliance theater. Concretely, that looks like four layers. 1. Ingestion layer Documents come in from wherever the firm already receives them — email, upload, integration with QuickBooks, Xero, Clio, iManage — get classified, and get normalized into structured data. 2. Extraction / drafting layer The agent does the actual work: pulling line items, matching transactions, assembling a first-draft letter, flagging clauses in a contract that need a human eye. 3. Approval gate Nothing produced in step 2 moves forward without an explicit human action. This isn't a suggestion in a UI that can be ignored; it's

Pennsylvania cop charged with oppression and obstruction.

Where AI incidents in legal actually come from, and what infrastructure (not policy) prevents them. Blake Aber · Predicate Ventures · 2026 The policy layer is table stakes. It isn't enough. When Sullivan & Cromwell apologized to a federal bankruptcy judge in April 2026 for AI hallucinations in a court filing, the firm's apology letter said the firm had policies. Safeguards existed. Those safeguards weren't followed. That framing, "the safeguard existed but wasn't followed," is how a policy failure gets described. But something more specific happened: a hallucination was generated, wasn't caught at generation time, wasn't caught at review time, and made it into a document that got filed. That's not a policy problem. It's an infrastructure problem. The distinction matters because it determines what you build next. What policy can and can't do Policy is a promise made before the event. A well-written AI acceptable-use policy says: don't submit output you haven't reviewed; verify citations before they go into a document; a human must approve anything client-facing. This works when the human executing the task has time, attention, and professional accountability in that moment. It fails when one of those is missing: a deadline, a junior practitioner, a late-night run. Policy can't: Verify a citation at the point of generation Flag output that has drifted below a confidence threshold Stop hallucinated text from appearing in a draft before a human ever sees it Detect when the underlying model is behaving differently than it was in testing Policy can: Set the expectation that review must happen Define who bears accountability when it doesn't Create a paper trail after the fact One of those is prevention. The other is compliance. What infrastructure does instead An AI harness layer operates at the point of generation, not at the point of review. This reflects a broader reality that production AI is mostly harness and very little model . For legal work specifically, three com

Sandstone's Series A was led by Lightspeed Partners, with participation from Sequoia.

In 2024, Orca Security sued Wiz and demanded their full git version control history. Orca wanted to see "when features and functions were added, modified, or altered, including through engineers' notes and comments." The court recognized git history as relevant evidence in a software IP dispute. It ordered production of commit logs tied to two specific features. That ruling should concern you. Your commits record author name, email, timestamp, and content hash. Git chains them together cryptographically, replicates them across clones, and makes them discoverable in litigation. You are building a legal record whether you intend to or not. You already use git as a development tool. It is also a chain of custody for intellectual property. And you are probably destroying yours. A Cryptographic Chain of Custody Every git commit stores five things: the content of the change, the author's name and email, the author's timestamp, the committer's name and email, and the committer's timestamp. That commit is hashed using SHA-1 (or SHA-256 in newer repositories), and the hash incorporates the hash of the parent commit. Change one byte anywhere in the chain and every subsequent hash changes. This is a Merkle DAG. The same data structure that makes blockchains tamper-evident. Your commit history is a cryptographic proof linking each change to all previous changes. Git records three layers of timestamps. AuthorDate is when the content was written. CommitterDate is when it was finalized into the repository. And the server-side push timestamp, recorded by GitHub or GitLab, marks when the remote received the data. That third timestamp is outside the developer's control. A clone is a full copy of the entire history. Your collaborators, CI runners, and backup systems each hold an independent replica. Forensics researchers call this "evidence proliferation." Tampering with one copy does nothing if fifty others exist unchanged. Under Federal Rules of Evidence 902(14), data verified throu