How to Build AI Agents With Memory

Real AI agents need memory, not just short context windows, but structured, reusable knowledge that evolves over time. Without memory, agents behave like goldfish. They forget past decisions, repeat mistakes, and treat every interaction as brand new. With memory, agents start to feel intelligent. They summarize long conversations, extract insights, branch tasks, learn from experience, retrieve multimodal knowledge, and build long-term representations that improve future actions. This is what Agentic AI Memory enables. At its core, agent memory is made up of multiple layers working together: - Context condensation compresses long histories into usable summaries so agents stay within token limits. - Insight extraction captures key facts, decisions, and learnings from every interaction. - Context branching allows agents to manage parallel task threads without losing state. - Internalizing experiences lets agents learn from outcomes and store operational knowledge. - Multimodal RAG retrieves memory across text, images, and videos for richer understanding. - Knowledge graphs organize memory as entities and relationships, enabling structured reasoning. - Model and knowledge editing updates internal representations when new information arrives. - Key-value generation converts interactions into structured memory for fast retrieval. - KV reuse and compression optimize memory efficiency at scale. - Latent memory generation stores experience as vector embeddings. - Latent repositories provide long-term recall across sessions and workflows. Together, these architectures form the memory backbone of autonomous agents - enabling persistence, adaptation, personalization, and multi-step execution. If you’re building agentic systems, memory design matters as much as model choice. Because without memory, agents only react. With memory, they learn. Save this if you’re working on AI agents. Share it with your engineering or architecture team. This is how agents move from reactive tools to evolving systems. #AI #AgenticAI

Is your agent truly remembering, or just responding? #AIagents don’t fail because they lack intelligence - they fail because they lack memory. Without structured memory, your agent will keep on repeating the same mistakes, forgetting users and losing context. If you want to build an agent that actually works in a product, you need a #memorysystem instead of just a prompt. Here’s the exact #memoryarchitecture used to scale AI agents in real production environments: 1️⃣ Long-Term Memory (Persistent Knowledge) Consider this the agent's accumulated knowledge, an archive of its developing "mind." • Semantic Memory It stores factual and static knowledge. Private knowledge base, documents, grounding context Example: Product FAQs, SOPs, API docs. • Episodic Memory It stores personal experiences & interactions. Chat history, session logs, and embeddings from past user interactions. Example: Remembering that a user prefers responses in bullet points. • Procedural Memory It stores how-to knowledge and workflows. Tool registries, prompt templates, execution rules Example: Knowing which tool to trigger when a user asks for a report. Why It Matters: #Longtermmemory prevents the agent from repeatedly learning the same information. It establishes context across sessions, leading to increased intelligence over time. 2️⃣ Short-Term Memory (Dynamic Context) This functions as the agent's working memory, a temporary space for notes during task resolution. • Prompt Structure This holds the current task's structure and its reasoning chain. Think: instructions, tone, goal. • Available Tools Stores which tools are accessible at the moment Think: “Can I access the Google Calendar API or not?” • Additional Context Temporary user interaction metadata. Think: user’s time zone, current query type, or page visited. Why It Matters: An agent's #shorttermmemory allows for immediate decision-making, providing agility in response to current events. This architecture empowers agents to: ✅Autonomously manage intricate workflows ✅Acquire knowledge without the need for retraining ✅Tailor experiences over time ✅Prevent recurring errors This architectural design differentiates a chatbot that merely responds from an agent capable of reasoning, adapting, and evolving. Developers often implement only one type of memory, but the most effective agents utilize all five. The key to long-term value, rather than short-term hype, lies in scalable memory.

Everyone's adding "memory" to their AI agents. Almost nobody's adding actual memory. Your vector database isn't memory. It's one Post-it note in an 8-drawer filing cabinet. Building Synnc's LangGraph agents taught us this the hard way. Here are 8 memory types — and the stack we actually use: 1) Context Window Memory ↳ The LLM's immediate working RAM ↳ We cap at 80% capacity to leave room for tool responses 2) Conversation Buffer ↳ Multi-turn dialogue persistence ↳ LangGraph checkpointers handle this natively 3) Semantic Memory ↳ Long-term user knowledge + preferences ↳ Mem0 gives us cross-session personalization out of the box 4) Episodic Memory ↳ Learning from past agent successes/failures ↳ Mem0 stores interaction traces → feeds few-shot examples 5) Tool Response Cache ↳ Stop paying for the same API call twice ↳ Redis gives us <1ms latency + native LangGraph integration 6) RAG Cache ↳ Embedding + retrieval deduplication ↳ Pinecone handles vector storage + similarity search 7) Agent State Store ↳ Time-travel debugging for complex workflows ↳ LangGraph + Redis checkpointing → rewind to any decision point 8) Procedural Memory ↳ Guardrails + consistent agent behavior ↳ Baked directly into our LangGraph node structure Our stack: LangGraph + Mem0 + Redis + Pinecone 4 products. 8 memory layers covered. The result? → 70% faster debugging (time-travel to any state) → 40% lower API costs (Redis caching) → Day-one personalization (Mem0 cross-session memory) Memory architecture isn't optional anymore. What's your agent memory stack?

Stop worshipping prompts. Start engineering the CONTEXT. If the LLM sounds smart but generates nonsense, that’s not really “hallucination” anymore… That’s due to the incomplete context one feeds it, which is (most of the time) unstructured, stale, or missing the things that mattered. But we need to understand that context isn't just the icing anymore, it's the whole damn CAKE that makes or breaks modern AI apps. We’re seeing a shift where initially RAG gave models a library card, and now context engineering principles teach them what to pull, when to pull, and how to best use it without polluting context windows. The most effective systems today are modular, with retrieval, memory, and tool use working together seamlessly. What a modern context-engineered system looks like: • Working memory: the last few turns and interim tool results needed right now. • Long-term memory: user preferences, prior outcomes, and facts stored in vector stores, referenced when useful. • Dynamic retrieval: query rewriting, reranking, and compression before anything hits the context window. • Tools as first-class citizens: APIs, search, MCP servers, etc., invoked when necessary. 𝐄𝐱𝐚𝐦𝐩𝐥𝐞: In an AI coding agent, working memory stores the latest compiler errors and recent changes, while long-term memory stores project dependencies and indexed files. The tools fetch API documentation and run web searches when knowledge falls short. The result is faster, more accurate code without hallucinations. So, if you’re building smart Agents today, do this: • Start with optimizing retrieval quality: query rewriting, rerankers, and context compression before the LLM sees anything. • Separate memories: working (short-term) vs. long-term, write back only distilled facts (not entire transcripts) to the long-term memory. • Treat tools like sensors: call them when evidence is missing. Never assume the model just “knows” everything. • Make the context contract explicit: schemas for tools/outputs and lightweight, enforceable system rules. The good news is that your existing RAG stack isn’t obsolete with the emergence of these new principles - it is the foundation. The difference now is orchestration: curating the smallest, sharpest slice of context the model needs to fulfill its job… no more, no less. So, if the model’s output is off, don’t just rewrite the prompt. Review and fix that context, and then watch the model act like it finally understands the assignment!

AI agents without proper memory are just expensive chatbots repeating the same mistakes. After building 50+ production agents, I discovered most developers only implement 1 out of 5 critical memory types. Here's the complete memory architecture powering agents at Google, Microsoft, and top AI startups: 𝗦𝗵𝗼𝗿𝘁-𝘁𝗲𝗿𝗺 𝗠𝗲𝗺𝗼𝗿𝘆 (𝗪𝗼𝗿𝗸𝗶𝗻𝗴 𝗠𝗲𝗺𝗼𝗿𝘆) → Maintains conversation context (last 5-10 turns) → Enables coherent multi-turn dialogues → Clears after session ends → Implementation: Rolling buffer/context window 𝗟𝗼𝗻𝗴-𝘁𝗲𝗿𝗺 𝗠𝗲𝗺𝗼𝗿𝘆 (𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝘁 𝗦𝘁𝗼𝗿𝗮𝗴𝗲) Unlike short-term memory, long-term memory persists across sessions and contains three specialized subsystems: 𝟭. 𝗦𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝗠𝗲𝗺𝗼𝗿𝘆 (𝗞𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗕𝗮𝘀𝗲) → Domain expertise and factual knowledge → Company policies, product catalogs → Doesn't change per user interaction → Implementation: Vector DB (Pinecone/Qdrant) + RAG 𝟮. 𝗘𝗽𝗶𝘀𝗼𝗱𝗶𝗰 𝗠𝗲𝗺𝗼𝗿𝘆 (𝗘𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 𝗟𝗼𝗴𝘀) → Specific past interactions and outcomes → "Last time user tried X, Y happened" → Enables learning from past actions → Implementation: Few-shot prompting + event logs 𝟯. 𝗣𝗿𝗼𝗰𝗲𝗱𝘂𝗿𝗮𝗹 𝗠𝗲𝗺𝗼𝗿𝘆 (𝗦𝗸𝗶𝗹𝗹 𝗦𝗲𝘁𝘀) → How to execute specific workflows → Learned task sequences and patterns → Improves with repetition → Implementation: Function definitions + prompt templates When processing user input, intelligent agents don't query memories in isolation: 1️⃣ Short-term provides immediate context 2️⃣ Semantic supplies relevant domain knowledge 3️⃣ Episodic recalls similar past scenarios 4️⃣ Procedural suggests proven action sequences This orchestrated approach enables agents to: - Handle complex multi-step tasks autonomously - Learn from failures without retraining - Provide contextually aware responses - Build relationships over time LangChain, LangGraph, and AutoGen all provide memory abstractions, but most developers only scratch the surface. The difference between a demo and production? Memory that actually remembers. Over to you: Which memory type is your agent missing?

The biggest limitation in today’s AI agents is not their fluency. It is memory. Most LLM-based systems forget what happened in the last session, cannot improve over time, and fail to reason across multiple steps. This makes them unreliable in real workflows. They respond well in the moment but do not build lasting context, retain task history, or learn from repeated use. A recent paper, “Rethinking Memory in AI,” introduces four categories of memory, each tied to specific operations AI agents need to perform reliably: 𝗟𝗼𝗻𝗴-𝘁𝗲𝗿𝗺 𝗺𝗲𝗺𝗼𝗿𝘆 focuses on building persistent knowledge. This includes consolidation of recent interactions into summaries, indexing for efficient access, updating older content when facts change, and forgetting irrelevant or outdated data. These operations allow agents to evolve with users, retain institutional knowledge, and maintain coherence across long timelines. 𝗟𝗼𝗻𝗴-𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 refers to techniques that help models manage large context windows during inference. These include pruning attention key-value caches, selecting which past tokens to retain, and compressing history so that models can focus on what matters. These strategies are essential for agents handling extended documents or multi-turn dialogues. 𝗣𝗮𝗿𝗮𝗺𝗲𝘁𝗿𝗶𝗰 𝗺𝗼𝗱𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 addresses how knowledge inside a model’s weights can be edited, updated, or removed. This includes fine-grained editing methods, adapter tuning, meta-learning, and unlearning. In continual learning, agents must integrate new knowledge without forgetting old capabilities. These capabilities allow models to adapt quickly without full retraining or versioning. 𝗠𝘂𝗹𝘁𝗶-𝘀𝗼𝘂𝗿𝗰𝗲 𝗺𝗲𝗺𝗼𝗿𝘆 focuses on how agents coordinate knowledge across formats and systems. It includes reasoning over multiple documents, merging structured and unstructured data, and aligning information across modalities like text and images. This is especially relevant in enterprise settings, where context is fragmented across tools and sources. Looking ahead, the future of memory in AI will focus on: • 𝗦𝗽𝗮𝘁𝗶𝗼-𝘁𝗲𝗺𝗽𝗼𝗿𝗮𝗹 𝗺𝗲𝗺𝗼𝗿𝘆: Agents will track when and where information was learned to reason more accurately and manage relevance over time. • 𝗨𝗻𝗶𝗳𝗶𝗲𝗱 𝗺𝗲𝗺𝗼𝗿𝘆: Parametric (in-model) and non-parametric (external) memory will be integrated, allowing agents to fluidly switch between what they “know” and what they retrieve. • 𝗟𝗶𝗳𝗲𝗹𝗼𝗻𝗴 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴: Agents will be expected to learn continuously from interaction without retraining, while avoiding catastrophic forgetting. • 𝗠𝘂𝗹𝘁𝗶-𝗮𝗴𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆: In environments with multiple agents, memory will need to be sharable, consistent, and dynamically synchronized across agents. Memory is not just infrastructure. It defines how your agents reason, adapt, and persist!

This is the only guide you need on AI Agent Memory 1. Stop Building Stateless Agents Like It's 2022 → Architect memory into your system from day one, not as an afterthought → Treating every input independently is a recipe for mediocre user experiences → Your agents need persistent context to compete in enterprise environments 2. Ditch the "More Data = Better Performance" Fallacy → Focus on retrieval precision, not storage volume → Implement intelligent filtering to surface only relevant historical context → Quality of memory beats quantity every single time 3. Implement Dual Memory Architecture or Fall Behind → Design separate short-term (session-scoped) and long-term (persistent) memory systems → Short-term handles conversation flow, long-term drives personalization → Single memory approach is amateur hour and will break at scale 4. Master the Three Memory Types or Stay Mediocre → Semantic memory for objective facts and user preferences → Episodic memory for tracking past actions and outcomes → Procedural memory for behavioral patterns and interaction styles 5. Build Memory Freshness Into Your Core Architecture → Implement automatic pruning of stale conversation history → Create summarization pipelines to compress long interactions → Design expiry mechanisms for time-sensitive information 6. Use RAG Principles But Think Beyond Knowledge Retrieval → Apply embedding-based search for memory recall → Structure memory with metadata and tagging systems → Remember: RAG answers questions, memory enables coherent behavior 7. Solve Real Problems Before Adding Memory Complexity → Define exactly what business problem memory will solve → Avoid the temptation to add memory because it's trendy → Problem-first architecture beats feature-first every time 8. Design for Context Length Constraints From Day One → Balance conversation depth with token limits → Implement intelligent context window management → Cost optimization matters more than perfect recall 9. Choose Storage Architecture Based on Retrieval Patterns → Vector databases for semantic similarity search → Traditional databases for structured fact storage → Graph databases for relationship-heavy memory types 10. Test Memory Systems Under Real-World Conversation Loads → Simulate multi-session user interactions during development → Measure retrieval latency under concurrent user loads → Memory that works in demos but fails in production is worthless Let me know if you've any questions 👋

95% of AI agents fail, not because the model is wrong, but because the memory is a mess. If you're building long-running agents with tools, multi-turn logic, or even basic retrieval, here's the number one thing to fix: Context hygiene. The OpenAI Agents SDK introduces session memory, but you still have to decide what to remember and what to forget. They just published a cookbook showing how to do this right. Two memory strategies, fully implemented ✅Context Trimming keeps the last N user turns ✅Context Summarization compresses older history into a structured block Both are fast to integrate, fully instrumented with logs, metadata, and token counts, and designed for tool-using agents in real-world workloads. Why this matters ❌Even GPT-5-scale windows can be poisoned by junk. ❌Redundant tools and un-curated retrieval inflate costs and cause hallucinations. ❌Poor context design breaks reasoning, handoffs, and debugging. When to use each ✅Use trimming for fast, stateless automations like CRM updates and API calls ✅Use summarizing for complex, long-lived sessions like support, analysts, or concierge flows The guide includes ✅Turn-boundary logic that preserves whole user-tool cycles ✅An evaluation playbook with LLM-as-judge, regression analysis, and transcript replays ✅A customizable summary prompt with structured fields, ordering rules, and hallucination safeguards If you want to scale AI agents in production and enterprise environments, let's chat. Follow Alex for more AI agent and automation news, and share it with your network if you think it'll be useful.

𝗠𝗲𝗺𝗼𝗿𝘆 𝗶𝘀 𝘄𝗵𝗮𝘁 𝘁𝗿𝗮𝗻𝘀𝗳𝗼𝗿𝗺𝘀 𝗰𝗼𝗻𝘃𝗲𝗿𝘀𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗔𝗜 𝗳𝗿𝗼𝗺 𝗮 𝘀𝘁𝗮𝘁𝗲𝗹𝗲𝘀𝘀 𝘁𝗼𝗼𝗹 𝗶𝗻𝘁𝗼 𝗮 𝗿𝗲𝗹𝗮𝘁𝗶𝗼𝗻𝘀𝗵𝗶𝗽 𝘁𝗵𝗮𝘁 𝗱𝗲𝗲𝗽𝗲𝗻𝘀 𝗼𝘃𝗲𝗿 𝘁𝗶𝗺𝗲. In this article I am sharing my learnings and research for building memory into AI products. I have organized into three distinct steps of memory management for agents and conversational AI assistants 𝗖𝗮𝗽𝘁𝘂𝗿𝗲 → What signals are worth remembering? Explicit preferences, observed behaviors, and carefully inferred insights flow through a selective filter. Not everything deserves to persist. 𝗥𝗲𝘁𝗲𝗻𝘁𝗶𝗼𝗻 → How does memory evolve? Hot cache for active context, cold storage for long-term knowledge, with continuous decay and reinforcement shaping what survives. 𝗥𝗲𝗰𝗮𝗹𝗹 → How is memory applied? Fast semantic search surfaces relevant context, enabling personalized responses without the system feeling intrusive. A feedback loop connects all three: what gets recalled and proves useful becomes more durable; what doesn't fades away. 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: Memory creates compounding value, healthy stickiness, and trust that competitors can't easily replicate. The full article covers capture strategies (explicit vs. implicit, real-time vs. offline), retention design (lifecycle, storage formats, user control), recall optimization (speed, relevance), and principles that make memory a relationship rather than surveillance. #Memory #ContextEngineering #Agents #AIAssistants #DesignPrinciples

We’re witnessing a shift from static models to 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀 𝘁𝗵𝗮𝘁 𝗰𝗮𝗻 𝘁𝗵𝗶𝗻𝗸, 𝗿𝗲𝗮𝘀𝗼𝗻, 𝗮𝗻𝗱 𝗮𝗰𝘁—not just respond. But with so many disciplines converging—LLMs, orchestration, memory, planning—how do you 𝗯𝘂𝗶𝗹𝗱 𝗮 𝗺𝗲𝗻𝘁𝗮𝗹 ��𝗼𝗱𝗲𝗹 to master it all? Here’s a 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱 𝗿𝗼𝗮𝗱𝗺𝗮𝗽 to navigate the Agentic AI landscape, designed for developers and builders who want to go beyond surface-level hype: ↳ 𝟭. 𝗥𝗲𝘁𝗵𝗶𝗻𝗸 𝗜𝗻𝘁𝗲𝗹𝗹𝗶𝗴𝗲𝗻𝗰𝗲: Move from model outputs to goal-driven autonomy. Understand where Agentic AI fits in the automation stack. ↳ 𝟮. 𝗚𝗿𝗼𝘂𝗻𝗱 𝗬𝗼𝘂𝗿𝘀𝗲𝗹𝗳 𝗶𝗻 𝗔𝗜/𝗠𝗟 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀: Before agents, there’s learning—deep learning, reinforcement learning, and the theories powering adaptive behavior. ↳ 𝟯. 𝗘𝘅𝗽𝗹𝗼𝗿𝗲 𝘁𝗵𝗲 𝗔𝗴𝗲𝗻𝘁 𝗧𝗲𝗰𝗵 𝗦𝘁𝗮𝗰𝗸: Dive into 𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻, 𝗔𝘂𝘁𝗼𝗚𝗲𝗻, and 𝗖𝗿𝗲𝘄𝗔𝗜—frameworks enabling coordination, planning, and tool use. ↳ 𝟰. 𝗚𝗼 𝗗𝗲𝗲𝗽 𝘄𝗶𝘁𝗵 𝗟𝗟𝗠 𝗜𝗻𝘁𝗲𝗿𝗻𝗮𝗹𝘀: Learn how tokenization, embeddings, and memory management drive better reasoning. ↳𝟱. 𝗦𝘁𝘂𝗱𝘆 𝗠𝘂𝗹𝘁𝗶-𝗔𝗴𝗲𝗻𝘁 𝗖𝗼𝗹𝗹𝗮𝗯𝗼𝗿𝗮𝘁𝗶𝗼𝗻: Agents aren’t lone wolves—they negotiate, delegate, and synchronize in distributed workflows. ↳𝟲. 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁 𝗠𝗲𝗺𝗼𝗿𝘆 + 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹: Understand how 𝗥𝗔𝗚, vector stores, and semantic indexing turn short-term chatbots into long-term thinkers. ↳𝟳. 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻-𝗠𝗮𝗸𝗶𝗻𝗴 𝗮𝘀 𝗮 𝗦𝗸𝗶𝗹𝗹: Build agents with layered planning, feedback loops, and reinforcement-based self-improvement. ↳𝟴. 𝗠𝗮𝗸𝗲 𝗣𝗿𝗼𝗺𝗽𝘁𝗶𝗻𝗴 𝗗𝘆𝗻𝗮𝗺𝗶𝗰: From few-shot to chain-of-thought, prompt engineering is the new compiler—learn to wield it with intention. ↳𝟵. 𝗥𝗲𝗶𝗻𝗳𝗼𝗿𝗰𝗲𝗺𝗲𝗻𝘁 + 𝗦𝗲𝗹𝗳-𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Agents that improve themselves aren’t science fiction—they're built on adaptive loops and human feedback. ↳𝟭𝟬. 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹-𝗔𝘂𝗴𝗺𝗲𝗻𝘁𝗲𝗱 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻: Master hybrid search and scalable retrieval pipelines for real-time, context-rich AI. ↳𝟭𝟭. 𝗧𝗵𝗶𝗻𝗸 𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁, 𝗡𝗼𝘁 𝗝𝘂𝘀𝘁 𝗗𝗲𝗺𝗼𝘀: Production-ready agents need low latency, monitoring, and integration into business workflows. 𝟭𝟮. 𝗔𝗽𝗽𝗹𝘆 𝘄𝗶𝘁𝗵 𝗣𝘂𝗿𝗽𝗼𝘀𝗲: From copilots to autonomous research assistants—Agentic AI is already solving real problems in the wild. 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗔𝗜 𝗶𝘀𝗻’𝘁 𝗷𝘂𝘀𝘁 𝗮𝗯𝗼𝘂𝘁 𝘀𝗺𝗮𝗿𝘁𝗲𝗿 𝗼𝘂𝘁𝗽𝘂𝘁𝘀—𝗶𝘁’𝘀 𝗮𝗯𝗼𝘂𝘁 𝗶𝗻𝘁𝗲𝗻𝘁𝗶𝗼𝗻𝗮𝗹, 𝗽𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝘁 𝗶𝗻𝘁𝗲𝗹𝗹𝗶𝗴𝗲𝗻𝗰𝗲. If you're serious about building the next wave of intelligent systems, this roadmap is your compass. Curious—what part of this roadmap are you diving into right now?