A real Excel file
The result is a downloadable .xlsx workbook with formulas, formatting, charts, tables, validation, and workbook metadata—not a table pasted into chat.
Production AI AgentADK-Rust v2 super agent
AI Agents Create Professional Excel Files
zSpreadsheet plans, builds, styles, calculates, previews, and versions real Excel workbooks from a conversation. The result stays visible and editable throughout the work.
Actual product captureChat · tools · live workbook
Why it is a super agent
It generates, validates, and returns a complete Excel workbook.
A basic spreadsheet assistant might answer a formula question or return a block of CSV. zSpreadsheet takes responsibility for the finished workbook: its structure, formulas, data, formatting, calculation, file creation, and the experience of reviewing it.
The agent still works inside visible boundaries. It can call only the spreadsheet tools connected to the runtime, saves into the user’s workspace, and shows its progress in the interface. The person can inspect the formula bar, edit the workbook directly, download the file, or continue the conversation.
This is what makes the product a useful ADK-Rust case study. Multiple agents, an MCP capability server, RAG, sessions, streamed events, and artifact storage are assembled around one familiar business result: a workbook someone can open and use.
Work you can watch
Tool calls stream into the conversation while progressive saves refresh the workbook preview. The person can see the artifact taking shape.
A workbook you can edit
The preview includes a formula bar and direct workbook controls. People can change cells themselves or ask the agent for another pass.
A workspace that remembers
Uploads, active workbook context, agent sessions, and immutable workbook versions remain attached to the user’s workspace.
Follow one workbook
From a prompt to a working .xlsx file.
Each stage has a clear responsibility. That separation lets developers change the planning model, workbook tools, styling policy, or storage layer without redesigning the whole product.
- 01
Describe the business outcome
Ask for a budget, forecast, pricing model, tracker, operating report, or a change to an existing workbook. Uploaded files can supply the source data.
- 02
Plan the workbook
The planner turns the request into sheets, exact cell locations, formulas, formatting rules, chart ranges, and a save destination.
- 03
Build through MCP
The writer batches values and formulas through the Excel MCP server. Independent operations can run together, reducing model and tool round trips.
- 04
Style and calculate
The styling agent applies themes, number formats, borders, tables, charts, and layout. The workbook engine recalculates formulas before saving.
- 05
Inspect, edit, and keep the artifact
The browser renders the saved workbook, evaluates formulas, supports direct edits, and records a new version without hiding the underlying .xlsx file.
Architecture
How the agent workflow connects to the workbook engine.
The browser is both a conversation interface and a workbook editor. ADK-Rust coordinates the agents and state. MCP gives those agents a controlled connection to the Excel engine that creates the final artifact.
Agent executionContext and eventsWorkbook operations and artifactsDurable state
What ADK-Rust v2 contributes
Framework capabilities used in a real product.
These are source-verified parts of the current implementation. zSpreadsheet does not claim A2A or AWP support today.
Sequential multi-agent work
Planner, writer, and styler have separate responsibilities while sharing one request and session.
Provider-aware tool schemas
ADK-Rust v2 adapts the 74 MCP tool schemas for Gemini, OpenAI, Anthropic, or DeepSeek at request time.
Current Rust MCP SDK
The application uses ADK-Rust’s rmcp 2.2 re-export, keeping its client and framework on one protocol version.
Recoverable MCP connection
A connection factory and bounded retry policy can replace the child-process connection when transport failure is recoverable.
Parallel tool batches
The writer and styler can execute independent workbook operations together while dependent work remains ordered.
Durable conversation state
PostgreSQL stores sessions and events; context compaction keeps longer spreadsheet conversations usable.
Workspace-grounded requests
ADK-Rust RAG searches uploaded workbook and CSV content before the request reaches the agent workflow.
Typed progress events
Agent text, thinking, tool calls, tool results, and completion events become the SSE stream shown in the product UI.
The Rust behind the product
Composable workflows with ADK-Rust.
The root agent is a sequential workflow, while the Runner attaches sessions and compaction. The Excel tools arrive through a reconnectable MCP client instead of being hard-coded into the agents.
Read the complete implementation ↗agent.rs · workflow and runner
let pipeline = SequentialAgent::new(
"spreadsheet_builder",
vec![
Arc::new(planner),
Arc::new(writer),
Arc::new(styler),
],
);
let runner = Runner::builder()
.app_name("excel_agent")
.agent(Arc::new(pipeline))
.session_service(postgres_sessions)
.compaction_config(compaction)
.build()?;mcp.rs · recoverable tool connection
let client = ().serve(
TokioChildProcess::new(Command::new(excel_mcp_server))?
).await?;
let tools = McpToolset::new(client)
.with_connection_factory(factory)
.with_refresh_config(
RefreshConfig::default().with_max_attempts(3)
);Current product boundary
What works now, and what remains.
Available today
- ●Create and modify real .xlsx files
- ●74 Excel MCP operations
- ●Live workbook and formula preview
- ●Direct cell and workbook controls
- ●Workspace uploads and RAG search
- ●PostgreSQL sessions and workbook versions
Still being completed
- ●Full visual rendering for every pivot configuration
- ●Direct UI contracts for every advanced chart feature
- ●Team collaboration and sharing permissions
Try the outcome
Ask for the workbook you actually need.
Start with a business request, watch the agents build it through MCP, inspect the formulas and formatting, then keep the resulting Excel file.