diff --git a/tools/aconfig/src/aconfig.rs b/tools/aconfig/src/aconfig.rs
index a6e1d1b..41815b7 100644
--- a/tools/aconfig/src/aconfig.rs
+++ b/tools/aconfig/src/aconfig.rs
@@ -26,6 +26,7 @@
 }
 
 impl Flag {
+    #[allow(dead_code)] // only used in unit tests
     pub fn try_from_text_proto(text_proto: &str) -> Result<Flag> {
         let proto: ProtoFlag = crate::protos::try_from_text_proto(text_proto)
             .with_context(|| text_proto.to_owned())?;
@@ -63,6 +64,7 @@
 }
 
 impl Override {
+    #[allow(dead_code)] // only used in unit tests
     pub fn try_from_text_proto(text_proto: &str) -> Result<Override> {
         let proto: ProtoOverride = crate::protos::try_from_text_proto(text_proto)?;
         proto.try_into()
diff --git a/tools/aconfig/src/cache.rs b/tools/aconfig/src/cache.rs
new file mode 100644
index 0000000..d60cc20
--- /dev/null
+++ b/tools/aconfig/src/cache.rs
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use anyhow::{anyhow, Result};
+use serde::{Deserialize, Serialize};
+use std::io::{Read, Write};
+
+use crate::aconfig::{Flag, Override};
+use crate::commands::Source;
+
+#[derive(Serialize, Deserialize)]
+pub struct Value {
+    pub value: bool,
+    pub source: Source,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Item {
+    pub id: String,
+    pub description: String,
+    pub values: Vec<Value>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Cache {
+    items: Vec<Item>,
+}
+
+impl Cache {
+    pub fn new() -> Cache {
+        Cache { items: vec![] }
+    }
+
+    pub fn read_from_reader(reader: impl Read) -> Result<Cache> {
+        serde_json::from_reader(reader).map_err(|e| e.into())
+    }
+
+    pub fn write_to_writer(&self, writer: impl Write) -> Result<()> {
+        serde_json::to_writer(writer, self).map_err(|e| e.into())
+    }
+
+    pub fn add_flag(&mut self, source: Source, flag: Flag) -> Result<()> {
+        if let Some(existing_item) = self.items.iter().find(|&item| item.id == flag.id) {
+            return Err(anyhow!(
+                "failed to add flag {} from {}: already added from {}",
+                flag.id,
+                source,
+                existing_item.values.first().unwrap().source
+            ));
+        }
+        self.items.push(Item {
+            id: flag.id.clone(),
+            description: flag.description.clone(),
+            values: vec![Value { value: flag.value, source }],
+        });
+        Ok(())
+    }
+
+    pub fn add_override(&mut self, source: Source, override_: Override) -> Result<()> {
+        let Some(existing_item) = self.items.iter_mut().find(|item| item.id == override_.id) else {
+            return Err(anyhow!("failed to override flag {}: unknown flag", override_.id));
+        };
+        existing_item.values.push(Value { value: override_.value, source });
+        Ok(())
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &Item> {
+        self.items.iter()
+    }
+}
+
+impl Item {
+    pub fn value(&self) -> bool {
+        self.values.last().unwrap().value
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add_flag() {
+        let mut cache = Cache::new();
+        cache
+            .add_flag(
+                Source::File("first.txt".to_string()),
+                Flag { id: "foo".to_string(), description: "desc".to_string(), value: true },
+            )
+            .unwrap();
+        let error = cache
+            .add_flag(
+                Source::File("second.txt".to_string()),
+                Flag { id: "foo".to_string(), description: "desc".to_string(), value: false },
+            )
+            .unwrap_err();
+        assert_eq!(
+            &format!("{:?}", error),
+            "failed to add flag foo from second.txt: already added from first.txt"
+        );
+    }
+
+    #[test]
+    fn test_add_override() {
+        fn get_value(cache: &Cache, id: &str) -> bool {
+            cache.iter().find(|&item| item.id == id).unwrap().value()
+        }
+
+        let mut cache = Cache::new();
+        let error = cache
+            .add_override(Source::Memory, Override { id: "foo".to_string(), value: false })
+            .unwrap_err();
+        assert_eq!(&format!("{:?}", error), "failed to override flag foo: unknown flag");
+
+        cache
+            .add_flag(
+                Source::File("first.txt".to_string()),
+                Flag { id: "foo".to_string(), description: "desc".to_string(), value: true },
+            )
+            .unwrap();
+        assert!(get_value(&cache, "foo"));
+
+        cache
+            .add_override(Source::Memory, Override { id: "foo".to_string(), value: false })
+            .unwrap();
+        assert!(!get_value(&cache, "foo"));
+
+        cache
+            .add_override(Source::Memory, Override { id: "foo".to_string(), value: true })
+            .unwrap();
+        assert!(get_value(&cache, "foo"));
+    }
+}
diff --git a/tools/aconfig/src/commands.rs b/tools/aconfig/src/commands.rs
new file mode 100644
index 0000000..0e377aa
--- /dev/null
+++ b/tools/aconfig/src/commands.rs
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use anyhow::{Context, Result};
+use clap::ValueEnum;
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::io::Read;
+
+use crate::aconfig::{Flag, Override};
+use crate::cache::Cache;
+
+#[derive(Clone, Serialize, Deserialize)]
+pub enum Source {
+    #[allow(dead_code)] // only used in unit tests
+    Memory,
+    File(String),
+}
+
+impl fmt::Display for Source {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Memory => write!(f, "<memory>"),
+            Self::File(path) => write!(f, "{}", path),
+        }
+    }
+}
+
+pub struct Input {
+    pub source: Source,
+    pub reader: Box<dyn Read>,
+}
+
+pub fn create_cache(aconfigs: Vec<Input>, overrides: Vec<Input>) -> Result<Cache> {
+    let mut cache = Cache::new();
+
+    for mut input in aconfigs {
+        let mut contents = String::new();
+        input.reader.read_to_string(&mut contents)?;
+        let flags = Flag::try_from_text_proto_list(&contents)
+            .with_context(|| format!("Failed to parse {}", input.source))?;
+        for flag in flags {
+            cache.add_flag(input.source.clone(), flag)?;
+        }
+    }
+
+    for mut input in overrides {
+        let mut contents = String::new();
+        input.reader.read_to_string(&mut contents)?;
+        let overrides = Override::try_from_text_proto_list(&contents)
+            .with_context(|| format!("Failed to parse {}", input.source))?;
+        for override_ in overrides {
+            cache.add_override(input.source.clone(), override_)?;
+        }
+    }
+
+    Ok(cache)
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, ValueEnum)]
+pub enum Format {
+    Text,
+    Debug,
+}
+
+pub fn dump_cache(cache: Cache, format: Format) -> Result<()> {
+    match format {
+        Format::Text => {
+            for item in cache.iter() {
+                println!("{}: {}", item.id, item.value());
+            }
+        }
+        Format::Debug => {
+            for item in cache.iter() {
+                println!("{}: {}", item.id, item.value());
+                for value in &item.values {
+                    println!("    {}: {}", value.source, value.value);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_cache() {
+        let s = r#"
+        flag {
+            id: "a"
+            description: "Description of a"
+            value: true
+        }
+        "#;
+        let aconfigs = vec![Input { source: Source::Memory, reader: Box::new(s.as_bytes()) }];
+        let o = r#"
+        override {
+            id: "a"
+            value: false
+        }
+        "#;
+        let overrides = vec![Input { source: Source::Memory, reader: Box::new(o.as_bytes()) }];
+        let cache = create_cache(aconfigs, overrides).unwrap();
+        let value = cache.iter().find(|&item| item.id == "a").unwrap().value();
+        assert!(!value);
+    }
+}
diff --git a/tools/aconfig/src/main.rs b/tools/aconfig/src/main.rs
index 9d87ca4..79ac920 100644
--- a/tools/aconfig/src/main.rs
+++ b/tools/aconfig/src/main.rs
@@ -17,22 +17,67 @@
 //! `aconfig` is a build time tool to manage build time configurations, such as feature flags.
 
 use anyhow::Result;
+use clap::{builder::ArgAction, builder::EnumValueParser, Arg, Command};
+use std::fs;
 
 mod aconfig;
+mod cache;
+mod commands;
 mod protos;
 
-use aconfig::{Flag, Override};
+use crate::cache::Cache;
+use commands::{Input, Source};
+
+fn cli() -> Command {
+    Command::new("aconfig")
+        .subcommand_required(true)
+        .subcommand(
+            Command::new("create-cache")
+                .arg(Arg::new("aconfig").long("aconfig").action(ArgAction::Append))
+                .arg(Arg::new("override").long("override").action(ArgAction::Append))
+                .arg(Arg::new("cache").long("cache").required(true)),
+        )
+        .subcommand(
+            Command::new("dump").arg(Arg::new("cache").long("cache").required(true)).arg(
+                Arg::new("format")
+                    .long("format")
+                    .value_parser(EnumValueParser::<commands::Format>::new())
+                    .default_value("text"),
+            ),
+        )
+}
 
 fn main() -> Result<()> {
-    let flag = Flag::try_from_text_proto(r#"id: "a" description: "description of a" value: true"#)?;
-    println!("{:?}", flag);
-    let flags = Flag::try_from_text_proto_list(
-        r#"flag { id: "a" description: "description of a" value: true }"#,
-    )?;
-    println!("{:?}", flags);
-    let override_ = Override::try_from_text_proto(r#"id: "foo" value: true"#)?;
-    println!("{:?}", override_);
-    let overrides = Override::try_from_text_proto_list(r#"override { id: "foo" value: true }"#)?;
-    println!("{:?}", overrides);
+    let matches = cli().get_matches();
+    match matches.subcommand() {
+        Some(("create-cache", sub_matches)) => {
+            let mut aconfigs = vec![];
+            for path in
+                sub_matches.get_many::<String>("aconfig").unwrap_or_default().collect::<Vec<_>>()
+            {
+                let file = Box::new(fs::File::open(path)?);
+                aconfigs.push(Input { source: Source::File(path.to_string()), reader: file });
+            }
+            let mut overrides = vec![];
+            for path in
+                sub_matches.get_many::<String>("override").unwrap_or_default().collect::<Vec<_>>()
+            {
+                let file = Box::new(fs::File::open(path)?);
+                overrides.push(Input { source: Source::File(path.to_string()), reader: file });
+            }
+            let cache = commands::create_cache(aconfigs, overrides)?;
+            let path = sub_matches.get_one::<String>("cache").unwrap();
+            let file = fs::File::create(path)?;
+            cache.write_to_writer(file)?;
+        }
+        Some(("dump", sub_matches)) => {
+            let path = sub_matches.get_one::<String>("cache").unwrap();
+            let file = fs::File::open(path)?;
+            let cache = Cache::read_from_reader(file)?;
+            let format = sub_matches.get_one("format").unwrap();
+            commands::dump_cache(cache, *format)?;
+        }
+        _ => unreachable!(),
+    }
     Ok(())
 }