---
title: "Foundations"
canonical: "https://current.tinyfish.ai/issue/22/foundations"
publication: "TinyFish"
publisher: "TinyFish"
language: "en-US"
guide: "https://current.tinyfish.ai/llms.txt"
permalink: "https://current.tinyfish.ai/issue/22/foundations"
issue: 22
section: "foundations"
description: "Conceptual clarity earned from building at scale"
authors: ["Rina Takahashi"]
published: 2026-03-30
updated: 2026-03-26
articles: 19
---

# TinyFish

> CURRENT is a journal about AI agents in production, for the engineering and product leaders who have to make them work. Drawing on experience building enterprise web agents, it explains why the demo succeeded and the deployment didn't, and what that means for choosing vendors, briefing the board, and avoiding mistakes others have already made.

[Read on the website](<https://current.tinyfish.ai/issue/22/foundations>)

## Issue 22 — Foundations

Conceptual clarity earned from building at scale

### The Portability Gap

- [The Export File Is Not the Agent](<https://current.tinyfish.ai/issue/22/foundations/article/12066/markdown>) — By [Rina Takahashi](<https://current.tinyfish.ai/team/25/markdown>) · Published 2026-03-25 · Format: The Portability Gap

A growing wave of tools now lets you export an agent definition and import it into a different framework. System prompts, tool schemas, model preferences, constraints. All neatly packaged. The tools work. What's worth paying attention to is what the export file leaves behind.

### Portability, Tested

- [What Doesn't Survive the Trip Tells You Something About Agents](<https://current.tinyfish.ai/issue/22/foundations/article/12067/markdown>) — By [Rina Takahashi](<https://current.tinyfish.ai/team/25/markdown>) · Published 2026-03-26 · Format: Portability, Tested

Docker found its seam between application and infrastructure, and that boundary turned out to be clean enough to hold across millions of deployments. Now an open-source project called GitAgent is storing AI agents as flat files in a git repo. Personality in YAML. Memory as Markdown. One export command targeting five different frameworks. The pitch is portability. The bet is that there's an equivalent cut to be made for agents.

### Further Reading

- **The 2026 MCP Roadmap** — [Source](<http://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/>) — Published 2026-03-26

The protocol's own gap map. Config portability, auth continuity, and gateway behavior are all still pre-RFC, which tells you where the real boundaries are.

- **Salesforce/MuleSoft 2026 Connectivity Benchmark Report** — [Source](<https://www.salesforce.com/news/stories/connectivity-report-announcement-2026/>) — Published 2026-03-26

Primary data on agent silos at scale: half of enterprise agents operate in isolation, the average org runs twelve. Vendor-commissioned, so read accordingly, but the numbers ground the portability conversation.

- **MCP's Biggest Growing Pains for Production Use Will Soon Be Solved** — [Source](<https://thenewstack.io/model-context-protocol-roadmap-2026/>) — Published 2026-03-26

Useful practitioner framing of what breaks when a protocol becomes load-bearing infrastructure before enterprise governance catches up to it.

- **Meet GitAgent: A Universal Open-Source Format for Framework-Agnostic AI Agents** — [Source](<https://www.marktechpost.com/2026/03/22/meet-gitagent-the-docker-for-ai-agents-that-is-finally-solving-the-fragmentation-between-langchain-autogen-and-claude-code/>) — Published 2026-03-26

Technical walkthrough of define-once, export-to-five-frameworks portability. Worth reading for the git-native oversight model, which treats pull requests as a governance surface.

- **AI Agent Frameworks 2026: LangGraph vs CrewAI & More** — [Source](<https://letsdatascience.com/blog/ai-agent-frameworks-compared>) — Published 2026-03-26

Concrete look at why framework lock-in carries real migration costs, and how MCP's tool layer functions as a partial portability hedge across competing stacks.

### What Travels, What Doesn't

"Can we move this agent somewhere else?" sounds like one question. It's actually six, and they have wildly different answers.

An agent is a stack of layers. System prompts, tool connections, memory, authorization, learned behavior, accumulated trust. Some of these travel well. Tool definitions, thanks to MCP, have a real interoperability story. System prompts are literally just text you can copy-paste. But memory architecture, auth tokens, behavioral patterns, trust? That's where the conversation gets honest.

These cards map the gradient. It's steeper than most portability discussions acknowledge.

- **System Prompts Copy Easily but Behave Unpredictably** — [Source](<https://converter.brightcoding.dev/blog/system-prompts-for-ai-agents-the-complete-2026-guide-to-building-powerful-safe-autonomous-systems>) — Published 2026-03-26

Tag: Core Logic

A system prompt is just text. You can paste it anywhere. But identical instructions produce meaningfully different behavior across model families, and frameworks like LangChain, CrewAI, and OpenAI's Agents SDK each wire those instructions into different structural patterns. The words travel fine. The behavior stays behind.

- **MCP Makes Tool Definitions the Bright Spot** — [Source](<https://www.descope.com/blog/post/mcp-vs-function-calling>) — Published 2026-03-26

Tag: Tool Layer

Tools are the most portable layer right now, and MCP deserves the credit. Point a new client at the same MCP servers and things mostly just work. Mostly. JSON Schema dialect mismatches still cause real friction, and MCP handles discovery, not execution concerns like rate limits or compliance logging.

- **Memory Is Where Portability Runs Into Concrete** — [Source](<https://machinelearningmastery.com/the-6-best-ai-agent-memory-frameworks-you-should-try-in-2026/>) — Published 2026-03-26

Tag: Agent Memory

Every major framework implements memory its own way. LangChain has buffer and summary modules. CrewAI has built-in memory types. AutoGen leans on conversational history. None of them talk to each other. Platforms like Mem0 and Zep offer framework-agnostic persistence, but there's no export standard. Switching frameworks means rebuilding from scratch.

- **Authorization Tokens Are Locked Down by Design** — [Source](<https://www.nccoe.nist.gov/sites/default/files/2026-02/accelerating-the-adoption-of-software-and-ai-agent-identity-and-authorization-concept-paper.pdf>) — Published 2026-03-26

Tag: Auth State

OAuth tokens are scoped to a specific server, resource, and agent identity. That's intentional: a leaked token shouldn't work somewhere else. But it also means authorization state can't follow an agent between deployments without full reissue. NIST's February 2026 concept paper on agent identity signals just how unsettled this area remains.

- **Hard-Won Production Skills Go Nowhere at All** — [Source](<https://arxiv.org/html/2601.12560v1>) — Published 2026-03-26

Tag: Learned Behavior

Over time, agents accumulate workflow shortcuts, heuristics, task-specific improvements. These live as elaborate prompt additions, vector-embedded examples, or fine-tuned weights. None of these formats are standardized. None are cross-framework compatible. An agent that spent months getting good at its job carries none of that skill into a new home.

- **Trust Built Over Thousands of Tasks Resets Instantly** — [Source](<https://www.biometricupdate.com/202603/ai-agent-identity-and-next-gen-enterprise-authentication-prominent-at-rsac-2026>) — Published 2026-03-26

Tag: Earned Trust

Separate from formal permissions, trust is the expanded autonomy an agent earns by performing reliably over time. Thousands of flawless tasks, zero incidents, growing confidence from the humans and systems around it. Move that agent to a new framework or deployment and all of it vanishes. No protocol exists for exporting a track record.

### How Frameworks Carry State

Ask five agent frameworks where memory lives and you'll get five structurally different answers. One checkpoints graph state to Postgres. Another treats the raw conversation as the only record. A third stores everything on someone else's servers, behind an API key you don't fully control.

These differences feel like implementation details right up until you try to move an agent from one framework to another. That's when the real shape of the problem becomes visible: identity might travel, but accumulated knowledge almost never does. Each framework's state model reflects genuine architectural choices. And those choices lock in faster than most teams expect.

Here's where agent state actually lives in six major frameworks, what persists, and what gets quietly left behind.

- **LangGraph Scatters State Across Three Separate Layers** — [Source](<https://docs.langchain.com/oss/python/concepts/memory>) — Published 2026-03-26

Tag: Graph State

Memory fragments across graph state schemas, checkpointer backends, and store namespaces. Short-term memory is thread-scoped. Long-term memory spans sessions via PostgreSQL or InMemoryStore. No single export captures the full picture. Moving an agent means reconstructing three layers independently, with nothing bridging them.

- **CrewAI Funnels Everything Through One Memory Object** — [Source](<https://docs.crewai.com/en/concepts/memory>) — Published 2026-03-26

Tag: Unified Memory

A single Memory() class replaces separate short-term, long-term, and entity stores. An LLM infers scope and importance at save time. Facts get auto-extracted after each task. Agent identity ports easily as role/goal/backstory text. The fact store, though? No standard export format exists.

- **AutoGen Makes the Conversation the Whole State** — [Source](<https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/memory.html>) — Published 2026-03-26

Tag: Conversation State

State is a flat message list shared across group chat participants. No separate schema. Agents join and leave dynamically while a GroupChatManager picks speakers. Persistent memory requires bolting on ChromaDB or Mem0. The message JSON exports fine. The group topology and speaker logic don't.

- **OpenAI Assistants API Keeps State on Their Servers** — [Source](<https://developers.openai.com/api/docs/assistants/deep-dive>) — Published 2026-03-26

Tag: Server-Side Threads

Threads, messages, files, vector stores: all on OpenAI's infrastructure, scoped to your API key. The API handles context truncation across up to 100,000 messages per thread. Now deprecated with an August 2026 shutdown date, so migration isn't optional. Everything must be extracted and rebuilt against the Responses API.

- **Claude Code State Vanishes When You Close Sessions** — [Source](<https://blog.imseankim.com/claude-code-team-mode-multi-agent-orchestration-march-2026/>) — Published 2026-03-26

Tag: Ephemeral Context

Session context lives entirely in the active context window. Close the session, lose the state. Persistent instructions survive only as CLAUDE.md files checked into the repo. The v2.1.69 release added agent_id tracking for team mode and patched a memory leak where subagents were pinning the parent's full conversation history.

- **GitAgent Moves Identity but Leaves Knowledge Behind** — [Source](<https://github.com/open-gitagent/gitagent>) — Published 2026-03-26

Tag: Portability Layer

An open-source spec for exporting agent definitions via SOUL.md, agent.yaml, and skills directories. System prompts, tool schemas, and role policies travel cleanly between frameworks. Memory, orchestration logic, and accumulated knowledge stay put. What the agent is can port. What the agent knows cannot.

## Other sections in Issue 22

- [Daily Brief](<https://current.tinyfish.ai/issue/22/daily-brief/markdown>)
- [Market Pulse](<https://current.tinyfish.ai/issue/22/market-pulse/markdown>)
- [Practitioner's Corner](<https://current.tinyfish.ai/issue/22/practitioners-corner/markdown>)
- [Echoes](<https://current.tinyfish.ai/issue/22/echoes/markdown>)
- [Vision](<https://current.tinyfish.ai/issue/22/vision/markdown>)

## More

- [Publication guide](<https://current.tinyfish.ai/llms.txt>)
- [Issue archive](<https://current.tinyfish.ai/issues/markdown>)
