You need one simple truth, but it is buried in an email, a text attachment, a chat aside, a PDF, and a stale note. Landfall helps the agent find the thing and stop.
pipx install git+https://github.com/eidos-agi/landfall-forge.git You are trying to figure out what is true, but the facts are everywhere: an email thread, a text attachment, a chat side channel, a PDF someone sent weeks ago, a stale note, and a name you half remember.
The grown-up answer is to build a data pipeline. That is absurd for a Tuesday afternoon. You need to find the thing, save the evidence, update the note, and know where the agent must stop.
Landfall gives the agent a map for this one mess: where to look, what to save, what to update, and where to stop.
Landfall gives the agent a short, explicit job before it starts searching: look here, answer these questions, save this evidence, update this note, and do not cross these lines.
Under the hood, that job is a small YAML contract. The CLI turns it into a run packet with source hints, questions, write targets, and stop conditions. The agent still does the search and judgment; Landfall makes the improvised hunt repeatable.
Use Landfall when the facts matter, but the source does not deserve a full integration project yet. Each run turns the messy discovery into a better import pattern for the next agent.
The saved notes say one thing. The newest email or chat thread says another.
Landfall moveAlways refresh named live sources before advising or writing.
The key fact sits in a PDF, screenshot, deck, or local file nobody indexed.
Landfall moveName the attachment hunt, where to look, and where to store evidence.
The answer depends on email, texts, public records, local notes, and judgment.
Landfall moveGive the agent a bounded source list and a human-only stop line.
The work is valuable, but it does not repeat enough for a warehouse or connector.
Landfall moveDo the small bounded hunt now; promote it later only if it keeps recurring.
An agent finds the facts but leaves no durable trail for the next agent.
Landfall moveWrite a run packet and update the declared note, task, file, or record every time.
The agent can inspect and draft, but sending, spending, signing, or exposing data needs a human.
Landfall moveMake the stop conditions part of the contract, not an instruction hidden in chat.
The first run often discovers the real problem: the email link is missing, the PDF lives in texts, the chat room has a different name, the source file moved, or the useful output needs a new section. Landfall captures those findings in the contract and run packet so the next run starts with better instructions.
Agents are dangerous when they search through a messy situation without a trail. They read an old note, miss yesterday's email, skip the attachment, and confidently update the wrong thing. Landfall makes the collection path explicit: refresh the right evidence, compare it to saved state, update the declared surface, and stop before human-only actions.
Most teams solve data by connecting known systems. That works when the source is a billing app, a CRM, a database, or another clean API. Operating intelligence usually breaks somewhere else: one-off PDFs, private texts, forwarded emails, local folders, half-remembered names, chat side channels, public records, and decisions that only make sense after reading all of them together.
Clean systems, stable schemas, repeatable reports. This is the right plan when the world behaves.
The valuable data is real. It just does not arrive through a normal connector.
AI does not make messy sources disappear. It makes more work worth attempting, which means more irregular data gets surfaced. A human assistant might ignore the weird PDF or missing thread because the labor is too high. An agent will try anyway. That is powerful, but it means the long tail becomes the main event.
Handles the happy path and punts the rest.
Attempts more surfaces, so it finds more exceptions.
Turns recurring exceptions into repeatable intake rituals.
Landfall does not build a universal data platform for the long tail. It trains agents to handle the small messy hunts in repeatable ways. A contract says: here are the irregular sources, here are the questions, here is where the answer belongs, here is what counts as evidence, and here is where the agent must stop.
pipx install git+https://github.com/eidos-agi/landfall-forge.git# See whether this workspace has landfalls
landfall doctor
# List saved import rituals
landfall list
# Turn a landfall into an agent execution brief
landfall brief relationship-intel
# Emit a structured packet for an agent or orchestration layer
landfall brief relationship-intel --json
# Write the run packet under .landfall/runs/
landfall run relationship-intel --write-report
# Validate the local landfall contracts
landfall auditlandfall_version: 1
name: relationship-intel-landfall
size: focused
purpose: Refresh the current relationship picture before advising Daniel.
sources:
email:
commands:
- "private-email search 'client intro outside engineer' --json"
connector_actions:
- "email_read_thread id=example-thread-id id_type=thread"
questions:
- id: email_review_links
prompt: "Which email links let Daniel review or answer directly?"
write_targets:
summaries:
- "notes/landfall-YYYY-MM-DD-relationship-intel.md"
stop_conditions:
- "Do not send outbound email without explicit approval."The client relationship workflow used Landfall to pull together email, text messages, chat notes, PDFs, public records, local files, and rolodex notes without building a warehouse or integration service first.