724-office: 7/24 Office: The Zero-Framework Ghost in the Machine

How 3,500 lines of pure Python created an autonomous agent that writes its own tools and manages its own uptime.

A mechanical arm using a soldering iron to repair its own circuitry, representing the self-evolving nature of the 7/24 Office agent. — Instead of waiting for a developer to patch bugs, 7/24 Office identifies missing capabilities and writes the Python code to fix itself.

A production-running AI agent built in **~3,500 lines of pure Python** with **zero framework dependency**. No LangChain, no LlamaIndex, no CrewAI -- just the standard library + 3 small packages (`croniter`, `lancedb`, `websocket-client`).

wangziqi06, Project Creator · wangziqi06/724-office

Key Takeaways

The agent operates in a meta-loop that writes and hot-loads its own Python tools to fix bugs or add missing capabilities at runtime.
A zero-framework architecture allows the system to run on edge devices like the Jetson Orin Nano with less than 2GB of RAM.
The system maintains long-term context through a three-layer memory model that compresses session history into searchable vector facts.
A cellular Docker-based router scales the project by isolating every user into a private, containerized workspace.

The Agent That Fixes Itself

The AI agent framework era has become bloated with abstractions that often obscure the simple loop of reasoning and tool use. 7/24 Office is a rebellion against this complexity. It proves that a production-grade, autonomous agent capable of self-repair can exist without heavy dependencies. The most radical feature is its ability to diagnose and fix itself.

Through a mechanism called `create_tool`, the agent operates in a meta-loop. When it identifies a missing capability or a bug, it writes the necessary Python fix, saves it to the local filesystem, and hot-loads it into its own environment while you sleep.

The 3,500-Line Rebellion

By eschewing popular libraries like LangChain or CrewAI in favor of the Python Standard Library, the project achieves remarkable hardware efficiency. It is designed to run on edge devices like the Jetson Orin Nano with a RAM budget under 2GB. This zero-framework philosophy reduces latency and makes debugging trivial.

Feature	7/24 Office	Traditional Frameworks
Dependencies	Near zero (Standard Library + 3 packages)	Heavy (LangChain, CrewAI)
Extensibility	Runtime exec and MCP	Static Class inheritance
Deployment	Docker-native multi-tenancy	Single-process scripts

A Three-Layered Mind

To maintain continuous context without hitting token limits, the system uses a sophisticated three-layer memory architecture located in `memory.py`. It transitions from raw session history to LLM-compressed facts, and finally to LanceDB vector retrieval. This allows for active recall of long-term context.

The three-stage memory pipeline compresses raw conversation history into searchable vector facts.

Cellular Scaling

The system scales through a Docker-based cellular approach managed by `router.py`. Every user is treated as an isolated containerized instance with its own workspace. This SaaS-in-a-box architecture ensures data privacy between different owners and prevents a single user from crashing the host.

The router dynamically provisions and routes requests to isolated user containers.

The Open Extension

To remain extensible without bloating the core, 7/24 Office leverages the Model Context Protocol (MCP). The agent uses `mcp_client.py` to communicate with external tool servers via JSON-RPC. This allows it to seamlessly integrate with databases, search engines, and other services without adding new dependencies.

A single electrical plug with dozens of adapter heads floating around it, representing extensibility. — The Model Context Protocol allows the agent to plug into external systems without bloating its core codebase.