Planning a 2-Week Europe Trip with a Single Prompt

Multi-city trip planning hits the same wall whether you ask an AI agent or juggle map apps and spreadsheets — context gets dropped, coordinates get fabricated, and sources become untraceable. We break down, feature by feature, how Consilience plans a two-week itinerary from Paris to Vienna.

Multi-city trips follow a strange law: your wishlist takes five minutes to write, but turning it into an actual itinerary — which city first, what to eat, where to sleep, how to get around — gets put off until right before departure, with about 47 browser tabs open.

I handed this ultimate human dilemma to Consilience: Paris, Amsterdam, Berlin, Prague, Vienna. A 14-night trip departing July 20, 2026 and returning August 3. Let's follow how scattered notes turn into a day-by-day guidebook, and see which feature did the work at each step — and why other tools get stuck.

Last updated: 2026-07-16

How do people usually plan complex, long trips

There used to be two ways to plan a trip route: hand-assemble it by juggling map apps, notepads, and spreadsheets, or ask an AI to do it all at once. The AI side now has more options too — general-purpose AI agents like ChatGPT, Claude, and Gemini; local coding agents like Claude Code or Cursor; and traditional RAG services like NotebookLM, where you upload documents and ask questions.

But none of these can see a trip plan through to the end. The manual approach is accurate but laborious — places live in a map, notes in a notebook, costs in a spreadsheet, and fixing one means manually re-syncing the rest. General-purpose AI agents drop your original wishlist as the conversation grows longer, and generate coordinates and travel times without verification. Sources are hard to trace back. Consilience, by contrast, maintains context, tracks sources, and actually computes coordinates, routes, and travel times.

All of this happens within a single workspace. The structure is simple: all materials connect into one knowledge graph (KG), on top of which the map view and guidebook are generated.

flowchart LR
    W["흩어진 위시리스트<br/>(5개국)"] --> G{{"온톨로지 그래프"}}
    R["딥리서치<br/>날씨·축제·요금"] --> G
    S["Appshot<br/>예약·지도 화면"] --> G
    G --> M["지도 캔버스<br/>지오코딩 경로 + 클러스터"]
    G --> B["가이드북<br/>Day 1…14, 출처 포함"]
    M <--> B

Now let's break it down feature by feature.

One line pulls exactly the context you need: the Ontology Graph

AI agents drop context because they treat notes as "chunks of text pasted into a conversation." Consilience, from the moment material is imported, atomizes it into entities and links them via relations. So a single line like "plan the trip" is enough to pull in exactly the right scope — the brief, all five wishlists, the draft itinerary. No need to attach any files.

And every relation in the graph carries the original source sentence it was drawn from. Hover over a relation chip and the exact original text appears, showing which note and which sentence it came from. That's the difference between a "plausible answer" and a "traceable answer."

The difference from other tools lies in the unit of retrieval. Local coding agents touch files directly, but once a session ends, context has to be rebuilt from scratch. Traditional RAG performs a single similarity search over chunks, which makes it weak at questions requiring relational inference, and attaching it to a workflow like maps requires custom development.

A map that builds real coordinates and routes: the Map Canvas

Ask an LLM "give me the coordinates for the Musée d'Orsay" and you'll get a plausible-looking number. The problem is you can't know if it's right until you check. That's dangerous for a travel map. Map Canvas uses actual geocoding technology for this calculation instead of the model. Coordinates, distances, travel times, and routes are all computed automatically. For places listed by name only, without an address, the agent verifies them on the web before geocoding, and for places it still can't pin down, it surfaces the most reliable information it can find.

Here's the result: every place from the wishlist lands on the city's map, routes between cities are drawn in the draft order, and within a city, places cluster together so a day's route is visible at a glance. Travel times are based on real roads and rail. Click a pin and "View in graph" jumps straight to that node in the graph.

AI agents plausibly fabricate coordinates. Consilience only shows what's certain.

The two features that make Consilience feel more like magic: Deep Research and Appshot

A wishlist only tells you "where." Two tools fill in how to get there, what the weather will be, and what's happening in a city that week.

Deep Research is a researcher you kick off with a single /research line. It scans the web to find, for each leg, train vs. flight, travel time, rough fares, and whether a rail pass pays off. Results turn into notes with attached sources and retrieval dates, and it handles local-language European sources on its own. A plan-shaking discovery came from here too: Amsterdam to Berlin by direct train takes about 6 hours — long enough to binge through Squid Game 3. For this leg specifically, I weighed train against flight side by side.

Until now, there were only two ways to feed on-screen information to an LLM: a screenshot, or copying the text. Screenshots leave you with just an image; a ⌘A copy-all flattens the hierarchy. Appshot, by contrast, captures whatever app window you have open with a single keyboard shortcut (pressing both ⌘ keys at once). Along with the screen image, it feeds in text that transcribes the window's structure, hierarchy intact:

Window: "Amsterdam → Berlin, Sun 26 Jul - Deutsche Bahn", App: Chrome
표준 윈도우 Deutsche Bahn, URL: https://int.bahn.de/en/…
	그룹 (settable, string) 출발편 목록
		그룹 (settable, string) 오전 직통편
			이미지 요금·소요시간
		그룹 (settable, string) 오후 환승편
	이미지 노선도

Appshot reads a window's structure directly through the operating system's accessibility API, without a vision model. The image and attachment chip appear first, in roughly half a second, and the hierarchical transcription of a complex web page follows a few seconds later, added to the same attachment. No vision tokens are spent. Each capture also records which app, which window, and which URL it came from. You don't need a long explanation like "check the top right of the screenshot I just took, then read the fare below the red button." "Add this fare to the comparison table" is enough.

Weather, lodging areas, food, and events for each city get filled in through this same flow. Because research is done against actual stay dates — Paris July 20–22, Amsterdam July 23–25, Berlin July 26–28, Prague July 29–30, Vienna July 31–August 2 — events that have already passed don't sneak into the plan. Only events whose date and location actually match appear on the map.

No need to worry when plans change — the knowledge graph reflects it automatically

From the moment you decide to take a trip to the moment you leave the house, the plan gets revised about 52 times. It keeps changing even during the trip. Consilience stores this long "history of decisions" intelligently — the same kind of technology Palantir uses to record decision units from piles of scattered unstructured data and chain them into a lineage. Write "take the train from Amsterdam to Berlin," and it's recorded as a decision. Later, change it to "actually, fly that leg instead," and the new decision supersedes the old one — while the history of that replacement is preserved. Open questions from your notes get captured as unresolved questions too, closed one by one. Ask "what did we decide about lodging again?" and only the latest decision comes back. It doesn't rely on an LLM's memory system. Consilience doesn't roll the dice.

You can't stop plans from changing. But you can stop an old plan from pretending to be the new one.

Use the map and guidebook together

"Make me a guidebook ordered for good walking routes." A request like that is enough to get Day 1 on July 20 through Day 14 on August 2. August 3 is marked separately as the return day from Vienna. Each day walks through a city's cluster in order, travel days carry the train or flight, and every item comes with a source. Open a day and that day's map appears alongside it.

Click any pin on the map. "View in graph" jumps straight to that place's node in the graph, and clicking a place name (a wikilink) inside the guidebook opens the original note. That's because the itinerary and the map read and write the same graph from the start — nothing needs to be built separately and manually synced.

The itinerary and the map aren't two files — they're two views of one graph.

What made this possible

Not magic — just features combined on top of the same graph.

• Ontology Graph: automatically pulls in scattered context and attaches the original source sentence as evidence for every relation.
• Map Canvas: computes coordinates and routes with built-in geocoding/routing, and researches places without addresses to find them.
• Deep Research (`/research`): scans the web and leaves behind notes with sources and dates attached.
• Appshot: brings in on-screen information as both an image and a hierarchically transcribed text, in one shot.
• Decision tracking: new decisions supersede old ones, so the graph always knows the latest plan.
• Writing: authors the map and guidebook together from the same graph.

In this post, I used Consilience to turn a two-week, five-country trip into a map and an automatically updated guidebook. And it's not just travel — anywhere materials and context pile up, it works powerfully, intelligently, and fast. Whether it's reviewing papers or managing a product, are you still stuck explaining context to an agent, refining your intent, and repeating your questions over and over?

FAQ

Do I need to attach notes every time?

No. Because notes are connected via relations in the ontology graph, a single-line instruction is enough to automatically pull in the related notes. You can trace back exactly which evidence was used through the original source sentence cited on every relation.

Is the AI making up the routes or travel times?

No. Coordinates, distances, routes, and travel times are computed by geocoding/routing services, and the model only uses the results — it doesn't generate them. For places it still can't pin down, it shows "unknown" instead of a pin.

How is Appshot different from pasting a screenshot?

A screenshot is just an image, so it relies on a vision model's interpretation. Appshot uses the operating system's accessibility API to transcribe a window's structure with its hierarchy intact, bringing in image and text together. It also records which app, which window, and which URL it came from.

Sources: City and neighborhood information used WikiVoyage (CC BY-SA 4.0). Weather, fares, and event dates reflect values at the time of retrieval, with the retrieval date noted in the text.